Variablen und Datentypen in 1C: Was im Speicher gespeichert wird und warum es wichtig ist

Wenn Sie Code in der integrierten 1C-Sprache schreiben, lebt jeder Wert - sei es eine Zahl, eine Zeichenfolge oder ein Verweis auf ein Verzeichniselement - irgendwo. Er nimmt Platz im RAM ein, hat einen bestimmten Typ und unterliegt bestimmten Regeln. Verständnis wie Variablen und Datentypen in 1C aufgebaut sind, ist die Grundlage, ohne die es unmöglich ist, zuverlässigen und produktiven Code zu schreiben. In diesem Artikel werden wir alles der Reihe nach analysieren: von der Deklaration von Variablen bis zu den Feinheiten der Arbeit mit zusammengesetzten Typen.

Was ist eine Variable in 1C?

Eine Variable ist ein benannter Speicherbereich, in dem ein Wert gespeichert ist. In 1C werden Variablen dynamisch typisiert: Sie müssen nicht im Voraus angeben, welcher Datentyp darin enthalten sein wird. Dieselbe Variable kann zuerst eine Zahl, dann eine Zeichenfolge und dann ein Datum enthalten.

Sie können eine Variable explizit mit dem Schlüsselwort Перем deklarieren oder implizit, indem Sie ihr einfach einen Wert zuweisen:

// Explizite Deklaration von Variablen Zähler;

// Implizite Deklaration durch Zuweisung
Счётчик = 0;
Имя = "Alexey";
ДатаНачала = '20250101';

Wenn eine Variable durch Перем deklariert wird, aber noch keinen Wert zugewiesen hat, enthält sie einen speziellen Wert Неопределено. Dies ist ein wichtiger Punkt: Неопределено ist keine Null, keine leere Zeile und kein Fehler. Dies ist ein eigenständiger Datentyp, der bedeutet, dass kein Wert vorhanden ist.

Geltungsbereich: Wo die Variable lebt

In 1C gibt es drei Ebenen der Sichtbarkeit von Variablen.

Modulvariablen werden ganz am Anfang des Moduls (vor Prozeduren und Funktionen) durch Перем deklariert. Sie sind von jeder Prozedur und Funktion dieses Moduls aus verfügbar und existieren, solange das Modul selbst existiert. Dies ist ein Analogon zu globalen Variablen innerhalb eines Objekts.

Lokale Variablen werden innerhalb einer Prozedur oder Funktion erstellt. Sie werden beim Aufruf geboren und sterben beim Verlassen. Der von ihnen belegte Speicher wird automatisch freigegeben.

Exportvariablen - Dies sind die Variablen des Moduls, die mit dem Schlüsselwort Экспорт gekennzeichnet sind. Sie sind von außen zugänglich - aus anderen Modulen und Formularen:

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

Tipp: Wenn Sie eine große Tabelle mit Werten in einer Modulvariablen speichern, bleibt sie für die gesamte Lebensdauer des Formulars oder der Verarbeitung im Speicher. Eine lokale Variable innerhalb einer Prozedur ist eine viel sicherere Wahl, wenn die Daten nur zur Laufzeit benötigt werden.

Primitive Datentypen

Die 1C-Plattform bietet mehrere grundlegende (primitive) Typen, die die Bausteine für alles andere sind.

Anzahl - speichert ganze und gebrochene Zahlen. Die maximale Länge beträgt 38 Zeichen, von denen bis zu 10 nach dem Komma stehen können. 1C verwendet Dezimalarithmetik, nicht Gleitkomma-Binärarithmetik wie die meisten Programmiersprachen. Dies bedeutet, dass 0.1 + 0.2 in 1C genau 0.3 ergibt, nicht 0.30000000000000004, wie in JavaScript oder Python. Für Finanzberechnungen ist dies eine kritische Eigenschaft:

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

Zeile - Zeichenfolge in UTF-16-Kodierung. Zeilen in 1C sind unveränderlich: Jede Verkettungsoperation erzeugt eine neue Zeile im Speicher. Wenn Sie Tausende von Zeilen in einer Schleife zusammenfügen, erzeugt jede Iteration ein neues Objekt und das alte wartet auf den Garbage Collector. Für die Massenmontage von Text ist es besser, den Eintrag in ТекстовыйДокумент zu verwenden oder Teile in einem Array zu bilden und dann zu kombinieren:

// Schlecht — quadratische Komplexität im Speicher
Результат = "";
Для Каждого Элемент Из Коллекция Цикл
    Результат = Результат + Элемент + ", ";
КонецЦикла;

// Besser — lineare Komplexität
Части = Новый Массив;
Для Каждого Элемент Из Коллекция Цикл
    Части.Добавить(Элемент);
КонецЦикла;
Результат = СтрСоединить(Части, ", ");

Datum — speichert Datum und Uhrzeit auf die Sekunde genau. Ein leeres Datum ist '00010101', nicht Неопределено. Dies ist eine häufige Fehlerquelle: Die Prüfung Если Дата = Неопределено erfasst kein leeres Datum. Richtige Prüfung:

