Что делает метод объекта freeze?

Метод Object.freeze() в JavaScript

Метод Object.freeze() — это встроенный метод JavaScript, который делает объект неизменяемым (immutable). После его вызова объект становится "замороженным": нельзя добавлять, удалять или изменять его свойства, а также менять их конфигурацию (например, атрибуты writable, configurable). Это один из способов создания объектов с защитой от случайных или преднамеренных модификаций.

Как работает Object.freeze()

При вызове Object.freeze(obj):

• Запрещает добавление новых свойств к объекту.
• Запрещает удаление существующих свойств.
• Запрещает изменение значений существующих свойств (кроме мутаций внутри вложенных объектов, если они есть).
• Устанавливает атрибут configurable: false для всех свойств объекта, что блокирует изменение дескрипторов свойств.
• Устанавливает атрибут writable: false для всех свойств, делая их значения постоянными.

Пример базового использования:

const user = {
  name: 'Анна',
  age: 30
};

Object.freeze(user);

// Попытки изменений будут проигнорированы или вызовут ошибку в строгом режиме:
user.name = 'Мария'; // Не сработает, значение останется 'Анна'
user.city = 'Москва'; // Не сработает, свойство не добавится
delete user.age; // Не сработает, свойство не удалится

console.log(user); // { name: 'Анна', age: 30 }

Особенности и важные нюансы

1. Поверхностная заморозка: Object.freeze() работает только на первом уровне объекта. Если свойство содержит вложенный объект, массив или другую ссылочную структуру, она остаётся изменяемой:

   const company = {
     name: 'TechCorp',
     employees: ['Анна', 'Иван']
   };
   
   Object.freeze(company);
   
   company.name = 'NewCorp'; // Не сработает
   company.employees.push('Мария'); // Сработает! Массив изменён
   console.log(company.employees); // ['Анна', 'Иван', 'Мария']
   

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

2. Строгий режим ('use strict'): В нестрогом режиме попытки изменить замороженный объект молча игнорируются. В строгом режиме они вызывают ошибку TypeError:

   'use strict';
   const obj = { x: 1 };
   Object.freeze(obj);
   obj.x = 2; // TypeError: Cannot assign to read only property 'x' of object
   

3. Возвращаемое значение: Метод возвращает тот же объект, который был передан, а не копию. Это удобно для цепочек вызовов:

   const data = Object.freeze({ id: 1, value: 'test' });
   

4. Проверка заморозки: Для определения, заморожен ли объект, используется Object.isFrozen(obj), который возвращает true или false:

   const obj = { a: 1 };
   console.log(Object.isFrozen(obj)); // false
   Object.freeze(obj);
   console.log(Object.isFrozen(obj)); // true
   

Сравнение с другими методами контроля изменчивости

• Object.seal(): Запрещает добавление и удаление свойств, но позволяет изменять значения существующих свойств (атрибут configurable: false, но writable: true).
• Object.preventExtensions(): Только запрещает добавление новых свойств, но позволяет удалять и изменять существующие.

Пример сравнения:

const obj = { a: 1, b: 2 };

Object.preventExtensions(obj);
obj.a = 10; // Разрешено
delete obj.b; // Разрешено
obj.c = 3; // Запрещено

Object.seal(obj);
obj.a = 20; // Разрешено
delete obj.b; // Запрещено
obj.c = 3; // Запрещено

Object.freeze(obj);
obj.a = 30; // Запрещено
delete obj.b; // Запрещено
obj.c = 3; // Запрещено

Практическое применение

• Защита конфигураций: Например, настройки приложения, константы или дефолтные параметры, которые не должны меняться в runtime.
• Оптимизация производительности: Некоторые движки JavaScript (например, V8) могут оптимизировать замороженные объекты, так как их структура неизменна.
• Функциональное программирование: Создание иммутабельных структур данных для предсказуемости состояния.
• Безопасность: Защита объектов от модификации сторонним кодом (например, в библиотеках).

Ограничения

• Необратимость: В стандартном JavaScript нет встроенного метода для "разморозки" объекта. Можно создать копию или использовать Object.assign() с новым объектом.
• Производительность при глубокой заморозке: Рекурсивная заморозка больших объектов может быть затратной.

Пример глубокой заморозки

Для реализации глубокой заморозки можно использовать рекурсивную функцию:

function deepFreeze(obj) {
  Object.freeze(obj);
  Object.keys(obj).forEach(key => {
    const value = obj[key];
    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
      deepFreeze(value);
    }
  });
  return obj;
}

const nestedObj = {
  data: { x: 1, y: { z: 2 } },
  list: [1, 2, 3]
};

deepFreeze(nestedObj);
nestedObj.data.y.z = 100; // Не сработает в строгом режиме
nestedObj.list.push(4); // Не сработает в строгом режиме

Итог: Object.freeze() — мощный инструмент для создания неизменяемых объектов на верхнем уровне, но требует внимания к вложенным структурам. Он помогает писать более надёжный и предсказуемый код, особенно в сложных приложениях.