Variables y tipos de datos en 1C: qué se almacena en la memoria y por qué es importante

Cuando escribes código en el lenguaje integrado 1C, cada valor, ya sea un número, una cadena o una referencia a un elemento de directorio, vive en algún lugar. Ocupa espacio en la memoria RAM, tiene un tipo específico y sigue reglas específicas. Comprensión cómo están dispuestas las variables y los tipos de datos en 1C, es la base, sin el cual es imposible escribir un código fiable y productivo. En este artículo, analizaremos todo en orden: desde la declaración de variables hasta las complejidades de trabajar con tipos compuestos.

¿Qué es una variable en 1C?

Una variable es un área de memoria con nombre en la que se almacena un valor. En 1C, las variables se escriben dinámicamente: no es necesario especificar de antemano qué tipo de datos contendrá. La misma variable puede contener primero un número, luego una cadena y luego una fecha.

Puedes declarar una variable explícitamente usando la palabra clave Перем, o implícitamente, simplemente asignándole un valor:

// Declaración explícita de la variable Contador;

// Declaración implícita a través de la asignación
Счётчик = 0;
Имя = "Alexey";
ДатаНачала = '20250101';

Si una variable se declara a través de Перем, pero aún no se le ha asignado un valor, contiene un valor especial Неопределено. Este es un punto importante: Неопределено no es cero, no es una cadena vacía y no es un error. Este es un tipo de datos independiente, lo que significa que no hay valor.

Ámbito: dónde vive la variable

En 1C hay tres niveles de visibilidad de las variables.

Variables del módulo se declaran al principio del módulo (antes de los procedimientos y funciones) a través de Перем. Están disponibles desde cualquier procedimiento y función de este módulo y existen mientras exista el propio módulo. Es un análogo de las variables globales dentro de un objeto.

Variables locales se crean dentro de un procedimiento o función. Nacen cuando se llaman y mueren cuando salen. La memoria que ocupaban se libera automáticamente.

Variables de exportación — son las variables del módulo marcadas con la palabra clave Экспорт. Están disponibles desde el exterior, desde otros módulos y formularios:

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

Consejo: Si almacena una gran tabla de valores en una variable de módulo, esta se quedará en la memoria durante toda la vida del formulario o procesamiento. Una variable local dentro de un procedimiento es una opción mucho más segura si los datos solo se necesitan en tiempo de ejecución.

Tipos de datos primitivos

La plataforma 1C proporciona varios tipos básicos (primitivos) que son los bloques de construcción para todo lo demás.

Número - almacena números enteros y fraccionarios. La longitud máxima es de 38 caracteres, de los cuales hasta 10 pueden estar después del punto decimal. 1C utiliza aritmética decimal, no binaria de punto flotante, como la mayoría de los lenguajes de programación. Esto significa que 0.1 + 0.2 en 1C dará exactamente 0.3, y no 0.30000000000000004, como en JavaScript o Python. Para los cálculos financieros, esta es una propiedad crítica:

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

Línea — secuencia de caracteres en la codificación UTF-16. Las cadenas en 1C son inmutables: cada operación de concatenación crea una nueva cadena en la memoria. Si se unen miles de líneas en un bucle, cada iteración genera un nuevo objeto y el antiguo espera al recolector de basura. Para el ensamblaje masivo de texto, es mejor usar la entrada en ТекстовыйДокумент o formar partes en una matriz y luego combinarlas:

// Malo: complejidad cuadrática de memoria
Результат = "";
Для Каждого Элемент Из Коллекция Цикл
    Результат = Результат + Элемент + ", ";
КонецЦикла;

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

Fecha — almacena la fecha y la hora con precisión de un segundo. Una fecha vacía es '00010101', no Неопределено. Esta es una fuente común de errores: la comprobación Если Дата = Неопределено no detectará una fecha vacía. Comprobación correcta:

Если ДатаДокумента = '00010101' Тогда
    // La fecha no está completa Fin Si;

