Переменные в 1С: что это такое, как объявлять и правильно использовать

Переменные - одна из первых тем, с которой сталкивается начинающий 1С-разработчик. Без них невозможно написать даже небольшой фрагмент кода: посчитать сумму документа, сохранить выбранного контрагента, проверить условие, передать данные в процедуру или временно собрать список значений.

На первый взгляд переменные выглядят очень просто: придумали имя, записали туда значение и потом используем его в коде. Но в 1С у переменных есть важные особенности: мягкая типизация, область видимости, контекст модуля, значение Неопределено, отличие от Null, работа со ссылками, объектами и коллекциями. Если понять эти основы сразу, дальше будет намного проще разбираться с процедурами, функциями, запросами, формами и объектами конфигурации.

Что такое переменная в 1С

Переменная - это имя, под которым в программе хранится некоторое значение. Можно представить ее как временную ячейку памяти: мы помещаем туда данные, а потом обращаемся к ним по имени.

Простой пример:

Количество = 5;
Цена = 120;
Сумма = Количество * Цена;

Сообщить(Сумма);

В этом коде используются три переменные: Количество, Цена и Сумма. В первые две переменные записываются числа, а в третью - результат вычисления.

Оператор = в 1С используется для присваивания. Значение справа вычисляется и записывается в переменную слева:

ИмяПользователя = "Алексей";

После этой строки переменная ИмяПользователя хранит строку "Алексей".

Как объявить переменную в 1С

В 1С переменную можно объявить явно - с помощью ключевого слова Перем:

Перем СуммаДокумента;

СуммаДокумента = 1500;

Можно объявить сразу несколько переменных:

Перем Цена, Количество, Сумма;

Если переменная объявлена через Перем, но значение ей еще не присвоили, она содержит специальное значение Неопределено:

Перем Результат;

Если Результат = Неопределено Тогда
    Сообщить("Значение пока не задано");
КонецЕсли;

Внутри процедуры или функции переменная может появиться и неявно - при первом присваивании:

Процедура РассчитатьСумму()
    
    Количество = 3;
    Цена = 250;
    Сумма = Количество * Цена;
    
    Сообщить(Сумма);

КонецПроцедуры

Такой код будет работать. Но для учебного кода и для сложных процедур часто полезно объявлять важные переменные явно: это делает программу понятнее и помогает быстрее увидеть, какие данные используются в алгоритме.

Важно: в 1С используется ключевое слово Перем, а не Переменная. Запись вида Переменная Сумма; не является корректным объявлением переменной во встроенном языке 1С.

Правила именования переменных

Имя переменной должно быть понятным и технически корректным. В 1С имя может содержать буквы, цифры и символ подчеркивания. Начинаться оно должно с буквы или подчеркивания. Пробелы, дефисы и специальные символы в имени использовать нельзя.

Корректные имена:

СуммаДокумента = 1000;
ДатаНачала = ТекущаяДата();
КодВалюты = "643";

Некорректные или плохие имена:

Сумма Документа = 1000; // ошибка: пробел в имени
Дата-Начала = ТекущаяДата(); // ошибка: дефис
1Количество = 5; // ошибка: начинается с цифры

Технически можно использовать очень короткие имена вроде А, Б, Х, но в реальной разработке это почти всегда ухудшает читаемость. Через месяц даже автору кода будет сложнее вспомнить, что именно хранилось в такой переменной.

Лучше писать так:

КоличествоТоваров = 10;
СуммаБезСкидки = 5000;
ПроцентСкидки = 7;

А не так:

К = 10;
С = 5000;
П = 7;

Еще одна особенность 1С: встроенный язык не учитывает регистр символов. Для платформы имена Сумма, сумма и СУММА будут одним и тем же именем. Поэтому лучше сразу выбрать единый стиль и придерживаться его. В 1С обычно используют имена в стиле СуммаДокумента, ТекущийПользователь, ДатаОкончания.

Тип переменной и тип значения

В 1С не нужно заранее указывать, что переменная будет числом, строкой или датой. Тип имеет не сама переменная, а значение, которое в ней сейчас хранится.

Значение = 100;       // сейчас это число
Значение = "100";     // теперь это строка
Значение = Истина;    // теперь это булево значение

Такой подход называется мягкой или динамической типизацией. Он удобен для быстрого написания кода, но требует дисциплины. Если одна и та же переменная сначала хранит сумму, потом строку с комментарием, а затем ссылку на документ, код становится запутанным.

Хорошее правило: одна переменная - один смысл. Даже если 1С позволяет менять тип значения, не стоит без необходимости использовать одну переменную для разных сущностей.

Проверить тип значения можно функцией ТипЗнч():

Значение = 100;

Если ТипЗнч(Значение) = Тип("Число") Тогда
    Сообщить("В переменной хранится число");
КонецЕсли;

Основные типы значений в 1С

