Object.seal( ) en JavaScript

¿Objetos y constructores de objetos en JavaScript?  
En el mundo vivo de la programación orientada a objetos, ya sabemos la importancia de las clases y los objetos, pero a diferencia de otros lenguajes de programación, JavaScript no tiene las clases tradicionales que se ven en otros lenguajes. Pero JavaScript tiene objetos y constructores que funcionan principalmente de la misma manera para realizar el mismo tipo de operaciones. 

• Los constructores son funciones generales de JavaScript que se utilizan con la palabra clave «nuevo». Los constructores son de dos tipos en JavaScript, es decir, constructores incorporados (array y objeto) y constructores personalizados (definen propiedades y métodos para objetos específicos).
• Los constructores pueden ser útiles cuando necesitamos una forma de crear un «tipo» de objeto que se pueda usar varias veces sin tener que redefinir el objeto cada vez y esto podría lograrse usando la función Object Constructor. Es una convención usar mayúsculas en el nombre de los constructores para distinguirlos de las funciones regulares.

Por ejemplo, considere el siguiente código: 

function Automobile(color) {
  this.color=color;
}
 
var vehicle1 = new Automobile ("red");

La función «Automóvil()» es un constructor de objetos, y sus propiedades y métodos, es decir, «color», se declara dentro de ella con el prefijo «esto». Los objetos definidos usando un constructor de objetos se convierten en instantes usando la palabra clave «nuevo». 
Cuando se llama a new Automobile(), JavaScript hace dos cosas: 

1. Crea un nuevo objeto nuevo (instancia) Automobile() y lo asigna a una variable.
2. Establece la propiedad del constructor, es decir, el «color» del objeto en Automóvil.

Método Object.seal() 
Entre los métodos constructores de objetos, hay un método Object.seal() que se usa para sellar un objeto. Sellar un objeto no permite agregar nuevas propiedades y marca todas las propiedades existentes como no configurables. Aunque los valores de las propiedades actuales se pueden cambiar siempre que se puedan escribir. 
El objeto a sellar se pasa como argumento y el método devuelve el objeto que ha sido sellado.

Diferencia entre el método Object.freeze() y el método Object.seal()

Si un objeto se congela con el método Object.freeze(), sus propiedades se vuelven inmutables y no se pueden realizar cambios en ellas, mientras que si se sella un objeto con el método Object.seal(), los cambios se pueden realizar `en el propiedades del objeto.

Aplicaciones: 

• Object.seal() se usa para sellar objetos y arrays.
• Object.seal() se usa para hacer que un objeto sea inmutable.

Sintaxis: 

Object.seal(obj)

Parámetros utilizados: 

1. obj : Es el objeto que tiene que ser sellado.

Valor devuelto: 
Object.sealed() devuelve el objeto que se pasó a la función.
 

A continuación se proporcionan ejemplos de la función anterior.

Ejemplos: 

Input : const obj1 = { property1: 'initial_data'};
        const obj2 = Object.seal(obj1);
        obj2.property1 = 'new_data';
        console.log(obj2.property1);

Output : "new_data"

Explicación: En este ejemplo, al objeto «ob2» se le han asignado propiedades del objeto «obj1» y se ha sellado para que no se puedan agregar nuevos valores. Se ha actualizado el valor de la propiedad 1 para obj2 ya que sellar un objeto permite cambiar las propiedades existentes. 

Input : var obj = { prop: function() {}, name: 'adam' };
        console.log(obj);
        obj.name = 'billy';
        delete obj.prop;
        console.log(obj);
        var o = Object.seal(obj);
        delete obj.prop;
        console.log(obj);
        obj.name = 'chris';
        console.log(obj);

Output : Object { prop: function () {}, name: "adam" }
         Object { name: "billy" }
         Object { name: "billy" }
         Object { name: "chris" }

Explicación: En este ejemplo, al objeto «obj» se le ha asignado «prop: función», que luego se eliminó porque el objeto «obj no estaba sellado. Después de eso, a un nuevo objeto «o» se le asignaron los valores sellados de «obj», lo que impidió que se eliminara pero permitió actualizaciones en las propiedades existentes.

Los códigos para la función anterior se proporcionan a continuación.

Código 1: 

<script>
// creating an object constructor and assigning values to it
const obj1 = { property1: 'initial_data'};
 
// creating a second object which will seal the properties of the first object
const obj2 = Object.seal(obj1);
 
// Updating the properties of the frozen object
obj2.property1 = 'new_data';
 
// Displaying the properties of the  frozen object
console.log(obj2.property1);
</script>

PRODUCCIÓN: 

"new_data"

Código 2: 

<script>
// creating an object constructor and assigning values to it
var obj = { prop: function() {}, name: 'adam' };
 
// Displaying the properties of the object created
console.log(obj);
 
// Updating the properties of the object
obj.name = 'billy';
delete obj.prop;
 
// Displaying the updated properties of the object
console.log(obj);
 
// Sealing the object using object.seal() method
var o = Object.seal(obj);
 
// Updating the properties of the object
delete obj.prop;
 
// Displaying the updated properties of the object
console.log(obj);
 
// Updating the properties of the sealed object
obj.name = 'chris';
 
// Displaying the properties of the  frozen object
console.log(obj);
 
</script>

PRODUCCIÓN: 

Object { prop: function () {}, name: "adam" }
Object { name: "billy" }
Object { name: "billy" }
Object { name: "chris" }

Excepciones: 

• Causa un TypeError si el argumento pasado no es un objeto.
• Eliminar o agregar propiedades a un objeto sellado fallará o arrojará un TypeError.
• Convertir una propiedad de datos en acceso o viceversa generará un TypeError.

Navegadores compatibles:

• Google Chrome 6.0 y superior
• Internet Explorer 9.0 y superior
• Mozilla 4.0 y superior
• Ópera 12 y superior
• Safari 5.0 y superior
• Borde 12 y superior

Referencia:  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal