Objetos

Frontend SELF ES
Nivel 36, Lección 0
Disponible

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.

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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 defecto false)
  • enumerable — si la propiedad aparece en for...in y Object.keys() (por defecto false)
  • configurable — si la propiedad se puede eliminar o cambiar sus ajustes (por defecto false)
  • 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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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):

JavaScript
    
      let person = {
        name: 'John',
        age: 30
      };

      console.log(person.hasOwnProperty('name')); // Mostrará: true
      console.log(person.hasOwnProperty('isStudent')); // Mostrará: false
    
  
1
Tarea
Frontend SELF ES, nivel 36, lección 0
Bloqueada
Propiedades del objeto
Propiedades del objeto
1
Tarea
Frontend SELF ES, nivel 36, lección 0
Bloqueada
Cambio de propiedades
Cambio de propiedades
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION