Что такое мутабельность объектов в 1С?

Мутабельность объектов в 1С

Мутабельность — это способность объекта изменяться после его создания. В 1С это фундаментальная концепция, которая определяет, как работают объекты и как они передаются между функциями.

Что такое мутабельность?

Мутабельный объект — это объект, который можно изменять после создания:

// Мутабельный объект
Объект = Справочники.Контрагенты.НайтиПоКоду(1);
Объект.Наименование = "Новое название"; // Изменили объект
Объект.Записать(); // Сохранили изменения

После записи объект В БД изменён, но объект в памяти остаётся доступным

Типы объектов в 1С

1. Мутабельные объекты (Изменяемые)

Это основные объекты 1С, которые можно изменять:

// Объекты справочников
Элемент = Справочники.Контрагенты.СоздатьЭлемент();
Элемент.Наименование = "ООО Компания";
Элемент.Записать();

// Объекты документов
Документ = Документы.СчётФактура.СоздатьДокумент();
Документ.Номер = "001";
Документ.Записать();

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

// Структура
Структура = Новый Структура("Поле1, Поле2");
Структура.Поле1 = "Значение"; // Изменили

// Соответствие
Соответствие = Новый Соответствие();
Соответствие["Ключ"] = "Значение"; // Изменили

2. Неизменяемые объекты (Immutable)

В 1С есть несколько неизменяемых типов:

// Строки — неизменяемы
Строка1 = "Привет";
Строка2 = Строка1 + " мир"; // Создаёт новую строку
// Строка1 остаётся "Привет"

// Числа — неизменяемы
Число1 = 10;
Число2 = Число1 + 5; // Создаёт новое число
// Число1 остаётся 10

// Даты — неизменяемы
Дата1 = 20200101;
Дата2 = ДобавитьМесяц(Дата1, 1); // Создаёт новую дату
// Дата1 остаётся неизменной

// Булевы значения — неизменяемы
Значение = Истина;

Передача объектов по ссылке (Reference)

Мутабельные объекты передаются по ссылке (reference), а не по значению:

Процедура ДемонстрацияПередачиПоСсылке()
    // Создали объект
    Контрагент = Справочники.Контрагенты.НайтиПоКоду(1);
    Контрагент.Наименование = "ООО А";
    
    // Передали в функцию
    ИзменитьКонтрагента(Контрагент);
    
    // После вызова функции — объект ИЗМЕНЁН!
    Сообщение(Контрагент.Наименование); // Выведет "ООО Б"
КонецПроцедуры

Процедура ИзменитьКонтрагента(КонтрагентПараметр)
    // Параметр указывает на ТОТ ЖЕ объект в памяти
    КонтрагентПараметр.Наименование = "ООО Б"; // Изменили оригинал!
КонецПроцедуры

Визуально:

Контрагент ──┐
             ├─→ [Объект в памяти: "ООО Б"]
КонтрагентПараметр ──┘

Оба указателя ссылаются на ОДИН объект. Изменение через один влияет на другой.

Передача примитивов по значению

Примитивные типы (строки, числа) передаются по значению (value):

Процедура ДемонстрацияПередачиПоЗначению()
    Число = 10;
    
    ИзменитьЧисло(Число);
    
    // После вызова функции — число НЕ изменилось!
    Сообщение(Число); // Выведет 10
КонецПроцедуры

Процедура ИзменитьЧисло(ЧислоПараметр)
    // Параметр содержит КОПИЮ значения
    ЧислоПараметр = 20; // Изменили копию, не оригинал!
КонецПроцедуры

Визуально:

Число = 10     (оригинал)
ЧислоПараметр = 10 (копия)

После ИзменитьЧисло():
Число = 10     (не изменилось)
ЧислоПараметр = 20 (изменилась копия)

Ссылка на мутабельный объект

Ссылка vs Объект в 1С

