Ir a la página de inicio
Home / Posts
Compartir en Twitter
Go to Homepage

GUÍA COMPLETA DE OBJETOS EN JAVASCRIPT PARA PRINCIPIANTES

October 22, 2025

Introducción a los Objetos en JavaScript

En el desarrollo web, JavaScript es un lenguaje fundamental, y los objetos en JavaScript son una de sus estructuras de datos más importantes. Los objetos permiten agrupar datos relacionados de manera organizada, facilitando la escritura de código limpio y eficiente. A diferencia de tipos de datos primitivos como cadenas o números, los objetos pueden almacenar múltiples valores de diferentes tipos bajo un solo nombre. Esta guía está diseñada para programadores principiantes que deseen comprender qué son los objetos, cómo crearlos, manipularlos, copiarlos e iterar sobre ellos. Se asume que tienes conocimientos básicos de variables, funciones y tipos de datos en JavaScript.

¿Qué son los objetos en JavaScript?

Un objeto en JavaScript es un tipo de dato que almacena colecciones de pares clave-valor. A diferencia de los tipos primitivos, como números o cadenas, que solo almacenan un valor, los objetos pueden contener diversos tipos de datos, incluyendo otros objetos, arrays, funciones y más. Las claves, también conocidas como nombres de propiedades, suelen ser cadenas, aunque cualquier valor usado como clave se convierte automáticamente a cadena si no lo es.

Puedes visualizar un objeto como un estante multifuncional donde cada compartimento (clave) contiene un elemento (valor). Por ejemplo, un objeto vacío se declara con llaves:

const objetoVacio = {};
console.log(typeof objetoVacio); // 'object'

Las propiedades de un objeto son variables, mientras que las funciones dentro de un objeto se denominan métodos. Los métodos permiten a los objetos realizar acciones utilizando sus propiedades. Aquí tienes un ejemplo práctico:

const usuario = {
    nombre: "Alex",
    nacionalidad: "Nigeria",
    profesion: "Ingeniero de Software",
    biografia() {
        console.log(
            `Mi nombre es ${this.nombre}. Soy ${this.profesion} de ${this.nacionalidad}`
        );
    },
};
console.log(usuario.nombre); // Alex
console.log(usuario.nacionalidad); // Nigeria
console.log(usuario.profesion); // Ingeniero de Software
console.log(usuario.biografia()); // Mi nombre es Alex. Soy Ingeniero de Software de Nigeria

En este ejemplo, las claves son nombre, nacionalidad y profesion, mientras que sus valores son cadenas. El método biografia utiliza la palabra clave this para referirse al propio objeto, permitiendo acceder a sus propiedades.

Los valores de un objeto pueden ser de cualquier tipo de dato, incluyendo arrays u otros objetos. Por ejemplo:

const datos = {
    usuarios: ["Alex", "James", "Mohammed"],
    profesiones: {
        alex: "ingeniero de software",
        james: "abogado",
        mohammed: "escritor técnico",
    },
};
console.log(datos.usuarios); // ['Alex', 'James', 'Mohammed']
console.log(datos.profesiones); // {alex: 'ingeniero de software', james: 'abogado', mohammed: 'escritor técnico'}

Acceso y Modificación de Propiedades de Objetos

Para acceder o modificar las propiedades y métodos de un objeto, puedes usar dos tipos de notación: la notación de puntos y la notación de corchetes. La notación de puntos es la más común, pero tiene limitaciones que veremos más adelante. Aquí un ejemplo de cómo usar la notación de puntos para acceder a propiedades:

console.log(datos.usuarios); // ['Alex', 'James', 'Mohammed']
console.log(datos.profesiones.alex); // ingeniero de software

También puedes agregar nuevas propiedades o métodos a un objeto existente utilizando cualquiera de las dos notaciones:

