El método defineProperty de la superclase Object no solo nos permite definir nuevos atributos en un objeto, sino también configurar las siguientes propiedades:
Configurable: indica si el nuevo atributo puede ser eliminado.
Enumerable: indica si el nuevo atributo podrá ser mostrado mediante funciones que listen las propiedades de un objeto. Hay excepciones en las que igual puede ser visualizado un atributo que tenga definido como false la propiedad enumerable.
Writable: indica si el nuevo atributo puede ser modificado de valor.
Normalmente, estas propiedades por defecto son definidas como true por JavaScript, sin embargo, si generamos los atributos de un objeto con Object.defineProperty, podríamos definirlas a nuestro gusto.
const juan ={name:"Juanito",age:18,approvedCourses:["Curso 1"],addCourse(newCourse){console.log("This",this);console.log("This.approvedCourses",this.approvedCourses);this.approvedCourses.push(newCourse);}};Object.defineProperty(juan,"nombreNuevaPropiedad",{value:"JavaScript",// Valor que tendráenumerable:false,writable:true,configurable:false,});
Accesibilidad a los atributos de un objeto
Con configurable, enumerable y writable podemos limitar el acceso y modificación de los atributos de un objeto. Veamos su funcionamiento mediante un par de ejemplos:
Atributos que no puedan ser listados
Definimos enumerable como false. Este atributo recién creado no se podrá visualizar si por ejemplo intentamos listar las llaves del objeto usando Object.keys:
// Definimos el objetoconst juan ={name:"Juanito",age:18,approvedCourses:["Curso 1"],addCourse(newCourse){console.log("This",this);console.log("This.approvedCourses",this.approvedCourses);this.approvedCourses.push(newCourse);}};Object.defineProperty(juan,"navigator",{// Creamos un nuevo atributovalue:"Chrome",enumerable:false,writable:true,configurable:true,});console.log(// Imprimimos las llaves del objetoObject.keys(juan));// [ 'name', 'age', 'approvedCourses', 'addCourse' ]
Sin embargo, hay una excepción si usamos Object.getOwnPropertyNames:
// Definimos el objetoconst juan ={name:"Juanito",age:18,approvedCourses:["Curso 1"],addCourse(newCourse){console.log("This",this);console.log("This.approvedCourses",this.approvedCourses);this.approvedCourses.push(newCourse);}};Object.defineProperty(juan,"navigator",{// Creamos un nuevo atributovalue:"Chrome",enumerable:false,// 👀writable:true,configurable:true,});console.log(// Imprimimos las propiedades del objetoObject.getOwnPropertyNames(juan));// [ 'name', 'age', 'approvedCourses', 'addCourse', 'navigator' ] 👈 Ya nos aparece
Atributos que no se puedan eliminar
Para ello definimos configurable como false en la nueva propiedad:
// Definimos el objetoconst juan ={name:"Juanito",age:18,approvedCourses:["Curso 1"],addCourse(newCourse){console.log("This",this);console.log("This.approvedCourses",this.approvedCourses);this.approvedCourses.push(newCourse);}};Object.defineProperty(juan,"terminal",{// Creamos un nuevo atributovalue:"WSL",enumerable:true,writable:true,configurable:false,// 👀});console.log(// Mostramos las propiedades del objeto previamente... 👁👁Object.keys(juan));// [ 'name', 'age', 'approvedCourses', 'addCourse', 'terminal' ]delete terminal;// Intentamos eliminar ❌console.log(// Listamos los atributos para comprobar si se eliminó `terminal` 🤔Object.keys(juan));// [ 'name', 'age', 'approvedCourses', 'addCourse', 'terminal' ] 👈 NO se eliminó
Atributos que no se puedan sobreescribir
Definimos writable como false:
// Definimos el objetoconst juan ={name:"Juanito",age:18,approvedCourses:["Curso 1"],addCourse(newCourse){console.log("This",this);console.log("This.approvedCourses",this.approvedCourses);this.approvedCourses.push(newCourse);}};Object.defineProperty(juan,"editor",{// Creamos un nuevo atributovalue:"VSCode",enumerable:true,writable:false,configurable:true,});console.log(juan.editor);// "VSCode"juan.editor="Atom";// Intentamos sobreescribirloconsole.log(juan.editor);// "VSCode" 👈 No cambió
Qué es Object.seal y Object.freeze
El método seal “sella” un determinado objeto. Es decir:
Impide que nuevas propiedades sean agregadas.
Define como configurable: false todos los atributos del objeto, con lo que impide que sean borradas.
Los atributos sí pueden ser modificados, ya que la propiedad writable permanece asignado como true.
// Definimos el objetoconst juan ={name:"Juanito",age:18,approvedCourses:["Curso 1"],addCourse(newCourse){console.log("This",this);console.log("This.approvedCourses",this.approvedCourses);this.approvedCourses.push(newCourse);}};Object.seal(juan);// "Sellamos" el objeto// Listamos para saber las llaves actuales:console.log(Object.keys(juan));// [ 'name', 'age', 'approvedCourses', 'addCourse' ]delete age;// Intentamos eliminar un atributo del objeto// Listamos para observar si hubo cambios:console.log(Object.keys(juan));// [ 'name', 'age', 'approvedCourses', 'addCourse' ]
El método freeze “congela” un objeto. Es decir:
Impide que se le agreguen nuevas propiedades.
Impide que sean eliminadas propiedades ya existentes.
Evita que sus propiedades writable, enumerable y configurable sean modificadas.
// Definimos el objetoconst juan ={name:"Juanito",age:18,approvedCourses:["Curso 1"],addCourse(newCourse){console.log("This",this);console.log("This.approvedCourses",this.approvedCourses);this.approvedCourses.push(newCourse);}};Object.freeze(juan);// "Congelamos" el objeto// Listamos para saber las llaves actuales:console.log(Object.keys(juan));// [ 'name', 'age', 'approvedCourses', 'addCourse' ]delete approvedCourses;// Intentamos eliminar un atributo del objetojuan.name="Carlitos";// Intentamos sobreescribir el valor de este atributo// Listamos para observar si hubo cambios:console.log(Object.keys(juan));// [ 'name', 'age', 'approvedCourses', 'addCourse' ]// Verificamos si cambió el valor de `name`:console.log(juan.name);// "Juanito"
El método defineProperty de la superclase Object no solo nos permite definir nuevos atributos en un objeto, sino también configurar las siguientes propiedades:
Configurable: indica si el nuevo atributo puede ser eliminado.
Enumerable: indica si el nuevo atributo podrá ser mostrado mediante funciones que listen las propiedades de un objeto. Hay excepciones en las que igual puede ser visualizado un atributo que tenga definido como false la propiedad enumerable.
Writable: indica si el nuevo atributo puede ser modificado de valor.
Normalmente, estas propiedades por defecto son definidas como true por JavaScript, sin embargo, si generamos los atributos de un objeto con Object.defineProperty, podríamos definirlas a nuestro gusto.
Con configurable, enumerable y writable podemos limitar el acceso y modificación de los atributos de un objeto. Veamos su funcionamiento mediante un par de ejemplos:
Atributos que no puedan ser listados
Definimos enumerable como false. Este atributo recién creado no se podrá visualizar si por ejemplo intentamos listar las llaves del objeto usando Object.keys:
// Definimos el objeto
const juan = {
name: "Juanito",
age: 18,
approvedCourses: ["Curso 1"],
addCourse(newCourse) {
console.log("This", this);
console.log("This.approvedCourses", this.approvedCourses);
this.approvedCourses.push(newCourse);
}
};
Object.defineProperty(juan, "navigator", { // Creamos un nuevo atributo
value: "Chrome",
enumerable: false,
writable: true,
configurable: true,
});
console.log( // Imprimimos las llaves del objeto
Object.keys(juan)
); // [ 'name', 'age', 'approvedCourses', 'addCourse' ]
Sin embargo, hay una excepción si usamos Object.getOwnPropertyNames:
// Definimos el objeto
const juan = {
name: "Juanito",
age: 18,
approvedCourses: ["Curso 1"],
addCourse(newCourse) {
console.log("This", this);
console.log("This.approvedCourses", this.approvedCourses);
this.approvedCourses.push(newCourse);
}
};
Object.defineProperty(juan, "navigator", { // Creamos un nuevo atributo
value: "Chrome",
enumerable: false, // 👀
writable: true,
configurable: true,
});
console.log( // Imprimimos las propiedades del objeto
Object.getOwnPropertyNames(juan)
); // [ 'name', 'age', 'approvedCourses', 'addCourse', 'navigator' ] 👈 Ya nos aparece
Atributos que no se puedan eliminar
Para ello definimos configurable como false en la nueva propiedad:
// Definimos el objeto
const juan = {
name: "Juanito",
age: 18,
approvedCourses: ["Curso 1"],
addCourse(newCourse) {
console.log("This", this);
console.log("This.approvedCourses", this.approvedCourses);
this.approvedCourses.push(newCourse);
}
};
Object.defineProperty(juan, "terminal", { // Creamos un nuevo atributo
value: "WSL",
enumerable: true,
writable: true,
configurable: false, // 👀
});
console.log( // Mostramos las propiedades del objeto previamente... 👁👁
Object.keys(juan)
); // [ 'name', 'age', 'approvedCourses', 'addCourse', 'terminal' ]
delete terminal; // Intentamos eliminar ❌
console.log( // Listamos los atributos para comprobar si se eliminó `terminal` 🤔
Object.keys(juan)
); // [ 'name', 'age', 'approvedCourses', 'addCourse', 'terminal' ] 👈 NO se eliminó
Con esta propiedad se pueden definir nuevas propiedades a nuestro objeto. Así mismo, se puede configurar ciertas características de la propiedad tales como:
Configurable: Esta indica si la propiedad puede ser borrada o eliminada
Enumerable: Indica si la propiedad puede ser mostrada en la enumeración de las mismas. Existen ciertos métodos que toman como referencia este valor para mostrar la propiedad
Writable: Esta indica si la propiedad puede ser modificada con el operador de asignación (=)
const person = {
userName: 'zajithcorro',
age: 26,
approvedCourses: ['Curso Profesional de Git y Github'],
addApprovedCourse (course) {
console.log(this)
this.approvedCourses.push(course);
}
}
A no ser que hagas librerías, no es recomendable usar defineProperty ni getOwnPropertyNames
Why is extending native objects a bad practice?
Lo mejor para ti y tu equipo es usar los objetos de la forma más simple.
Si quieres tener información que no cambie nunca probablemente lo que necesitas son Symbols
Solo para complementar, al usar Object.freeze() y/o Object.seal(), aparte de no poder borrar propiedades, tampoco se podrán agregar nuevas. Además, al usar alguno de esos 2 métodos, no habrá forma de volver atrás; es decir, si haces freeze o seal sobre un objeto, no podrás unfreeze o unseal luego 😅 (tendrías que crear una copia que permita volverle a hacer cambios o algo así).
Object.defineProperty y enumerable, writable y configurable
Con Object.defineProperty() podemos crear nuevas propiedades con la posibilidad de ver y editar enumerable, writable y configurable, que son opciones que podemos activar (o no) en las propiedades que creamos.
1. Enumerable (por defecto false)
true: Lista las propiedades con Object.keys
false: NO lista las propiedades con Object.keys (pero sí en getOwnPropertyNames())
2. Writable (por defecto false)
true: Permite modificar el valor con el operador de asignación.
false: NO permite modificar el valor con el operador de asignación.
3. Configurable (por defecto false)
true: Permite eliminar la propiedad.
false: NO permite eliminar la propiedad.
Más métodos estáticos
Object.seal()
Pone todas las propiedades en configurable: false
Ej: Object.seal(juan);
Object.freeze()
Pone todas las propiedades en writable: false
Ej: Object.freeze(juan);
.
La verdad en aplicaciones no tan complejas del día a día me cuesta encontrarle utilidad, (mejor uso TS xd) 💙
Sin embargo si que es muy bonito conocer como hace las cosas el lenguaje internamente. 💛
Yo creo que los métodos son principalmente para la seguridad de la página porque yo intente usar el Object.defineProperty en la consola del navegador para cambiar los valores y el de configurable no me dejo. Siempre tuve esa duda de como proteger datos en JS porque es código abierto, por eso me gusto esta clase