Un objeto es una bolsa de valores con nombre
Un array agrupa valores por posición. Un objeto en JavaScript los agrupa por nombre. Cuando lo que quieres modelar tiene partes con etiqueta —un usuario con su nombre y su edad, una petición con su método y su URL— lo natural es usar un objeto.
La forma más corta de crear uno es con un literal de objeto:
Cada entrada es un par clave: valor. Por dentro, las claves son cadenas (las comillas son opcionales cuando se trata de identificadores válidos como name). Los valores pueden ser cualquier cosa que JavaScript sepa representar: números, cadenas, booleanos, arrays, funciones e incluso otros objetos.
La coma final tras la última entrada no es ningún problema. De hecho, la mayoría de equipos la dejan puesta: así los diffs quedan más limpios cuando añades una nueva propiedad más adelante.
Leer y escribir propiedades de un objeto
Hay dos formas de acceder a una propiedad: notación de punto y notación de corchetes.
La notación de punto es más limpia y suele ser la opción por defecto. La notación de corchetes entra en juego cuando la clave está guardada en una variable o cuando no es un identificador válido:
Si intentas leer una propiedad que no existe, obtendrás undefined, sin lanzar ningún error:
Eso puede enmascarar errores tipográficos sin que te enteres. Si prefieres que el código falle de forma evidente, tendrás que comprobarlo a mano.
Añadir y eliminar propiedades de un objeto JavaScript
Los objetos en JavaScript son flexibles: puedes agregar claves nuevas cuando quieras:
Y elimínalas con delete:
delete es uno de esos operadores que no vas a usar todos los días, pero cuando necesitas quitar una clave por completo (no simplemente dejarla en undefined), es justo la herramienta que toca. Si haces user.email = undefined, la clave sigue ahí — de hecho, "email" in user seguiría devolviendo true.
Cómo comprobar si una propiedad existe en un objeto JavaScript
Hay tres formas, y cada una tiene su matiz:
incomprueba si la clave existe, incluyendo las que se heredan de la cadena de prototipos.Object.hasOwn(obj, key)solo mira las claves propias del objeto. Úsalo cuando quieras ignorar lo heredado. Sustituye a la antigua llamada ahasOwnProperty.obj.key !== undefinedsuele funcionar, pero te miente si una propiedad tiene asignado explícitamente el valorundefined.
Si dudas, tira de Object.hasOwn: hace justo lo que normalmente esperas.
Métodos: funciones que viven dentro de un objeto
Cuando el valor de una propiedad es una función, hablamos de un método. Dentro de un literal de objeto existe una sintaxis corta para definirlos:
this dentro de un método hace referencia al objeto sobre el que se llamó al método — user en este caso. Así es como greet sabe qué nombre usar.
Ojo con un detalle: las funciones flecha no tienen su propio this, así que no son la mejor opción para métodos que necesitan acceder a otras propiedades del objeto:
Usa la sintaxis abreviada de métodos (greet() { ... }) siempre que manejes this. Las funciones flecha van perfectas como callbacks, pero no como métodos de un objeto.
Objetos anidados en JavaScript
Los valores también pueden ser objetos, y así hasta donde quieras:
Para acceder a una propiedad anidada basta con encadenar: user.address.city. El problema está en que, si algún paso de la cadena es null o undefined, te saltará un TypeError:
console.log(user.profile.city);
// TypeError: Cannot read properties of undefined (reading 'city')
El optional chaining (user.profile?.city) es la solución moderna: devuelve undefined en lugar de lanzar un error cuando falta un eslabón de la cadena. Más adelante en este capítulo hay una página dedicada al tema.
Cómo recorrer un objeto en JavaScript
Cuando necesitas recorrer todas las claves de un objeto, tus mejores aliados son Object.keys, Object.values y Object.entries:
Object.entries es el más práctico: te devuelve la clave y el valor a la vez, y combina genial con la desestructuración de arrays.
También existe el bucle for...in, pero recorre además las propiedades heredadas, cosa que normalmente no te interesa:
for (const key in scores) {
console.log(key); // works, but includes inherited keys
}
Opta por Object.keys / Object.entries salvo que realmente necesites recorrer también las propiedades heredadas.
Atajos de sintaxis que conviene conocer
Hay dos formas abreviadas con las que te vas a topar constantemente:
La property shorthand se activa cuando el nombre de la variable coincide con el de la clave. Las claves computadas (la forma [expr]) te permiten generar nombres de propiedad de forma dinámica — muy útil cuando escribes funciones que actualizan un campo por nombre.
La igualdad de objetos se compara por referencia
Esto le pasa a casi todo el mundo alguna vez:
=== con objetos comprueba si ambos lados apuntan al mismo objeto en memoria, no si su contenido es igual. Dos objetos con propiedades idénticas siguen siendo dos objetos distintos.
Para responder a "¿tienen la misma forma?", toca comparar campo a campo a mano, o tirar de alguna función de igualdad profunda (deep equality). JSON.stringify(a) === JSON.stringify(b) es un truco rápido que funciona con datos planos, pero se rompe en cuanto aparecen funciones, valores undefined o referencias circulares.
Los objetos son mutables aunque uses const
const fija la variable a un único valor. Lo que no hace es congelar el objeto al que apunta esa variable:
Si lo que buscas es inmutabilidad real, Object.freeze(user) bloquea cualquier cambio posterior (de forma superficial: los objetos anidados aún pueden mutar). En la práctica, la mayoría del código se apoya más en la convención que en Object.freeze: trata los objetos declarados con const como "no reasignes esta referencia" y gestiona la inmutabilidad a nivel de diseño.
Siguiente paso: los arrays
Los objetos y los arrays son las dos piezas con las que se construye todo lo demás en JavaScript. Los objetos manejan datos con etiquetas; los arrays, datos en orden. En la siguiente lección veremos cómo funcionan los arrays en JavaScript y el puñado de métodos (push, slice, map y compañía) que hacen casi todo el trabajo pesado.
Preguntas frecuentes
¿Cómo se crea un objeto en JavaScript?
Lo más habitual es usar un literal de objeto: const user = { name: 'Ada', age: 30 }. Las llaves contienen pares clave-valor separados por comas. Las claves son cadenas (las comillas son opcionales si se trata de un identificador válido) y los valores pueden ser cualquier cosa: números, cadenas, arrays, funciones u otros objetos.
¿Qué diferencia hay entre la notación de punto y la de corchetes?
user.name y user['name'] hacen lo mismo cuando la clave es un identificador conocido. Conviene usar corchetes si la clave está guardada en una variable (user[key]), contiene caracteres que el punto no sabe interpretar (espacios, guiones) o empieza por un dígito. Para el resto, la notación de punto queda más limpia.
¿Cómo se comprueba si una propiedad existe en un objeto?
Con 'name' in user compruebas si la clave existe, incluidas las heredadas. Con Object.hasOwn(user, 'name') compruebas solo las propiedades propias del objeto; es el reemplazo moderno de hasOwnProperty. También funciona user.name !== undefined, pero te engaña si la propiedad se ha asignado explícitamente a undefined.
¿Cómo se recorre un objeto en JavaScript?
for (const key in obj) itera las claves, incluyendo las heredadas. Lo más habitual hoy es usar Object.keys(obj), Object.values(obj) o Object.entries(obj) junto con un bucle for...of o .forEach(). Object.entries es especialmente cómodo cuando necesitas la clave y el valor en la misma iteración.
