Почему можно изменять поля объекта, объявленного через const?

Отличный и очень важный вопрос, который часто вызывает путаницу у начинающих разработчиков. Ответ лежит в фундаментальном различии между присваиванием (assignment) и изменением (mutation), а также в том, как JavaScript хранит значения объектов.

Ключевое различие: const защищает связь, а не содержимое

Ключевое слово const в JavaScript означает constant (константа). Однако важно понимать, что константной является сама переменная (идентификатор) и ссылка, которую она хранит, а не данные, на которые эта ссылка указывает.

Проще говоря, const предотвращает повторное присваивание переменной, но не мешает изменению внутреннего состояния объекта, на которую эта переменная ссылается.

Примитивные vs. Ссылочные типы данных

Чтобы понять это глубже, нужно различать два типа данных:

1. Примитивные типы (String, Number, Boolean, null, undefined, Symbol, BigInt): Переменная хранит само значение. При работе с const это значение защищено от изменений.

   const myNumber = 42;
   myNumber = 100; // ОШИБКА: Assignment to constant variable.
   // Значение 42 защищено.
   

2. Ссылочные типы (Object, Array, Function, Date и др.): Переменная хранит не сам объект, а ссылку (указатель, адрес в памяти) на место, где этот объект находится. const защищает именно эту ссылку от изменения, делая её постоянной.

   const person = { name: 'Alice', age: 30 };
   // Переменная `person` теперь хранит неизменную ссылку на объект.
   

Что именно делает const с объектом?

Давайте рассмотрим на примерах:

const company = { name: 'TechCorp', employees: 100 };

// ДЕЙСТВИЕ 1: Изменение (мутация) свойств объекта - РАЗРЕШЕНО.
// Мы меняем данные по адресу, который хранит `company`. Сам адрес не меняется.
company.employees = 150; // Ok!
company.country = 'USA'; // Ok! Можно добавлять новые свойства.

// ДЕЙСТВИЕ 2: Попытка переназначить переменную - ЗАПРЕЩЕНО.
// Мы пытаемся заставить `company` хранить ссылку на другой объект. Это меняет саму ссылку.
company = { name: 'NewCorp' }; // ОШИБКА: Assignment to constant variable.

// ДЕЙСТВИЕ 3: Даже "заморозку" ссылки можно обойти через вложенность.
company.departments = ['Engineering', 'Sales'];
company.departments.push('Marketing'); // Ok! Мы изменяем массив, на который ссылается свойство.

// Визуальная аналогия:
// `const company` — это ярлык (shortcut) на рабочем столе, приклеенный к файлу "object.data".
// Вам запрещено отклеить этот ярлык и приклеить его к другому файлу (действие 2).
// Но вы можете открыть файл "object.data" и отредактировать его содержимое как угодно (действие 1).

Как добиться настоящей неизменяемости объекта?

Если вам нужно сделать объект действительно неизменным (иммутабельным), const для этого недостаточно. Для этого в JavaScript есть несколько инструментов:

1. Object.freeze(): "Замораживает" объект, предотвращая добавление, удаление и изменение существующих свойств. Однако это неглубокое (shallow) замораживание.

   const frozenObject = Object.freeze({ score: 95 });
   frozenObject.score = 100; // Тихая ошибка в нестрогом режиме, в strict mode — TypeError.
   frozenObject.newProp = 'x'; // Не сработает.
   
   // Но вложенные объекты не защищены!
   const shallowFrozen = Object.freeze({ data: { a: 1 } });
   shallowFrozen.data.a = 2; // Сработает! Изменение вложенного объекта.
   

2. Глубокое замораживание: Для защиты всей структуры объекта необходимо рекурсивно применить Object.freeze() ко всем вложенным объектам и массивам.

3. Использование практик иммутабельности: В современных приложениях (особенно с Redux, React state) данные не изменяются, а создаются новые. Для этого используются:

    *   Оператор spread (`...`)
    *   `Object.assign()`
    *   Методы, возвращающие новые массивы/объекты (например, `map`, `filter`, `slice`).

```javascript
const originalState = { user: 'Bob', permissions: ['read'] };

// Вместо мутации: originalState.permissions.push('write');
// Создаём новый объект:
const newState = {
    ...originalState,
    permissions: [...originalState.permissions, 'write'] // Новый массив
};
// originalState остался неизменным, newState — это новый объект.
```

Почему такое поведение логично и полезно?

1. Производительность: Копирование больших объектов при каждом изменении было бы крайне неэффективно. Работа со ссылками — это осознанный компромисс.
2. Гибкость: Позволяет передавать объекты в функции и методы, которые могут их модифицировать, не теряя ссылку на оригинальный объект.
3. Консистентность: Поведение const единообразно для всех ссылочных типов (объекты, массивы, функции). Запрет на изменение содержимого объекта нарушил бы эту логику и сделал бы const бесполезным для большинства реальных случаев работы с данными.

Итог: Объявление const obj = {} означает: "Эта переменная obj навсегда будет указывать именно на этот объект в памяти". Но содержимое этого объекта по указанному адресу может меняться. Для управления изменяемостью данных существуют другие инструменты (Object.freeze, иммутабельные обновления), которые используются поверх базовой гарантии, предоставляемой const.