Objetos en JavaScript: cómo agrupar propiedades y métodos en una sola pieza

En el artículo de bucles ya usaste de pasada un objeto para ver cómo funciona for...in. Pero hasta ahora no nos hemos detenido en qué es realmente un objeto ni por qué es, junto con los arrays, la otra gran forma que tiene JavaScript de agrupar datos. En este artículo vemos qué es un objeto, cómo crearlo, cómo leer y modificar sus datos, y cómo meter funciones dentro para que hagan algo con ellos.

Si ya sabes guardar datos en variables, tomar decisiones con condicionales, organizar código en funciones, guardar listas con arrays y repetir código con bucles, esto es el siguiente paso natural: agrupar datos relacionados — y las funciones que trabajan con ellos — en una sola pieza.

Qué es un objeto y por qué lo necesitas

Un objeto en JavaScript es una colección de datos relacionados, agrupados en un único valor. En vez de tener sueltas variables como nombre, edad y ciudad, un objeto te deja guardarlas juntas, bajo un mismo nombre, con una clave para cada una:

const nombre = "Ana";
const edad = 28;
const ciudad = "Madrid";

// lo mismo, pero como un objeto
const persona = {
  nombre: "Ana",
  edad: 28,
  ciudad: "Madrid"
};

En el artículo de arrays viste la otra gran forma que tiene JavaScript de agrupar datos: una lista ordenada, donde accedes a cada valor por su posición (colores[0]). Un objeto es distinto: no tiene orden, y accedes a cada valor por su nombre, no por su posición. Usa un array cuando lo que importa es el orden y vas a recorrer una lista; usa un objeto cuando lo que importa es el nombre de cada dato.

Cómo crear un objeto: el object literal

La forma más habitual de crear un objeto es escribiendo directamente su contenido entre llaves — es lo que se llama un object literal. Cada propiedad es un par clave: valor, separado por comas:

const libro = {
  titulo: "Dune",
  autor: "Frank Herbert",
  paginas: 412,
  publicado: true
};

Para leer un valor usas la notación de punto, que vemos con detalle más abajo:

console.log(libro.titulo); // "Dune"
console.log(libro.paginas); // 412

Si el objeto no existe todavía puedes empezar vacío y añadir propiedades después:

const libro = {};
libro.titulo = "Dune";

Propiedades: guardar datos relacionados

El valor de una propiedad puede ser cualquier cosa: un texto, un número, un booleano, un array, o incluso otro objeto. Por ejemplo, puedes ampliar persona con una lista de aficiones:

const persona = {
  nombre: "Ana",
  edad: 28,
  aficiones: ["leer", "escalar", "programar"]
};

console.log(persona.aficiones[0]); // "leer"

Esto es algo que vas a ver constantemente: objetos que contienen arrays, y arrays que contienen objetos. Es, de hecho, el formato en el que la mayoría de APIs devuelven datos, algo que verás cuando empieces a trabajar con peticiones a servidores.

Métodos: funciones dentro de un objeto

Ya sabes crear tus propias funciones. Un método no es más que eso: una función guardada como propiedad de un objeto. Cuando una propiedad es una función, en vez de datos, decimos que es un método:

const persona = {
  nombre: "Ana",
  saludar() {
    console.log("Hola, soy " + this.nombre);
  }
};

persona.saludar(); // "Hola, soy Ana"

saludar() { ... } es la forma abreviada de escribir saludar: function() { ... }; en código moderno vas a ver casi siempre la primera.

this: cómo un método sabe de qué objeto hablar

Dentro de un método, this hace referencia al objeto sobre el que se ha llamado ese método. Gracias a this, puedes escribir un único método y que funcione para cualquier objeto que lo use, sin repetir el nombre a mano:

const persona1 = { nombre: "Ana", saludar() { console.log("Hola, soy " + this.nombre); } };
const persona2 = { nombre: "Luis", saludar: persona1.saludar };

persona1.saludar(); // "Hola, soy Ana"
persona2.saludar(); // "Hola, soy Luis"

this depende de cómo se llama al método, no de dónde se definió — por eso en el ejemplo, el mismo método da un resultado distinto en cada objeto.

Notación de punto vs notación de corchetes

Hay dos formas de leer (y escribir) una propiedad:

Notación	Cuándo usarla	Ejemplo
Punto (objeto.clave)	Cuando conoces el nombre exacto de la propiedad de antemano	persona.nombre
Corchetes (objeto["clave"])	Cuando el nombre tiene espacios o guiones, o viene de una variable	persona["fecha de nacimiento"]

La notación de corchetes es imprescindible cuando el nombre de la propiedad está guardado en una variable, porque la notación de punto solo entiende nombres literales:

const clave = "edad";

console.log(persona[clave]); // 28 (funciona)
console.log(persona.clave); // undefined (busca una propiedad llamada "clave")

Añadir, modificar y borrar propiedades

Un objeto no es fijo: puedes añadir, cambiar o quitar propiedades en cualquier momento después de crearlo:

const persona = { nombre: "Ana", edad: 28 };

persona.edad = 29;         // modificar
persona.ciudad = "Madrid"; // añadir
delete persona.edad;       // borrar

Objetos anidados

El valor de una propiedad puede ser, a su vez, otro objeto. Es habitual cuando los datos tienen una estructura natural, como una dirección dentro de una persona:

const persona = {
  nombre: "Ana",
  direccion: {
    calle: "Gran Via",
    ciudad: "Madrid"
  }
};

console.log(persona.direccion.ciudad); // "Madrid"

Para llegar a un dato dentro de un objeto anidado, simplemente encadenas puntos (o corchetes) uno detrás de otro.

Recorrer las propiedades de un objeto

En el artículo de bucles ya viste for...in, que recorre las claves de un objeto una por una:

const persona = { nombre: "Ana", edad: 28, ciudad: "Madrid" };

for (const clave in persona) {
  console.log(clave + ": " + persona[clave]);
}

Una alternativa muy habitual en código moderno es Object.keys(), que te devuelve un array solo con las claves propias del objeto — y que puedes combinar con los métodos de array que ya conoces, como forEach:

Object.keys(persona).forEach(function (clave) {
  console.log(clave + ": " + persona[clave]);
});
// nombre: Ana
// edad: 28
// ciudad: Madrid

Errores típicos al empezar

• Confundir cuándo usar un array y cuándo un objeto. Si lo que importa es el orden y vas a recorrer una lista, usa un array; si lo que importa es el nombre de cada dato, usa un objeto.
• Olvidar las comillas en claves con espacios o que empiezan por número: persona["fecha de nacimiento"] necesita corchetes y comillas; persona.fecha de nacimiento no es válido.
• Usar notación de punto con una clave guardada en variable. persona.clave busca una propiedad llamada literalmente "clave", no el valor de esa variable — para eso necesitas corchetes: persona[clave].
• Esperar que dos objetos con el mismo contenido sean iguales con ===. Los objetos se comparan por referencia, no por contenido: dos objetos creados por separado nunca son ===, aunque tengan exactamente las mismas propiedades.

En resumen

• Un objeto agrupa datos relacionados (propiedades) y funciones que actúan sobre ellos (métodos), identificados por nombre en vez de por posición.
• Se crea con un object literal: { clave: valor }.
• Usa notación de punto cuando conoces el nombre fijo; usa corchetes cuando el nombre viene de una variable o tiene caracteres especiales.
• this, dentro de un método, apunta al objeto sobre el que se ha llamado.
• Puedes añadir, modificar y borrar propiedades en cualquier momento.
• Para recorrer sus propiedades, usa for...in o Object.keys().

Con esto ya tienes las dos piezas fundamentales con las que vas a organizar datos en JavaScript: arrays para listas ordenadas, objetos para datos con nombre. El siguiente paso natural es usar esta estructura con datos reales: convertirla a texto con JSON para guardarla o enviarla a un servidor, o guardarla directamente en el navegador. Mientras tanto, si vas a apoyarte en un asistente de IA mientras practicas esto, te interesa cómo usarla sin dejar de aprender de verdad.