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 con el prototipo y las propiedades especificadas.
En este ejemplo, el objeto john se crea basado en el prototipo personPrototype:
let personPrototype = {
greet: function() {
return 'Hello!';
}
};
let john = Object.create(personPrototype);
john.name = 'John';
john.age = 30;
john.isStudent = false;
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