Variables et types de données dans 1C : ce qui est stocké en mémoire et pourquoi c'est important

Lorsque vous écrivez du code dans le langage intégré 1C, chaque valeur, qu'il s'agisse d'un nombre, d'une chaîne ou d'une référence à un élément de répertoire, réside quelque part. Elle prend de la place dans la mémoire vive, a un certain type et obéit à des règles spécifiques. Compréhension comment les variables et les types de données sont organisés dans 1C, c'est la base, sans lequel il est impossible d'écrire un code fiable et productif. Dans cet article, nous allons tout analyser dans l'ordre : de la déclaration des variables aux subtilités du travail avec les types composites.

Qu'est-ce qu'une variable dans 1C ?

Une variable est une zone de mémoire nommée dans laquelle une valeur est stockée. Dans 1C, les variables sont typées dynamiquement : vous n'avez pas besoin de spécifier à l'avance quel type de données y sera contenu. Une même variable peut d'abord contenir un nombre, puis une chaîne, puis une date.

Vous pouvez déclarer une variable explicitement en utilisant le mot-clé Перем, ou implicitement, en lui attribuant simplement une valeur :

// Déclaration explicite de la variable Compteur ;

// Déclaration implicite par affectation
Счётчик = 0;
Имя = "Alexey";
ДатаНачала = '20250101';

Si une variable est déclarée via Перем, mais qu'elle n'a pas encore été assignée, elle contient une valeur spéciale Неопределено. C'est un point important : Неопределено n'est pas zéro, pas une chaîne vide et pas une erreur. Il s'agit d'un type de données indépendant, qui signifie qu'il n'y a pas de valeur.

Portée : où la variable vit

Dans 1C, il existe trois niveaux de visibilité des variables.

Variables du module sont déclarées au tout début du module (avant les procédures et les fonctions) via Перем. Elles sont accessibles à partir de n'importe quelle procédure et fonction de ce module et existent tant que le module lui-même existe. C'est un analogue des variables globales à l'intérieur d'un objet.

Variables locales sont créés à l'intérieur d'une procédure ou d'une fonction. Ils naissent à l'appel et meurent à la sortie. La mémoire qu'ils occupaient est libérée automatiquement.

Variables d'exportation — ce sont les variables du module marquées avec le mot-clé Экспорт. Elles sont accessibles de l'extérieur, à partir d'autres modules et formulaires :

Перем ГлобальнаяНастройка Экспорт;

Conseil : Si vous stockez un grand tableau de valeurs dans une variable de module, il restera en mémoire pendant toute la durée de vie du formulaire ou du traitement. Une variable locale à l'intérieur d'une procédure est un choix beaucoup plus sûr si les données ne sont nécessaires que pendant l'exécution.

Types de données primitifs

La plateforme 1C fournit plusieurs types de base (primitifs) qui sont les blocs de construction pour tout le reste.

Nombre — stocke des nombres entiers et fractionnaires. Le nombre maximal de caractères est de 38, dont 10 peuvent être après la virgule. 1C utilise l'arithmétique décimale, pas la virgule flottante binaire comme la plupart des langages de programmation. Cela signifie que 0.1 + 0.2 dans 1C donnera exactement 0.3, et non 0.30000000000000004, comme dans JavaScript ou Python. Pour les calculs financiers, il s'agit d'une propriété critique :

Цена = 1500.50;
Количество = 3;
Сумма = Цена * Количество; // 4501.50 — exactement, sans erreur

Ligne — séquence de caractères encodés en UTF-16. Les chaînes en 1C sont immuables : chaque opération de concaténation crée une nouvelle chaîne en mémoire. Si vous collez des milliers de lignes dans une boucle, chaque itération génère un nouvel objet et l'ancien attend le ramasse-miettes. Pour l'assemblage de texte en masse, il est préférable d'utiliser l'entrée dans ТекстовыйДокумент ou de former des parties dans un tableau, puis de les combiner :

// Mauvais - complexité quadratique en mémoire
Результат = "";
Для Каждого Элемент Из Коллекция Цикл
    Результат = Результат + Элемент + ", ";
КонецЦикла;

// Mieux - la complexité linéaire
Части = Новый Массив;
Для Каждого Элемент Из Коллекция Цикл
    Части.Добавить(Элемент);
КонецЦикла;
Результат = СтрСоединить(Части, ", ");

Date — stocke la date et l'heure à la seconde près. Une date vide est '00010101', pas Неопределено. C'est une source fréquente d'erreurs : la vérification Если Дата = Неопределено ne détectera pas une date vide. Vérification correcte :

Если ДатаДокумента = '00010101' Тогда
    // Date non renseignée Fin Si ;

Booléen — prend les valeurs Истина ou Ложь. En termes conditionnels, 1C n'effectue pas de conversion de type implicite : le nombre 0 ne se transforme pas automatiquement en Ложь, comme en JavaScript. Il faut écrire une comparaison explicite.