// ССЫЛКА — это идентификатор объекта в БД
Ссылка = Справочники.Контрагенты.НайтиПоКоду(1);
// Ссылка неизменяема! Это просто UUID

// ОБЪЕКТ — это текущее состояние в памяти
Объект = Ссылка.ПолучитьОбъект();
Объект.Наименование = "Новое имя";
Объект.Записать();

// После Записать ссылка остаётся той же,
// но объект в БД обновлён
Обновленный = Ссылка.ПолучитьОбъект();
Сообщение(Обновленный.Наименование); // "Новое имя"

Практические примеры мутабельности

Пример 1: Опасность мутабельности

Процедура ОпасностьМутабельности()
    // Список мутабельных объектов
    МойСписок = Новый Массив();
    МойСписок.Добавить(Новый Структура("Имя, Возраст"));
    МойСписок[0].Имя = "Иван";
    
    // Попытка создать копию
    КопияСписка = МойСписок; // Это НЕ копия, а второй указатель!
    
    КопияСписка[0].Имя = "Петр";
    
    // МойСписок ТОЖЕ изменился!
    Сообщение(МойСписок[0].Имя); // "Петр"
КонецПроцедуры

Пример 2: Правильное создание копии

Процедура ПравильнаяКопия()
    // Оригинальная структура
    Оригинал = Новый Структура("Имя, Возраст");
    Оригинал.Имя = "Иван";
    Оригинал.Возраст = 30;
    
    // Способ 1: Копирование через Новую Структуру
    Копия = Новый Структура(Оригинал);
    Копия.Имя = "Петр";
    
    Сообщение(Оригинал.Имя); // "Иван" (не изменился)
    Сообщение(Копия.Имя);    // "Петр" (независимая копия)
КонецПроцедуры

Пример 3: Мутабельность в таблицах значений

Процедура РаботаСТаблицей()
    // Создаём таблицу
    Таблица = Новый ТаблицаЗначений();
    Таблица.Колонки.Добавить("Наименование");
    Таблица.Колонки.Добавить("Сумма");
    
    // Добавляем строку
    Строка = Таблица.Добавить();
    Строка.Наименование = "Товар 1";
    Строка.Сумма = 100;
    
    // Если передать в функцию — функция изменит оригинал!
    ОбработатьТаблицу(Таблица);
    
    // Таблица изменена
    Сообщение(Таблица[0].Сумма); // Может быть изменённым значением
КонецПроцедуры

Процедура ОбработатьТаблицу(ТаблицаПараметр)
    Для Каждого Строка Из ТаблицаПараметр Цикл
        Строка.Сумма = Строка.Сумма * 1.18; // Добавляем НДС
    КонецЦикла;
КонецПроцедуры

Рекомендации при работе с мутабельностью

1. Помни о передаче по ссылке — изменения в функции повлияют на оригинал
2. Создавай копии явно — если нужна независимая копия
3. Документируй побочные эффекты — указывай, если функция изменяет параметры
4. Избегай неожиданных изменений — предусмотри механизм для защиты от изменений
5. Используй вспомогательные переменные — для безопасной работы с объектами

Пример с явным управлением

// ❌ ПЛОХО: неясно, что функция изменяет параметр
Процедура ОбработатьКонтрагента(Контрагент)
    Контрагент.Наименование = Верх(Контрагент.Наименование);
    Контрагент.Записать();
КонецПроцедуры

// ✅ ХОРОШО: ясно, что возвращается результат
Функция ПолучитьОбработанногоКонтрагента(Контрагент)
    Контрагент.Наименование = Верх(Контрагент.Наименование);
    Контрагент.Записать();
    
    Возврат Контрагент;
КонецФункции

// ИСПОЛЬЗОВАНИЕ
МойКонтрагент = ПолучитьОбработанногоКонтрагента(МойКонтрагент);

Понимание мутабельности критично для написания надёжного и предсказуемого кода в 1С, особенно при работе с документами, справочниками и таблицами значений.