datos.edades = [30, 32, 40];
datos["resumen"] = `El objeto tiene ${datos.usuarios.length} usuarios`;
console.log(datos);
/*
{
  usuarios: ["Alex", "James", "Mohammed"],
  profesiones: {
    alex: "ingeniero de software",
    james: "abogado",
    mohammed: "escritor técnico"
  },
  edades: [30, 32, 40],
  resumen: "El objeto tiene 3 usuarios"
}
*/

Para modificar valores existentes, simplemente reasigna el valor utilizando la notación de puntos o corchetes:

datos.usuarios = ["Jane", "Williams", "John"];
datos["edades"] = [20, 25, 29];
console.log(datos.usuarios); // ['Jane', 'Williams', 'John']
console.log(datos.edades); // [20, 25, 29]

Limitaciones de la Notación de Puntos

Aunque la notación de puntos es intuitiva, tiene restricciones importantes. No puedes usar valores dinámicos como nombres de propiedades ni nombres de propiedades con espacios o caracteres no válidos (como números al inicio). En estos casos, la notación de corchetes es la solución adecuada.

Uso de Valores Dinámicos como Nombres de Propiedades

Si necesitas usar el valor de una variable como nombre de una propiedad, la notación de corchetes es obligatoria. Por ejemplo, si deseas que el usuario ingrese un nombre de propiedad dinámicamente:

const objetoDinamico = {};
const tipoGadget = prompt("Ingresa un tipo de gadget");
objetoDinamico[tipoGadget] = ["JBL", "Sony"];
console.log(objetoDinamico); // { [tipoGadget]: ["JBL", "Sony"] }

Si usas la notación de puntos en este caso, JavaScript interpretará el nombre de la variable literalmente, no su valor:

const categoria = "marcas";
objetoDinamico.marcas = ["HP", "Dell", "Apple"];
console.log(objetoDinamico.marcas); // ['HP', 'Dell', 'Apple']
console.log(objetoDinamico[categoria]); // ['HP', 'Dell', 'Apple']

Propiedades con Nombres Multi-Palabra

La notación de puntos no permite nombres de propiedades con espacios. Por ejemplo:

objetoDinamico.altura usuarios = [5.6, 5.4, 6.0]; // Error de sintaxis

En cambio, con la notación de corchetes, puedes manejar nombres de propiedades con espacios:

objetoDinamico["altura usuarios"] = [5.6, 5.4, 6.0];
console.log(objetoDinamico["altura usuarios"]); // [5.6, 5.4, 6.0]

Los nombres de propiedades en la notación de puntos deben seguir las reglas de nombres de variables: no pueden comenzar con números, incluir espacios ni usar caracteres especiales distintos a $ o _.

Creación de Objetos con Constructores

Existen dos formas principales de crear objetos: usando literales de objeto (como los ejemplos anteriores) o usando constructores de objetos. Los literales son ideales para crear un solo objeto, pero si necesitas crear múltiples objetos con una estructura similar, los constructores son más eficientes.

Un constructor es una función que define la estructura de un objeto. Por convención, los nombres de los constructores comienzan con mayúscula. Puedes crear una instancia de un objeto usando la palabra clave new. Aquí un ejemplo:

function Perfil(nombre, edad, nacionalidad) {
    this.nombre = nombre;
    this.edad = edad;
    this.nacionalidad = nacionalidad;
    this.biografia = function () {
        console.log(
            `Mi nombre es ${this.nombre}. Tengo ${this.edad} años. Soy de ${this.nacionalidad}`
        );
    };
}

const perfil1 = new Perfil("Oladele", 50, "Nigeria");
console.log(perfil1.biografia()); // Mi nombre es Oladele. Tengo 50 años. Soy de Nigeria

El uso de this asegura que las propiedades y métodos se asocien al objeto creado. Los constructores facilitan la creación de múltiples objetos con la misma estructura sin repetir código.

Copia de Objetos en JavaScript