Indéfini — un type spécial avec une seule valeur. Utilisé comme marqueur d'absence de valeur, il est renvoyé lors de l'accès à une clé de correspondance inexistante, lors de la lecture de détails vides et dans d'autres situations similaires.

Null — un autre type spécial associé aux bases de données. Il apparaît lorsque vous travaillez avec les résultats de la requête, lorsque la connexion de gauche est utilisée et qu'il n'y a pas d'entrée correspondante dans la table jointe. Null et Неопределено sont des choses différentes, et vous ne devriez pas les confondre.

Types de référence : qu'est-ce qui se trouve réellement dans la variable ?

Lorsque vous recevez un élément de répertoire ou un document, la variable ne stocke pas l'objet entier, mais un lien — un identifiant unique (UUID) par lequel la plateforme peut trouver des données dans la base de données :

СсылкаНаТовар = Справочники.Товары.НайтиПоКоду("00001");

La variable СсылкаНаТовар contient un lien de type СправочникСсылка.Товары. C'est un objet compact, en fait, un wrapper sur le GUID. Les données elles-mêmes (nom, prix, soldes) ne sont pas chargées en mémoire. Elles ne seront extraites de la base de données que lors de la première référence au réquisit :

// C'est ici que la base de données est consultée
Наименование = СсылкаНаТовар.Наименование;

C'est ce qu'on appelle le chargement paresseux (lazy loading), et il a un inconvénient. Si vous parcourez mille liens dans une boucle et que vous lisez les détails de chacun d'eux via un point, la plateforme effectuera mille requêtes distinctes à la base de données. La bonne solution est de recevoir des données par lots via une requête :

// Mauvais — 1000 appels à la base de données Pour chaque lien du tableau de liens Cycle
    Наименование = Ссылка.Наименование; // requête à la base de données à chaque itération de la fin du cycle ;

// Bon - 1 requête à la base de données
Запрос = Новый Запрос;
Запрос.Текст = "SELECT Name FROM Reference.Book.Products WHERE Link (&List)";
Запрос.УстановитьПараметр("List", МассивСсылок);
Результат = Запрос.Выполнить().Выгрузить();

Important : Le lien (СправочникСсылка) est un « pointeur » vers des données en lecture seule. Un objet (СправочникОбъект) est une copie complète des données chargées en mémoire qui peuvent être modifiées et écrites. L'objet est plus lourd que le lien. Si vous recevez des objets dans une boucle, mais que vous n'avez pas l'intention de les modifier, utilisez des liens et des requêtes.

// Nous obtenons l'objet - toutes les données sont chargées en mémoire
ОбъектТовара = СсылкаНаТовар.ПолучитьОбъект();
ОбъектТовара.Наименование = "New name";
ОбъектТовара.Записать();

Type composite : un champ, de nombreuses possibilités

Dans les métadonnées 1C, l'attribut peut avoir un type composite. Par exemple, le champ « Propriétaire » dans un document peut être à la fois de type СправочникСсылка.Организации et СправочникСсылка.ФизическиеЛица. La plate-forme stocke dans ce champ la valeur elle-même et les informations sur son type.

Pour travailler avec des types composites, on utilise l'objet ОписаниеТипов :

МассивТипов = Новый Массив;
МассивТипов.Добавить(Тип("Number"));
МассивТипов.Добавить(Тип("Line"));

ОписаниеДопустимыхТипов = Новый ОписаниеТипов(МассивТипов);

Vous pouvez vérifier le type de valeur actuel dans la variable avec la fonction ТипЗнч() :

Если ТипЗнч(Значение) = Тип("Number") Тогда
    // Nous travaillons comme avec un nombre Sinon Si TypeZnch (Valeur) = Type ("RéférenceLien.Marchandises") Alors    // Nous travaillons comme avec un lien Fin Si ;

Les types composites sont pratiques, mais ils ont leur prix. Dans la base de données, un champ avec un type composite est stocké de manière moins efficace qu'un champ avec un type fixe. Si le champ contient toujours une valeur d'un type, il est préférable de l'indiquer dans le configurateur — cela permettra d'économiser de l'espace et d'accélérer les requêtes.

Collections : tableaux, structures et correspondances

En plus des types primitifs et de référence, 1C dispose d'un ensemble de collections universelles qui sont utilisées partout.

Tableau — un ensemble ordonné de valeurs avec accès par index. L'indexation commence à zéro. Peut contenir des éléments de tous types en même temps :

Список = Новый Массив;
Список.Добавить(42);
Список.Добавить("text");
Список.Добавить(ТекущаяДата());

Structure — un ensemble de paires « clé-valeur », où les clés sont les lignes spécifiées lors de la création. La structure est pratique pour le transfert de paramètres nommés :

