Los objetos en JavaScript son la base para construir aplicaciones web confiables. Aquí verás cómo definir pares clave-valor, acceder a propiedades con precisión, evitar errores como TypeError y aplicar optional chaining para que tu lógica no se rompa cuando falte información. Todo con ejemplos claros y buenas prácticas.

¿Qué es un objeto en JavaScript y cómo se define?

Un objeto es una colección de pares clave-valor que agrupa características de algo: nombre, edad, correo, etc. A diferencia de los arreglos que usan índices, los objetos usan claves legibles. Se definen con llaves {} y permiten desde valores primitivos hasta arreglos y otros objetos anidados.

• Usa llaves para objetos y corchetes para arreglos.
• Agrupa datos relacionados en un solo lugar.
• Emplea nombres de claves claros y consistentes.
• Puedes incluir fechas con Date.now().

Ejemplo base del objeto nota:

fullscreen
// src/quince-objects.js
const nota = {
  ID: 1,
  title: "Mi primera nota",
  content: "Contenido de la nota.",
  createAt: Date.now()
};

También puede crecer con más propiedades: edad numérica, isAdmin booleana, o un arreglo dates con valores. Identifícalas bien para no confundir lo que es de un objeto y lo que pertenece a un arreglo.

¿Cómo diferenciar objetos de arreglos?

• Objetos: llaves {} y acceso por clave.
• Arreglos: corchetes [] y acceso por índice.
• Claves descriptivas ayudan a leer y mantener el código.

¿Cómo acceder a propiedades con punto y con corchetes?

Existen dos formas. La notación de punto es directa y legible. La notación de corchetes permite usar claves dinámicas desde variables.

fullscreen
console.log(nota.ID);        // Acceso por punto.
console.log(nota.title);     // Acceso por punto.

const campo = "content";     // Clave dinámica.
console.log(nota[campo]);    // Acceso por corchetes.

Atención a los typos en las claves: si escribes tile en lugar de title, no obtendrás el valor esperado. En cadenas de texto el efecto es menor; en nombres de propiedades puede romper la lógica porque la clave cambia.

¿Qué ocurre si la propiedad no existe?

• Acceder a una clave inexistente devuelve undefined.
• Acceder más adentro (propiedad de algo undefined) genera TypeError.

fullscreen
console.log(nota.autor);         // undefined.
console.log(nota.autor.name);    // TypeError: no puede leer 'name' de undefined.

Cuando veas el trace del error, léelo: indica qué propiedad falló y en qué nivel. Entender el mensaje acelera la corrección.

¿Cómo prevenir fallos con optional chaining en datos de una API?

Al consumir datos desde un servidor por medio de una API, la estructura puede cambiar: quizá esperas autor y name, pero no llegan. Sin protección, eso detiene el flujo de la aplicación. Con optional chaining evitas el colapso si algo falta.

• Coloca un signo de pregunta antes del punto en cada nivel opcional.
• Si la ruta no existe, devuelve undefined en lugar de lanzar error.
• Mantiene el programa funcionando aunque falten campos.

fullscreen
// Sin protección: puede lanzar TypeError si 'autor' falta.
// console.log(nota.autor.name);

// Con optional chaining: seguro ante datos ausentes.
console.log(nota?.autor?.name); // undefined si 'autor' o 'name' no existen.

Buenas prácticas:

• Usa optional chaining incluso si hoy controlas el objeto. Puede cambiar mañana.
• Define claves claras y consistentes para minimizar typos.
• Prefiere la notación de punto para lectura y usa corchetes para claves dinámicas.
• Loguea con console.log solo lo necesario para depurar sin ruido.

¿Tienes un caso real con objetos, acceso dinámico o optional chaining? Cuéntalo en los comentarios y comparte tu solución.