A diferencia de los tipos primitivos, asignar un objeto a una nueva variable no crea una copia, sino una referencia al mismo objeto en memoria. Esto significa que modificar una propiedad en la nueva variable afecta al objeto original:

let numero = 10;
let copiaNumero = numero;
numero = 20;
console.log(numero); // 20
console.log(copiaNumero); // 10

let objetoOriginal = {
    nombre: "Alex",
    edad: 40,
};
let objetoReferencia = objetoOriginal;
objetoOriginal.nombre = "Jane";
console.log(objetoReferencia); // { nombre: 'Jane', edad: 40 }
console.log(objetoOriginal === objetoReferencia); // true

Para crear una copia real de un objeto, puedes usar el operador spread o el método Object.assign().

Operador Spread

El operador spread (...) permite copiar las propiedades de un objeto a uno nuevo. Este operador funciona con cualquier iterable, como objetos o arrays:

let objetoCopia = { ...objetoOriginal };
objetoOriginal.nombre = "Williams";
console.log(objetoOriginal); // { nombre: 'Williams', edad: 40 }
console.log(objetoCopia); // { nombre: 'Jane', edad: 40 }
console.log(objetoOriginal === objetoCopia); // false

Método Object.assign()

El método Object.assign() copia todas las propiedades enumerables de un objeto fuente a un objeto destino:

let objetoDestino = Object.assign({}, objetoCopia);
objetoCopia.edad = 60;
console.log(objetoDestino); // { nombre: 'Jane', edad: 40 }
console.log(objetoCopia); // { nombre: 'Jane', edad: 60 }
console.log(objetoCopia === objetoDestino); // false

Tanto el operador spread como Object.assign() realizan copias superficiales, lo que significa que no copian objetos o arrays anidados profundamente. Por ejemplo:

let objetoAnidado = {
    nombre: "Mary",
    edad: 40,
    gadgets: {
        marca: ["Apple", "Sony"],
    },
};
let copiaAnidada = { ...objetoAnidado };
copiaAnidada.nombre = "Bianca";
copiaAnidada.gadgets.marca[0] = "HP";
console.log(objetoAnidado);
/*
{
  nombre: 'Mary',
  edad: 40,
  gadgets: { marca: ['HP', 'Sony'] }
}
*/
console.log(copiaAnidada);
/*
{
  nombre: 'Bianca',
  edad: 40,
  gadgets: { marca: ['HP', 'Sony'] }
}
*/

En este caso, cambiar el array anidado en copiaAnidada afecta a objetoAnidado porque ambos comparten la misma referencia al objeto anidado.

Iteración sobre Objetos en JavaScript

Para recorrer las propiedades de un objeto, utiliza el bucle for…in. Este bucle itera sobre todas las propiedades enumerables de un objeto:

let objetoIterado = {
    nombre: "Ade",
    pronombre: "él",
    edad: 60,
};
for (let propiedad in objetoIterado) {
    console.log(`${propiedad}: ${objetoIterado[propiedad]}`);
}
/*
nombre: Ade
pronombre: él
edad: 60
*/

Es importante usar la notación de corchetes dentro del bucle para acceder a los valores, ya que la notación de puntos no funcionará con nombres de propiedades dinámicos. Si usas la notación de puntos, obtendrás undefined.

Conclusiones

Los objetos son un pilar fundamental de JavaScript, ya que permiten organizar datos complejos de manera eficiente. Su capacidad para almacenar diferentes tipos de datos y métodos los hace esenciales para conceptos avanzados como la programación orientada a objetos. En esta guía, hemos explorado cómo crear objetos con literales y constructores, cómo acceder y modificar propiedades con notación de puntos y corchetes, cómo copiar objetos usando el operador spread y Object.assign(), y cómo iterar sobre propiedades con el bucle for…in. Dominar estas técnicas es clave para escribir código más limpio y escalable en JavaScript. Practica con los ejemplos proporcionados y experimenta creando tus propios objetos para consolidar tu aprendizaje.