6.1 Creación de objetos
Objetos son uno de los tipos de datos principales en JavaScript y se usan ampliamente para almacenar y gestionar datos. Un objeto es una colección de propiedades, donde cada propiedad consiste en una llave (nombre) y un valor. En esta lección, vamos a ver la creación de objetos, así como el acceso a sus propiedades y métodos.
1. Literal de objeto
La forma más común de crear un objeto en JavaScript es usar un literal de objeto.
En este ejemplo, hemos creado el objeto person con cuatro propiedades: name, age, isStudent y greet.
let person = {
name: 'John',
age: 30,
isStudent: false,
greet: function() {
return 'Hello!';
}
};
2. Constructor Object
Los objetos también pueden ser creados usando el constructor Object().
Este método es equivalente a crear un objeto usando un literal de objeto, pero es más verboso:
let person = new Object();
person.name = 'John';
person.age = 30;
person.isStudent = false;
person.greet = function() {
return 'Hello!';
};
3. Función constructora
La función constructora permite crear múltiples instancias de objetos con las mismas propiedades y métodos.
En este ejemplo, la función constructora Person() se utiliza para crear los objetos john y jane con las mismas propiedades y métodos:
function Person(name, age, isStudent) {
this.name = name;
this.age = age;
this.isStudent = isStudent;
this.greet = function() {
return 'Hello!';
};
}
let john = new Person('John', 30, false);
let jane = new Person('Jane', 25, true);
4. Método Object.create()
El método Object.create() crea un nuevo objeto y le asigna de inmediato un prototipo: otro objeto en el que el nuevo buscará las propiedades y métodos que no tenga por sí mismo.
En este ejemplo, el objeto john se crea a partir del prototipo personPrototype:
let personPrototype = {
greet: function() {
return 'Hello!';
}
};
let john = Object.create(personPrototype);
john.name = 'John';
john.age = 30;
john.isStudent = false;
console.log(john.name); // Mostrará: John
console.log(john.greet()); // Mostrará: Hello!
Fíjate en la última línea. El objeto john no tiene un método greet propio: solo le escribimos name, age e isStudent. Sin embargo, john.greet() funciona: al acceder a una propiedad, JavaScript la busca primero en el propio objeto y, si no la encuentra, sube al prototipo. Esa ruta de búsqueda se llama cadena de prototipos.
La diferencia entre una propiedad propia y una heredada es fácil de ver:
console.log(john.hasOwnProperty('name')); // Mostrará: true
console.log(john.hasOwnProperty('greet')); // Mostrará: false
console.log('greet' in john); // Mostrará: true
hasOwnProperty() responde a la pregunta «¿tiene el objeto esta propiedad por sí mismo?», mientras que el operador in responde «¿se puede llegar a esta propiedad, aunque sea por la cadena de prototipos?». De ahí las respuestas distintas para greet.
Un punto importante: las propiedades del prototipo no se copian en el nuevo objeto. personPrototype sigue siendo un objeto aparte y john solo lo referencia. Por eso un mismo prototipo puede compartirse entre cientos de objetos, y greet se guarda en memoria una sola vez. Compáralo con la función constructora del ejemplo 3: allí cada objeto creado recibía su propia copia de greet.
El segundo argumento: propiedades con ajustes
Object.create() admite un segundo argumento opcional: un objeto que describe las propiedades que hay que crear de inmediato. No se definen con un simple valor, sino con un descriptor, un conjunto de ajustes:
value— el valor de la propiedad en síwritable— si el valor se puede cambiar (por defectofalse)enumerable— si la propiedad aparece enfor...inyObject.keys()(por defectofalse)configurable— si la propiedad se puede eliminar o cambiar sus ajustes (por defectofalse)get/set— un getter y un setter en lugar de un valor corriente. El getter se dispara al leer la propiedad; el setter, al escribir en ella
Juntándolo todo:
let john = Object.create(personPrototype, {
name: {
value: 'John',
writable: true, // el valor se puede cambiar
enumerable: true // propiedad visible en for...in
},
id: {
value: 1001,
writable: false, // solo lectura
enumerable: true
},
info: {
enumerable: true,
get: function() { // getter: se dispara al leer
return this.name + ' #' + this.id;
},
set: function(value) { // setter: se dispara al escribir
this.name = value;
}
}
});
console.log(john.info); // Mostrará: John #1001
john.name = 'Johnny'; // funciona
john.id = 2002; // no hace nada, en silencio
console.log(john.info); // Mostrará: Johnny #1001
Ten en cuenta que los tres indicadores valen false por defecto, así que al usar el segundo argumento casi siempre hay que indicarlos de forma explícita. Asignar a una propiedad con writable: false falla en silencio en modo normal y lanza un TypeError en modo estricto ('use strict').
Otro caso útil es Object.create(null). Un objeto así no tiene prototipo alguno: ni toString(), ni hasOwnProperty(), ni ningún otro método heredado. Eso lo convierte en un cómodo «diccionario limpio», donde cada clave es tuya con seguridad y no viene heredada de Object.prototype.
6.2 Acceso a propiedades y métodos
1. Acceso mediante punto
La forma más común de acceder a propiedades y métodos de un objeto es mediante el punto:
let person = {
name: 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person.name); // Mostrará: John
console.log(person.age); // Mostrará: 30
console.log(person.greet()); // Mostrará: Hello!
2. Acceso mediante corchetes
Las propiedades de un objeto también pueden ser accedidas mediante corchetes. Este método es útil si el nombre de la propiedad se almacena en una variable o contiene espacios o caracteres especiales:
let person = {
'first name': 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person['first name']); // Mostrará: John
console.log(person['age']); // Mostrará: 30
let propertyName = 'greet';
console.log(person[propertyName]()); // Mostrará: Hello!
3. Modificación y adición de propiedades
Las propiedades de un objeto pueden ser modificadas o añadidas en cualquier momento:
let person = {
name: 'John',
age: 30
};
// Modificación de una propiedad existente
person.age = 31;
console.log(person.age); // Mostrará: 31
// Adición de una nueva propiedad
person.isStudent = false;
console.log(person.isStudent); // Mostrará: false
4. Eliminación de propiedades
Las propiedades de un objeto pueden ser eliminadas mediante el operador delete:
let person = {
name: 'John',
age: 30,
isStudent: false
};
delete person.isStudent;
console.log(person.isStudent); // Mostrará: undefined
6.3 Iteración sobre las propiedades del objeto
1. Ciclo for...in
El ciclo for...in permite recorrer todas las propiedades enumerables de un objeto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
for (let key in person) {
console.log(`${key}: ${person[key]}`);
}
// Mostrará:
// name: John
// age: 30
// isStudent: false
2. Método Object.keys()
El método Object.keys() devuelve un array con todas las propiedades enumerables de un objeto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let keys = Object.keys(person);
console.log(keys); // Mostrará: ['name', 'age', 'isStudent']
3. Método Object.values()
El método Object.values() devuelve un array con los valores de todas las propiedades enumerables de un objeto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let values = Object.values(person);
console.log(values); // Mostrará: ['John', 30, false]
4. Método Object.entries()
El método Object.entries() devuelve un array de pares [clave, valor] para todas las propiedades enumerables de un objeto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let entries = Object.entries(person);
console.log(entries); // Mostrará: [['name', 'John'], ['age', 30], ['isStudent', false]]
6.4 Verificación de propiedades
1. Operador in
El operador in permite verificar la existencia de una propiedad en un objeto:
let person = {
name: 'John',
age: 30
};
console.log('name' in person); // Mostrará: true
console.log('isStudent' in person); // Mostrará: false
2. Método hasOwnProperty()
El método hasOwnProperty() verifica si un objeto tiene una propiedad específica como propia (no heredada):
let person = {
name: 'John',
age: 30
};
console.log(person.hasOwnProperty('name')); // Mostrará: true
console.log(person.hasOwnProperty('isStudent')); // Mostrará: false
GO TO FULL VERSION