Если ДатаДокумента = '00010101' Тогда
    // Datum nicht ausgefüllt Ende Wenn;

Bulewo - nimmt die Werte Истина oder Ложь an. In bedingten Ausdrücken führt 1C keine implizite Typkonvertierung durch: Die Zahl 0 wird nicht automatisch in Ложь konvertiert, wie in JavaScript. Es ist notwendig, einen expliziten Vergleich zu schreiben.

Nicht definiert - ein spezieller Typ mit einem einzigen Wert. Wird als Marker für fehlende Werte verwendet, wird zurückgegeben, wenn auf einen nicht vorhandenen Übereinstimmungsschlüssel zugegriffen wird, beim Lesen leerer Details und in anderen ähnlichen Situationen.

Null - ein weiterer spezieller Typ, der mit Datenbanken verbunden ist. Erscheint bei der Arbeit mit Abfrageergebnissen, wenn die linke Verbindung verwendet wird und es keinen entsprechenden Eintrag in der zu verknüpfenden Tabelle gibt. Null und Неопределено sind verschiedene Dinge und sollten nicht verwechselt werden.

Referenztypen: Was liegt eigentlich in der Variable?

Wenn Sie ein Verzeichnis-Element oder Dokument erhalten, speichert die Variable nicht das gesamte Objekt, sondern einen Link - eine eindeutige Kennung (UUID), anhand derer die Plattform Daten in der Datenbank finden kann:

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

Die Variable СсылкаНаТовар enthält einen Link vom Typ СправочникСсылка.Товары. Dies ist ein kompaktes Objekt - im Grunde ein Wrapper über einer GUID. Die Daten selbst (Name, Preis, Rest) werden nicht in den Speicher geladen. Sie werden nur beim ersten Zugriff auf die Requisite aus der Datenbank abgerufen:

// Hier wird auf die Datenbank zugegriffen
Наименование = СсылкаНаТовар.Наименование;

Dies wird als Lazy Loading bezeichnet und hat eine Kehrseite. Wenn Sie in einer Schleife tausend Links durchlaufen und die Requisiten jedes Links über einen Punkt lesen, führt die Plattform tausend separate Abfragen an die Datenbank aus. Die richtige Lösung besteht darin, Daten in einem Paket über eine Anfrage zu erhalten:

// Schlecht - 1000 Zugriffe auf die Datenbank Für jeden Link Aus Array Links Zyklus
    Наименование = Ссылка.Наименование; // Anfrage an die Datenbank bei jeder Iteration Ende des Zyklus;

// Gut — 1 Anfrage an die Datenbank
Запрос = Новый Запрос;
Запрос.Текст = "SELECT Name FROM Reference.Book.Products WHERE Link (&List)";
Запрос.УстановитьПараметр("List", МассивСсылок);
Результат = Запрос.Выполнить().Выгрузить();

Wichtig: Ein Verweis (СправочникСсылка) ist ein schreibgeschützter „Zeiger“ auf Daten. Ein Objekt (СправочникОбъект) ist eine vollständige, im Speicher geladene Kopie der Daten, die geändert und geschrieben werden kann. Das Objekt ist schwerer als der Link. Wenn Sie Objekte in einer Schleife erhalten, diese aber nicht ändern möchten, verwenden Sie Links und Abfragen.

// Wir erhalten das Objekt — alle Daten werden in den Speicher geladen
ОбъектТовара = СсылкаНаТовар.ПолучитьОбъект();
ОбъектТовара.Наименование = "New name";
ОбъектТовара.Записать();

Verbundtyp: ein Feld — viele Möglichkeiten

In den 1C-Metadaten kann ein Attribut einen zusammengesetzten Typ haben. Beispielsweise kann das Feld "Besitzer" in einem Dokument gleichzeitig vom Typ СправочникСсылка.Организации und СправочникСсылка.ФизическиеЛица sein. Die Plattform speichert in diesem Feld sowohl den Wert selbst als auch Informationen über seinen Typ.

Um mit zusammengesetzten Typen zu arbeiten, wird das Objekt ОписаниеТипов verwendet:

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

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

Sie können den aktuellen Werttyp in der Variablen mit der Funktion ТипЗнч() überprüfen:

Если ТипЗнч(Значение) = Тип("Number") Тогда
    // Wir arbeiten mit der Zahl Andernfalls Wenn TypWert (Wert) = Typ ("VerzeichnisLink.Waren") Dann    // Wir arbeiten wie mit einem Link Ende Wenn;

Zusammengesetzte Typen sind praktisch, haben aber ihren Preis. In einer Datenbank wird ein Feld mit einem zusammengesetzten Typ weniger effizient gespeichert als ein Feld mit einem festen Typ. Wenn ein Feld immer einen Wert desselben Typs enthält, ist es besser, dies im Konfigurator anzugeben - dies spart Platz und beschleunigt die Abfragen.

Sammlungen: Arrays, Strukturen und Übereinstimmungen

Neben primitiven und referenziellen Typen verfügt 1C über eine Reihe universeller Sammlungen, die überall verwendet werden.

Array - ein geordneter Satz von Werten mit Indexzugriff. Die Indexierung beginnt bei Null. Kann Elemente beliebiger Typen gleichzeitig enthalten:

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

Struktur - eine Reihe von Schlüssel-Wert-Paaren, wobei die Schlüssel die bei der Erstellung angegebenen Zeilen sind. Die Struktur ist praktisch für die Übertragung von benannten Parametern:

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

Übereinstimmung - auch Schlüssel-Wert-Paare, aber der Schlüssel kann ein Wert eines beliebigen Typs sein, einschließlich Links. Die Zuordnung funktioniert wie eine Hash-Tabelle:

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

Nuance: Die Methode Получить bei Übereinstimmung gibt Неопределено zurück, wenn der Schlüssel nicht gefunden wird und keinen Fehler verursacht. Dies muss beim Schreiben der Bedingungen berücksichtigt werden.

Werttabelle - die mächtigste Sammlung in 1C. Im Wesentlichen handelt es sich um eine temporäre Tabelle im Speicher mit Zeilen und typisierten Spalten. Wertetabellen werden aktiv für die Datenverarbeitung, Berichterstellung und den Austausch zwischen Modulen verwendet:

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

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

Eine Wertetabelle kann viel Speicherplatz beanspruchen. Wenn Sie ein Abfrageergebnis mit einer Million Zeilen in die Tabelle laden, befinden sich alle diese Informationen im RAM des Servers. Bei großen Datenmengen ist es besser, das Abfrageergebnis in Teilen über Выборка zu verarbeiten, als alles auf einmal in die Tabelle zu laden.

Typisierung und Fallstricke

1C führt bei einigen Operationen eine implizite Typumwandlung durch, was zu unerwarteten Ergebnissen führen kann:

// Zeile + Zahl - es wird ein Fehler auftreten!
Результат = "Total: " + 100; // Fehler bei der Typumwandlung

// Richtig — explizite Typisierung
Результат = "Total: " + Строка(100); // "Gesamt: 100"

// Vergleich verschiedener Typen Wenn 0 = Falsch Dann // Falsch - Typen stimmen nicht überein Ende Wenn;

Если 0 = "" Тогда     // Auch Lüge Ende Wenn;

Explizite Casting-Funktionen sind Ihre Freunde: Число(), Строка(), Дата(), Булево(). Verwenden Sie sie immer, wenn Sie einen Wert konvertieren müssen, und verlassen Sie sich nicht auf die Automatisierung der Plattform.

Parameterübergabe: nach Wert und nach Verweis

In 1C werden die Parameter von Prozeduren und Funktionen standardmäßig per Verweis übergeben. Dies bedeutet, dass der aufrufende Code diese Änderungen sieht, wenn Sie ein Array an eine Prozedur übergeben und Elemente hinzufügen:

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

Данные = Новый Массив;
ДобавитьЭлемент(Данные);
// Die Daten enthalten jetzt ein "neues Element"

Wenn Sie das Original vor Änderungen schützen möchten, verwenden Sie das Schlüsselwort Знач:

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

Bei primitiven Typen (Zahl, Zeichenfolge, Datum, Boolesch) funktioniert die Übertragung „durch Verweis“ jedoch anders: Die Neuzuweisung eines Parameters innerhalb einer Prozedur wirkt sich nicht auf die externe Variable aus. Änderungen sind nur für veränderliche Objekte sichtbar - Arrays, Strukturen, Wertetabellen.

Warum ist das alles wichtig?

Das Verständnis von Variablen und Datentypen ist keine akademische Übung. Dies wirkt sich direkt auf die Qualität Ihres Codes aus. Zu wissen, dass Strings unveränderlich sind, wird Sie davor bewahren, Tausende von Zwischenobjekten im Speicher zu erstellen. Wenn Sie den Unterschied zwischen einem Verweis und einem Objekt verstehen, werden Hunderte von unnötigen Datenbankabfragen verhindert. Wenn Sie wissen, wie zusammengesetzte Typen funktionieren, können Sie die Metadatenstruktur richtig entwerfen. Und eine klare Vorstellung vom Sichtbarkeitsbereich schützt vor Speicherlecks im Servercode.

Jedes Mal, wenn Sie eine Variable deklarieren, treffen Sie eine architektonische Entscheidung: was, wo und wie lange speichern. Je besser Sie die interne Funktionsweise der Plattform verstehen, desto sicherer und effizienter wird Ihr Code sein.

Wenn Sie die Programmierung systematisch erlernen möchten - von den Grundlagen bis zu fortgeschrittenen Themen - schauen Sie sich die App an Kodik. Dies ist eine Bildungsplattform mit Schritt-für-Schritt-Kursen in Python, JavaScript, HTML, CSS und anderen Sprachen, die Ihnen helfen, eine solide Wissensgrundlage aufzubauen.

Und wenn Sie Fragen haben oder das Material mit anderen Entwicklern besprechen möchten, treten Sie unserem Team bei Telegram-Kanal, wo bereits mehr als 2000 Teilnehmer ihre Erfahrungen teilen und sich gegenseitig helfen, im Beruf zu wachsen.