Objetos en JavaScript: La Piedra Angular del Lenguaje Los objetos son una parte fundamental de JavaScript. Son estructuras de datos flexibles y poderosas que permiten almacenar colecciones de datos y funcionalidades relacionadas. En este artículo, exploraremos en profundidad los objetos en JavaScript, desde lo básico hasta características más avanzadas.

1. Creación de Objetos

Hay varias formas de crear objetos en JavaScript:

Notación Literal de Objeto

let persona = {
  nombre: "Ana",
  edad: 30,
  saludar: function() {
    console.log("Hola, soy " + this.nombre);
  }
};`

Constructor de Objeto

let persona = new Object();
persona.nombre = "Ana";
persona.edad = 30;
persona.saludar = function() {
  console.log("Hola, soy " + this.nombre);
};

Función Constructora

function Persona(nombre, edad) {
  this.nombre = nombre;
  this.edad = edad;
  this.saludar = function() {
    console.log("Hola, soy " + this.nombre);
  };
}

let persona = new Persona("Ana", 30);

2. Propiedades y Métodos

Las propiedades son los datos almacenados en un objeto, mientras que los métodos son funciones asociadas a un objeto.

let coche = {
  marca: "Toyota",
  modelo: "Corolla",
  año: 2020,
  arrancar: function() {
    console.log("El coche está arrancando");
  }
};

console.log(coche.marca); // "Toyota"
coche.arrancar(); // "El coche está arrancando"

3. Acceso a Propiedades

Hay dos formas principales de acceder a las propiedades de un objeto:

Notación de Punto

console.log(coche.modelo); // "Corolla"

Notación de Corchetes

console.log(coche["modelo"]); // "Corolla"

4. Propiedades Dinámicas

Puedes agregar, modificar o eliminar propiedades de un objeto en cualquier momento:

coche.color = "rojo"; // Agregar
coche.año = 2021; // Modificar
delete coche.modelo; // Eliminar

5. Métodos de Objeto

JavaScript proporciona varios métodos útiles para trabajar con objetos:

Object.keys() Devuelve un array con las claves enumerables de un objeto.

console.log(Object.keys(coche)); // ["marca", "año", "arrancar", "color"]
Object.values()

Devuelve un array con los valores de las propiedades enumerables de un objeto.

console.log(Object.values(coche)); // ["Toyota", 2021, [Function: arrancar], "rojo"]
Object.entries()

Devuelve un array de arrays, donde cada subarray es un par [clave, valor] del objeto.

console.log(Object.entries(coche));
// [["marca", "Toyota"], ["año", 2021], ["arrancar", [Function: arrancar]], ["color", "rojo"]]

6. Prototipos y Herencia

JavaScript utiliza prototipos para implementar la herencia. Cada objeto tiene un enlace interno a otro objeto llamado su prototipo. Este prototipo objeto tiene a su vez su propio prototipo, y así sucesivamente, formando lo que se conoce como la cadena de prototipos.

Creación de objetos con prototipos

let animalProto = {
  comer: function() {
    console.log("Ñom ñom");
  }
};

let perro = Object.create(animalProto);
perro.ladrar = function() {
  console.log("Guau guau");
};

perro.comer(); // "Ñom ñom"
perro.ladrar(); // "Guau guau"

Herencia con funciones constructoras

function Animal(nombre) {
  this.nombre = nombre;
}

Animal.prototype.comer = function() {
  console.log(this.nombre + " está comiendo.");
};

function Perro(nombre) {
  Animal.call(this, nombre);
}

Perro.prototype = Object.create(Animal.prototype);
Perro.prototype.constructor = Perro;

Perro.prototype.ladrar = function() {
  console.log(this.nombre + " está ladrando.");
};

let miPerro = new Perro("Fido");
miPerro.comer(); // "Fido está comiendo."
miPerro.ladrar(); // "Fido está ladrando."

7. Getters y Setters

Los getters y setters permiten definir cómo se accede y modifica una propiedad de un objeto.

let persona = {
  nombre: "Juan",
  apellido: "Pérez",
  get nombreCompleto() {
    return this.nombre + " " + this.apellido;
  },
  set nombreCompleto(valor) {
    [this.nombre, this.apellido] = valor.split(" ");
  }
};

console.log(persona.nombreCompleto); // "Juan Pérez"
persona.nombreCompleto = "María López";
console.log(persona.nombre); // "María"
console.log(persona.apellido); // "López"

8. Object.defineProperty()

Este método permite definir nuevas propiedades o modificar las existentes con un control más fino sobre sus atributos.

let obj = {};

Object.defineProperty(obj, 'propiedad', {
  value: 42,
  writable: false,
  enumerable: true,
  configurable: true
});

console.log(obj.propiedad); // 42
obj.propiedad = 77; // No tiene efecto debido a writable: false
console.log(obj.propiedad); // 42

9. Métodos de Object.prototype

Estos métodos están disponibles para todos los objetos en JavaScript:

hasOwnProperty() Comprueba si una propiedad es propia del objeto y no heredada.

console.log(persona.hasOwnProperty('nombre')); // true
console.log(persona.hasOwnProperty('toString')); // false

toString() Devuelve una representación en cadena del objeto.

console.log(persona.toString()); // "[object Object]"

10. Desestructuración de Objetos

La desestructuración permite extraer valores de objetos y asignarlos a variables de forma más concisa.

let {nombre, edad} = persona;
console.log(nombre); // "María"
console.log(edad); // 30

Conclusión

Los objetos son fundamentales en JavaScript, ofreciendo versatilidad y potencia para estructurar código y datos. Dominarlos es esencial para desarrollar aplicaciones eficientes y escalables. Con su capacidad para encapsular propiedades y métodos, implementar herencia y crear abstracciones complejas, los objetos son la base de la programación moderna en JavaScript. Su comprensión profunda abre puertas a patrones de diseño avanzados y mejora significativamente la calidad del código.