Booleano — toma los valores Истина o Ложь. En términos condicionales, 1C no realiza una conversión de tipo implícita: el número 0 no se convierte automáticamente en Ложь, como en JavaScript. Es necesario escribir una comparación explícita.

Indeterminado — un tipo especial con un solo valor. Se utiliza como marcador de ausencia de valor, se devuelve al acceder a una clave de coincidencia inexistente, al leer detalles vacíos y en otras situaciones similares.

Null — otro tipo especial asociado con las bases de datos. Aparece cuando se trabaja con los resultados de la consulta, cuando se utiliza la conexión izquierda y no hay un registro correspondiente en la tabla adjunta. Null y Неопределено son cosas diferentes, y no deben confundirse.

Tipos de referencia: ¿qué hay realmente en la variable?

Cuando recibe un elemento o documento de directorio, la variable no almacena el objeto completo, sino un enlace: un identificador único (UUID) mediante el cual la plataforma puede encontrar datos en la base de datos:

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

La variable СсылкаНаТовар contiene un enlace de tipo СправочникСсылка.Товары. Este es un objeto compacto, de hecho, una envoltura sobre el GUID. Los datos en sí (nombre, precio, saldos) no se cargan en la memoria. Se extraerán de la base de datos solo cuando se acceda por primera vez al requisito:

// Aquí es donde se realiza la consulta a la base de datos
Наименование = СсылкаНаТовар.Наименование;

Esto se llama carga lenta (lazy loading), y tiene una desventaja. Si en un ciclo se procesan mil enlaces y se leen los detalles de cada uno a través de un punto, la plataforma realizará mil consultas separadas a la base de datos. La solución correcta es recibir los datos por paquetes a través de una solicitud:

// Mal - 1000 llamadas a la base de datos Para cada Enlace de la matriz de enlaces Ciclo
    Наименование = Ссылка.Наименование; // solicitud a la base de datos en cada iteración Fin del ciclo;

// Bueno: 1 solicitud a la base de datos
Запрос = Новый Запрос;
Запрос.Текст = "SELECT Name FROM Reference.Book.Products WHERE Link (&List)";
Запрос.УстановитьПараметр("List", МассивСсылок);
Результат = Запрос.Выполнить().Выгрузить();

Importante: Un enlace (СправочникСсылка) es un «puntero» a datos de solo lectura. Un objeto (СправочникОбъект) es una copia completa de los datos cargados en la memoria que se puede modificar y escribir. El objeto es más pesado que el enlace. Si recibe objetos en un bucle, pero no va a cambiarlos, use enlaces y consultas.

// Obtenemos el objeto: todos los datos se cargan en la memoria
ОбъектТовара = СсылкаНаТовар.ПолучитьОбъект();
ОбъектТовара.Наименование = "New name";
ОбъектТовара.Записать();

Tipo compuesto: un campo, muchas posibilidades

En los metadatos 1C, el atributo puede tener un tipo compuesto. Por ejemplo, el campo «Propietario» en un documento puede ser de tipo СправочникСсылка.Организации y СправочникСсылка.ФизическиеЛица al mismo tiempo. La plataforma almacena en este campo tanto el valor en sí como la información sobre su tipo.

Para trabajar con tipos compuestos, se utiliza el objeto ОписаниеТипов:

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

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

Puedes comprobar el tipo de valor actual en la variable con la función ТипЗнч():

Если ТипЗнч(Значение) = Тип("Number") Тогда
    // Trabajamos con el número De lo contrario Si Tipo de carácter (Valor) = Tipo ("DirectorioEnlace.Artículos") Entonces    // Trabajamos como con un enlace Fin Si;

Los tipos compuestos son convenientes, pero tienen su precio. En una base de datos, un campo con un tipo compuesto se almacena de manera menos eficiente que un campo con un tipo fijo. Si el campo siempre contiene un valor de un tipo, es mejor especificarlo en el configurador; esto ahorrará espacio y acelerará las consultas.

Colecciones: matrices, estructuras y coincidencias

Además de los tipos primitivos y de referencia, 1C tiene un conjunto de colecciones universales que se utilizan en todas partes.

Matriz — conjunto ordenado de valores con acceso por índice. La indexación comienza desde cero. Puede contener elementos de cualquier tipo al mismo tiempo:

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

Estructura — un conjunto de pares de «clave-valor», donde las claves son las cadenas especificadas durante la creación. La estructura es conveniente para la transmisión de parámetros con nombre:

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

Cumplimiento — también pares de "clave-valor", pero la clave puede ser cualquier tipo de valor, incluidos los enlaces. La coincidencia funciona como una tabla hash:

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

Matiz: El método Получить de coincidencia devuelve Неопределено si no se encuentra la clave y no provoca un error. Esto debe tenerse en cuenta al escribir las condiciones.

Tabla de valores - la colección más poderosa en 1C. Básicamente, es una tabla temporal en la memoria con filas y columnas tipificadas. Las tablas de valores se utilizan activamente para el procesamiento de datos, la generación de informes y el intercambio entre módulos:

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

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

Una tabla de valores puede ocupar una cantidad significativa de memoria. Si cargas el resultado de una consulta con un millón de filas, toda esta información estará en la memoria RAM del servidor. Para grandes cantidades de datos, es mejor procesar el resultado de la consulta en porciones a través de Выборка, en lugar de cargar todo en la tabla a la vez.

Tipos de conversión y sus dificultades

1C realiza una conversión de tipo implícita en algunas operaciones, y esto puede conducir a resultados inesperados:

// ¡La línea + Número será un error!
Результат = "Total: " + 100; // Error de conversión de tipo

// Correcto: conversión explícita
Результат = "Total: " + Строка(100); // "Total: 100"

// Comparación de diferentes tipos Si 0 = Falso Entonces // Falso - los tipos no coinciden Fin Si;

Если 0 = "" Тогда     // También Mentira Fin Si;

Las funciones de conversión explícita son tus amigas: Число(), Строка(), Дата(), Булево(). Úsalas siempre que necesites convertir un valor y no confíes en la automatización de la plataforma.

Transferencia de parámetros: por valor y por referencia

En 1C, los parámetros de los procedimientos y funciones se transmiten por referencia de forma predeterminada. Esto significa que si se pasa una matriz a un procedimiento y se le añaden elementos, el código de llamada verá estos cambios:

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

Данные = Новый Массив;
ДобавитьЭлемент(Данные);
// Los datos ahora contienen un «nuevo elemento»

Si desea proteger el original de los cambios, utilice la palabra clave Знач:

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

Sin embargo, para los tipos primitivos (número, cadena, fecha, booleano), la transferencia "por referencia" funciona de manera diferente: la reasignación de un parámetro dentro de un procedimiento no afecta a la variable externa. Los cambios son visibles solo para objetos mutables: matrices, estructuras, tablas de valores.

¿Por qué es importante todo esto?

Comprender las variables y los tipos de datos no es un ejercicio académico. Esto afecta directamente a la calidad de tu código. Saber que las cadenas son inmutables evitará la creación de miles de objetos intermedios en la memoria. Comprender la diferencia entre una referencia y un objeto evitará cientos de consultas innecesarias a la base de datos. Comprender cómo funcionan los tipos compuestos ayudará a diseñar correctamente la estructura de metadatos. Y una idea clara del alcance evitará fugas de memoria en el código del servidor.

Cada vez que declaras una variable, tomas una decisión arquitectónica: qué almacenar, dónde almacenar y durante cuánto tiempo. Cuanto mejor entiendas la mecánica interna de la plataforma, más seguro y eficiente será tu código.

Si quieres aprender programación de forma sistemática, desde los conceptos básicos hasta los temas avanzados, echa un vistazo a la aplicación Kodik. Es una plataforma educativa con cursos paso a paso en Python, JavaScript, HTML, CSS y otros idiomas que te ayudarán a construir una base sólida de conocimientos.

Y si tienes alguna pregunta o quieres discutir el material con otros desarrolladores, únete a nuestro Canal de Telegram, donde más de 2000 participantes comparten sus experiencias y se ayudan mutuamente a crecer en su profesión.