В переменных 1С можно хранить разные значения. Начинающему разработчику в первую очередь важно уверенно понимать несколько базовых типов.

Число

Используется для количества, цены, суммы, процентов и других числовых данных.

Цена = 1200;
Количество = 2;
Сумма = Цена * Количество;

Строка

Строка хранит текст. Строковые значения записываются в двойных кавычках:

Наименование = "Клавиатура";
Комментарий = "Товар добавлен в заказ";

Чтобы соединить несколько строк, используется оператор +:

Имя = "Анна";
Сообщить("Пользователь: " + Имя);

Если нужно добавить к строке число, число лучше явно преобразовать в строку:

Сумма = 1500;
Сообщить("Сумма документа: " + Строка(Сумма));

Булево

Булев тип хранит одно из двух значений: Истина или Ложь.

ДокументПроведен = Истина;

Если ДокументПроведен Тогда
    Сообщить("Документ проведен");
КонецЕсли;

Булевы переменные удобно называть так, чтобы по имени был понятен вопрос: ДокументПроведен, ЕстьОшибки, ЭтоНовыйКонтрагент.

Дата

Тип Дата используется для хранения даты и времени:

ДатаДокумента = ТекущаяДата();

Также дату можно задать литералом:

ДатаНачала = '20260101000000';

Формат такого литерала: год, месяц, день, часы, минуты, секунды. Для даты без времени можно указать только год, месяц и день:

ДатаНачала = '20260101';

Неопределено

Неопределено означает, что значение не задано. Такое значение получает переменная, объявленная через Перем, если ей еще ничего не присвоили.

Перем ВыбранныйКонтрагент;

Если ВыбранныйКонтрагент = Неопределено Тогда
    Сообщить("Контрагент не выбран");
КонецЕсли;

Не путайте Неопределено с нулем, пустой строкой и пустой датой. Это разные значения.

Null

Null часто встречается при работе с запросами и базой данных. Например, если в запросе используется левое соединение и связанная запись не найдена, в результате может появиться Null.

Null и Неопределено - не одно и то же:

Если Значение = Null Тогда
    Сообщить("В результате запроса нет связанного значения");
КонецЕсли;

Для начинающего важно запомнить простое правило: Неопределено чаще относится к незаданному значению в коде, а Null - к отсутствующему значению в данных, особенно в результатах запросов.

Ссылки, объекты и коллекции

В 1С переменная может хранить не только примитивное значение, но и более сложные данные.

Например, ссылка на элемент справочника:

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

В переменной СсылкаНаНоменклатуру хранится не весь элемент справочника, а ссылка на него. Если нужно изменить элемент, обычно получают объект:

ОбъектНоменклатуры = СсылкаНаНоменклатуру.ПолучитьОбъект();
ОбъектНоменклатуры.Наименование = "Новое наименование";
ОбъектНоменклатуры.Записать();

Также переменные часто хранят коллекции:

СписокКодов = Новый Массив;
СписокКодов.Добавить("001");
СписокКодов.Добавить("002");

Параметры = Новый Структура;
Параметры.Вставить("ДатаНачала", '20260101');
Параметры.Вставить("ДатаОкончания", '20261231');

Коллекции используются для временного хранения наборов данных: списков, параметров, таблиц, результатов обработки.

Область видимости переменных

Область видимости определяет, из какого места кода можно обратиться к переменной.

Локальные переменные

Локальная переменная создается внутри процедуры или функции и доступна только там:

Процедура Рассчитать()

    Сумма = 1000;
    Сообщить(Сумма);

КонецПроцедуры

За пределами процедуры Рассчитать переменная Сумма недоступна.

Локальные переменные - самый безопасный вариант. Если значение нужно только внутри одной процедуры, не стоит выносить его на уровень модуля.

Переменные модуля

Переменные модуля объявляются в начале модуля через Перем и доступны процедурам и функциям этого модуля:

Перем ТекущийРежимРаботы;

Процедура УстановитьРежим(Режим)
    ТекущийРежимРаботы = Режим;
КонецПроцедуры

Функция ПолучитьРежим()
    Возврат ТекущийРежимРаботы;
КонецФункции

Такие переменные удобны, когда нескольким процедурам действительно нужно общее состояние. Но злоупотреблять ими не стоит: чем шире область видимости, тем сложнее понять, где и почему изменилось значение.

Экспортные переменные

Переменную модуля можно объявить с ключевым словом Экспорт:

Перем НастройкаОбмена Экспорт;

Такая переменная становится доступной из других модулей в тех случаях, когда это допускает контекст выполнения. На практике экспортные переменные нужно использовать осторожно. Часто вместо них лучше сделать экспортную функцию или процедуру, которая явно возвращает нужное значение или меняет состояние контролируемым образом.

Плохая идея:

Перем СуммаДокумента Экспорт;

Лучше:

Функция ПолучитьСуммуДокумента() Экспорт
    Возврат СуммаДокумента;
