Sellar, congelar y evitar la extensión de un objeto en JavaScript

En el JavaScript moderno, los objetos son integrales, y tener una sólida comprensión de los temas que rodean a los objetos es necesario para escribir un mejor JavaScript. Puede crear un objeto de cuatro maneras en JavaScript.

Una vez que sepa cómo crear un objeto, es posible que desee aprender sobre los descriptores de propiedades de objeto.  A modo de recapitulación, digamos que tienes un objeto, el gato:

var cat = {
    name: 'foo',
    age: 9
}

Cada propiedad de objeto contiene más información que solo un valor. Por ejemplo, puede imprimir otra información de propiedad mediante el método Object.getOwnPropertyDescriptor​

console.log(Object.getOwnPropertyDescriptor(cat, 'name'));

En la consola, puede ver que el nombre de una propiedad ofrece más información:

Como está muy claro, si writeable se establece en true, puede reescribir un valor de propiedad, etc.

A partir de ahora, conoce los descriptores de propiedades de objetos, por lo que si debe hacer que una propiedad sea de solo lectura, establecerá la propiedad escribible en false.

Object.defineProperty(cat, 'name', { writable: false });

A continuación, repasemos algunos requisitos más para cambiar el comportamiento predeterminado de un objeto JavaScript.

1. Impedir que un objeto tenga una nueva propiedad
2. Además del requisito 1, marque todas las propiedades configurables como falsas
3. Además del requisito 2, haga que todas las propiedades que se puedan escribir en false

A partir de ECMA 6, tiene métodos para lograr los requisitos anteriores. Veámoslos uno por uno:

Object.preventExtensions

Digamos que tienes un objeto: el gato:

var cat = {
    name: 'foo',
    age: 9
}

Con el comportamiento predeterminado, puedes agregar propiedades a un objeto JavaScript. Por lo tanto, es posible la siguiente operación:

cat.color = 'black';
console.log(cat.color); // black

Para evitar que el comportamiento predeterminado agregue propiedades dinámicamente en un objeto, debes usar Object.preventExtensions(). Este método evita que se le agreguen nuevas propiedades a un objeto.

Object.preventExtensions(cat);
cat.color = 'black';
console.log(cat.color); // undefined

Después de usar Object.preventExtensions en el objeto, si agrega un nuevo color de propiedad, JavaScript lo ignorará y, como salida, obtendrá undefined.

Si JavaScript está en modo estricto, obtendrá un error si agrega una nueva propiedad a un objeto que no es extensible.

'use strict'
var cat = {
 
    name: 'foo',
    age: 9
}
 
Object.preventExtensions(cat);
cat.color = 'black';
console.log(cat.color); // error thrown 

En el modo estricto, obtendrá un error con mensajes muy claros que dice: "no se puede agregar la propiedad, el objeto no es extensible"

En resumen, debe usar el método object.preventExtensions para evitar que se le agreguen nuevas propiedades a un objeto.

Objeto.sello

Supongamos que desea sellar un objeto, es decir:

• No deberías poder agregar nuevas propiedades (llamando a object.preventExtensions())
• No se debe cambiar ninguna configuración (estableciendo las propiedades configurables en false)

Puede sellar un objeto utilizando el método object.seal().  Consideremos de nuevo un objeto, el gato:

var cat = {
 
    name: 'foo',
    age: 9
}

No desea que se agreguen nuevas propiedades a cat y la configuración de todas las propiedades debe establecerse en false. Puedes hacer esto usando el método object.seal():

Object.seal(cat);
cat.color = 'black';
console.log(cat.color); // undefined
console.log(Object.getOwnPropertyDescriptor(cat, 'name'));

Dado que tiene un objeto sellado, como salida, obtendrá un conjunto indefinido y configurable en false.

En resumen, debes usar Object.seal() para sellar un objeto. No podrá agregar nuevas propiedades y configurable se establece en false.

Object.freeze

Supongamos que desea congelar un objeto, es decir:

• No deberías poder agregar nuevas propiedades, es decir, llamar a object.preventExtensions()
• No se debe cambiar ninguna configuración (estableciendo las propiedades configurables en false)
• Para todas las propiedades, writeable debe establecerse en false

Puedes inmovilizar un objeto utilizando el método Object.freeze().  Básicamente, llama al método Object.seal() y establece la propiedad grabable en false.

Consideremos un objeto: el gato:

var cat = {
    name: 'foo',
    age: 9
}

No se deben agregar nuevas propiedades al objeto, la configurable de todas las propiedades debe establecerse en false y la escritura de las propiedades debe establecerse en false. Puedes hacer esto usando el método object.freeze():

Object.freeze(cat);
cat.age = 10;
cat.color = 'black';
console.log(cat.age); //9
console.log(cat.color); // undefined
console.log(Object.getOwnPropertyDescriptor(cat, 'name'));

Dado que ha congelado el objeto, como salida, obtendrá undefined, 9 y configurable y escribible establecido en false.

En resumen, debes usar Object.freeze() para congelar un objeto. Una vez que inmoviliza un objeto, no debería poder agregar nuevas propiedades ni reescribir el valor de una propiedad, y configurable se establecerá en false.

Resumen

Al trabajar con objetos en JavaScript, necesita una sólida comprensión de las diferentes formas de crear un objeto. El descriptor de propiedad, Object.seal, Object.preventExtensions y Object.freeze son muy necesarios. Espero que ahora tengas una mejor comprensión de estos conceptos.