Параметры = Новый Структура;
Параметры.Вставить("Organization", СсылкаОрганизации);
Параметры.Вставить("Period", ТекущаяДата());

Conformité — également des paires « clé-valeur », mais la clé peut être une valeur de n'importe quel type, y compris des liens. La correspondance fonctionne comme une table de hachage :

КэшНаименований = Новый Соответствие;
КэшНаименований.Вставить(СсылкаНаТовар, "Milk 3.2%");
Наименование = КэшНаименований.Получить(СсылкаНаТовар); // « Lait 3,2 % »

Nuance : La méthode Получить de la correspondance renvoie Неопределено si la clé n'est pas trouvée, mais ne provoque pas d'erreur. Ceci doit être pris en compte lors de la rédaction des conditions.

Tableau des valeurs - la collection la plus puissante de 1C. En fait, il s'agit d'une table temporaire en mémoire avec des lignes et des colonnes typées. Les tableaux de valeurs sont activement utilisés pour le traitement des données, la génération de rapports et l'échange entre les modules :

ТЗ = Новый ТаблицаЗначений;
ТЗ.Колонки.Добавить("Product", Новый ОписаниеТипов("ReferenceLink.Products"));
ТЗ.Колонки.Добавить("Quantity", Новый ОписаниеТипов("Number"));

НоваяСтрока = ТЗ.Добавить();
НоваяСтрока.Товар = СсылкаНаТовар;
НоваяСтрока.Количество = 10;

Une table de valeurs peut prendre beaucoup de mémoire. Si vous téléchargez le résultat d'une requête avec un million de lignes, toutes ces informations seront dans la mémoire vive du serveur. Pour de grands volumes de données, il est préférable de traiter le résultat de la requête par portions via Выборка, et de ne pas tout charger dans le tableau à la fois.

Types de conversion et pièges

1C effectue une conversion de type implicite dans certaines opérations, ce qui peut entraîner des résultats inattendus :

// Ligne + Nombre - il y aura une erreur !
Результат = "Total: " + 100; // Erreur de type

// Correct — conversion explicite
Результат = "Total: " + Строка(100); // « Total : 100 »

// Comparaison de différents types Si 0 = Faux Alors // Faux - les types ne correspondent pas Fin Si ;

Если 0 = "" Тогда     // Aussi Mensonge Fin Si ;

Les fonctions de conversion explicite sont vos amies : Число(), Строка(), Дата(), Булево(). Utilisez-les chaque fois que vous devez convertir une valeur et ne comptez pas sur l'automatisation de la plateforme.

Transfert de paramètres : par valeur et par référence

Dans 1C, les paramètres des procédures et des fonctions sont transmis par référence par défaut. Cela signifie que si vous passez un tableau à une procédure et y ajoutez des éléments, le code appelant verra ces changements :

Процедура ДобавитьЭлемент(МойМассив)
    МойМассив.Добавить("new item");
КонецПроцедуры

Данные = Новый Массив;
ДобавитьЭлемент(Данные);
// Les données contiennent désormais un « nouvel élément »

Si vous souhaitez protéger l'original des modifications, utilisez le mot-clé Знач :

Процедура БезопаснаяОбработка(Знач МойМассив)
    МойМассив.Добавить("this will not affect the original");
КонецПроцедуры

Cependant, pour les types primitifs (nombre, chaîne, date, booléen), le transfert « par référence » fonctionne différemment : la réaffectation d'un paramètre à l'intérieur d'une procédure n'affecte pas la variable externe. Les modifications ne sont visibles que pour les objets mutables : tableaux, structures, tableaux de valeurs.

Pourquoi tout cela est-il important ?

Comprendre les variables et les types de données n'est pas un exercice académique. Cela affecte directement la qualité de votre code. Savoir que les chaînes sont immuables vous évitera de créer des milliers d'objets intermédiaires en mémoire. Comprendre la différence entre une référence et un objet empêchera des centaines de requêtes de base de données inutiles. Comprendre le fonctionnement des types composites vous aidera à concevoir correctement la structure des métadonnées. Et une idée claire de la portée vous évitera les fuites de mémoire dans le code du serveur.

Chaque fois que vous déclarez une variable, vous prenez une décision architecturale : quoi stocker, où stocker et pendant combien de temps. Mieux vous comprendrez la mécanique interne de la plateforme, plus votre code sera fiable et efficace.

Si vous souhaitez apprendre la programmation de manière systématique, des bases aux sujets avancés, consultez l'application Code. Il s'agit d'une plateforme éducative avec des cours étape par étape sur Python, JavaScript, HTML, CSS et d'autres langages, qui vous aidera à construire une base de connaissances solide.

Et si vous avez des questions ou si vous souhaitez discuter du matériel avec d'autres développeurs, rejoignez notre Chaîne Telegram, où plus de 2 000 participants partagent leur expérience et s'entraident pour se développer professionnellement.