КонецФункции

Так код становится понятнее: видно, откуда берется значение и кто отвечает за его получение.

Передача переменных в процедуры и функции

Переменные часто передаются в процедуры и функции как параметры:

Функция РассчитатьСумму(Цена, Количество)
    Возврат Цена * Количество;
КонецФункции

Сумма = РассчитатьСумму(120, 3);

В 1С параметры без ключевого слова Знач передаются по ссылке. Это значит, что процедура может изменить переменную вызывающего кода:

Процедура УвеличитьНаОдин(ТекущееКоличество)
    ТекущееКоличество = ТекущееКоличество + 1;
КонецПроцедуры

Количество = 5;
УвеличитьНаОдин(Количество);

Сообщить(Количество); // 6

Если нужно защитить исходную переменную от переприсваивания внутри процедуры, используйте Знач:

Процедура УвеличитьНаОдин(Знач ТекущееКоличество)
    ТекущееКоличество = ТекущееКоличество + 1;
КонецПроцедуры

Количество = 5;
УвеличитьНаОдин(Количество);

Сообщить(Количество); // 5

Это особенно важно в общих процедурах, где изменение входных параметров может стать неожиданностью для другого разработчика.

Частые ошибки при работе с переменными

Использовать переменную до присваивания

Перем Сумма;

Сообщить(Сумма); // будет Неопределено

Лучше сразу задавать начальное значение, если оно известно:

Сумма = 0;

Путать строку и число

Количество = "10";
Цена = 100;
Сумма = Количество * Цена; // ошибка или неожиданное поведение

Если данные пришли строкой, преобразуйте их явно:

Количество = Число("10");
Цена = 100;
Сумма = Количество * Цена;

Сравнивать пустую дату с Неопределено

Пустая дата - это не Неопределено. Если реквизит даты не заполнен, часто используется пустая дата:

Если ДатаДокумента = '00010101' Тогда
    Сообщить("Дата не заполнена");
КонецЕсли;

Давать переменным слишком общие имена

Данные = Новый ТаблицаЗначений;
Результат = Запрос.Выполнить();
Значение = Строка(Сумма);

Такие имена допустимы в маленьких примерах, но в реальном коде лучше уточнять смысл:

ТаблицаТоваров = Новый ТаблицаЗначений;
РезультатЗапроса = Запрос.Выполнить();
СуммаПредставление = Строка(Сумма);

Создавать переменные модуля без необходимости

Если значение нужно только внутри одной процедуры, пусть оно там и живет. Переменная модуля кажется удобной, но со временем может превратиться в источник ошибок: один обработчик ее изменил, другой использовал старое значение, третий вообще не ожидал, что она заполнена.

Практический пример

Допустим, нужно рассчитать сумму с учетом скидки:

Процедура ПоказатьСуммуСоСкидкой()

    Цена = 1200;
    Количество = 3;
    ПроцентСкидки = 10;

    СуммаБезСкидки = Цена * Количество;
    СуммаСкидки = СуммаБезСкидки * ПроцентСкидки / 100;
    СуммаКОплате = СуммаБезСкидки - СуммаСкидки;

    Сообщить("Сумма без скидки: " + Строка(СуммаБезСкидки));
    Сообщить("Скидка: " + Строка(СуммаСкидки));
    Сообщить("К оплате: " + Строка(СуммаКОплате));

КонецПроцедуры

Здесь у каждой переменной понятное имя и один конкретный смысл. Такой код легко читать и легко проверять.

Рекомендации начинающему 1С-разработчику

1. Называйте переменные по смыслу, а не случайными буквами.
2. Не используйте одну переменную для разных сущностей.
3. Помните, что 1С не учитывает регистр в именах.
4. Для важных значений задавайте начальное значение явно.
5. Различайте Неопределено, Null, пустую строку, ноль и пустую дату.
6. Используйте локальные переменные, если значение не нужно за пределами процедуры.
7. Не делайте переменные экспортными без веской причины.
8. Явно преобразуйте типы, когда соединяете строки, числа и даты.
9. Проверяйте тип значения через ТипЗнч(), если переменная может содержать разные типы.
10. Пользуйтесь отладчиком: переменные лучше всего понимать, когда видишь, как меняются их значения при выполнении кода.

Итог

Переменные в 1С - простая тема только на первый взгляд. С них начинается любой алгоритм: расчет суммы, проверка условий, работа с формой, выполнение запроса, обработка табличной части. Чем лучше вы понимаете, где переменная объявлена, какое значение хранит, какого оно типа и кто может его изменить, тем надежнее будет ваш код.

Для начала достаточно запомнить главное: переменная в 1С - это имя для временного хранения значения. Объявлять ее можно через Перем, значение присваивается оператором =, тип определяется текущим значением, а область видимости зависит от того, где переменная создана. Когда эти основы станут привычными, следующие темы встроенного языка 1С будут восприниматься намного легче.