Saltar al contenido
Fundamentos del lenguaje

Valores primitivos y objetos

Lección 3 de 913 min4 ejercicios

En JavaScript todos los valores pertenecen a una de dos familias: los primitivos, como números y textos, y los objetos, como arrays, funciones y fechas. Parece un detalle técnico, pero explica uno de los errores más comunes de quien empieza: cambiar una cosa y que cambie otra.

Qué mirar en el pizarrón

Las tarjetas sólidas son variables; el recuadro punteado lila es un objeto en memoria. Fíjate en la diferencia: copiar a crea otro 10, pero copiar persona solo crea otra flecha hacia el mismo objeto.

En el pizarrón

let a = 10;let b = a;b = 20;console.log(a, b); const persona = { nombre: "Ana" };const copia = persona;copia.nombre = "Luis";console.log(persona.nombre);

Variables

  1. a10
Consola(vacía)

let a = 10 guarda el número 10 en a. Un número es un valor primitivo: cabe entero dentro de la variable.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: let a = 10 guarda el número 10 en a. Un número es un valor primitivo: cabe entero dentro de la variable. Variables: a 10.
  2. Paso 2: let b = a copia el valor: b recibe su propio 10. Ahora hay dos 10 independientes, uno en cada variable. Variables: a 10, b 10.
  3. Paso 3: Cambiar b no toca a a: cada una tiene su copia. Variables: a 10, b 20.
  4. Paso 4: Se imprime 10 20. Variables: a 10, b 20.
  5. Paso 5: Un objeto no cabe dentro de la variable: vive aparte, en memoria (el recuadro punteado). La variable persona guarda una referencia, como una flecha que apunta a él. Lo llamamos objeto #1. Variables: a 10, b 20, persona → objeto #1, objeto #1 { nombre: 'Ana' }.
  6. Paso 6: const copia = persona copia la referencia, no el objeto. Ahora dos nombres apuntan al mismo objeto #1. Variables: a 10, b 20, persona → objeto #1, copia → objeto #1, objeto #1 { nombre: 'Ana' }.
  7. Paso 7: copia.nombre = "Luis" sigue la flecha y cambia el objeto #1. Es el mismo objeto al que apunta persona. Variables: a 10, b 20, persona → objeto #1, copia → objeto #1, objeto #1 { nombre: 'Luis' }.
  8. Paso 8: persona.nombre sigue su flecha hasta el objeto #1 y encuentra "Luis". Variables: a 10, b 20, persona → objeto #1, copia → objeto #1, objeto #1 { nombre: 'Luis' }.
  9. Paso 9: La regla: los primitivos se copian por valor y los objetos, por referencia. Para tener un objeto nuevo de verdad hay que copiarlo explícitamente, como verás más abajo. Variables: a 10, b 20, persona → objeto #1, copia → objeto #1, objeto #1 { nombre: 'Luis' }.

Dos familias de valores

Los primitivos son los valores más simples. Hay siete tipos:

Tipo Ejemplos Para qué
string "hola", 'JS' Texto
number 42, 3.14, -7 Números, enteros o con decimales
bigint 9007199254740993n Enteros enormes
boolean true, false Sí o no
undefined undefined “Todavía no tiene valor”
null null “Vacío a propósito”
symbol Symbol("id") Identificadores únicos

Todo lo demás es un objeto: los objetos literales { }, los arrays [ ], las funciones, las fechas, los mapas… Un objeto agrupa varios valores bajo un mismo nombre y puede cambiar por dentro.

Para saber qué tipo tiene un valor, usa typeof:

console.log(typeof "hola");     // string
console.log(typeof 42);         // number
console.log(typeof true);       // boolean
console.log(typeof undefined);  // undefined
console.log(typeof { a: 1 });   // object
console.log(typeof [1, 2]);     // object (los arrays son objetos)
console.log(typeof null);       // object (¡un error histórico!)
console.log(typeof console.log); // function

Los primitivos no cambian

Un primitivo es inmutable: no se puede modificar por dentro. Las operaciones sobre un texto o un número siempre crean un valor nuevo:

const saludo = "hola";
const grito = saludo.toUpperCase();

console.log(grito);   // HOLA (un texto nuevo)
console.log(saludo);  // hola (el original no cambió)

Lo que sí puedes hacer, si la declaraste con let, es que la variable pase a guardar otro valor. Pero eso es reasignar el nombre, no modificar el valor.

Copiar: por valor o por referencia

El pizarrón de arriba muestra la diferencia clave:

  • Al copiar un primitivo, se copia el valor. Las dos variables quedan independientes.
  • Al “copiar” un objeto, se copia la referencia: la flecha que apunta a él. Las dos variables apuntan al mismo objeto, y un cambio hecho desde una se ve desde la otra.

Con los arrays pasa lo mismo, porque son objetos:

const compras = ["pan", "leche"];
const lista = compras;   // misma referencia

lista.push("huevos");

console.log(compras);    // [ 'pan', 'leche', 'huevos' ]

Y también al pasar un objeto a una función: la función recibe la referencia, así que puede modificar el original.

function subirNivel(jugador) {
  jugador.nivel = jugador.nivel + 1;
}

const ana = { nombre: "Ana", nivel: 1 };
subirNivel(ana);
console.log(ana.nivel);  // 2: la función cambió el objeto original

Comparar con ===

=== compara distinto según la familia:

  • Con primitivos compara valores: 5 === 5 y "a" === "a" dan true.
  • Con objetos compara referencias: solo da true si las dos son la misma flecha hacia el mismo objeto.
const a = { x: 1 };
const b = { x: 1 };
const c = a;

console.log(a === b);  // false: dos objetos distintos con el mismo contenido
console.log(a === c);  // true: el mismo objeto

Hacer una copia de verdad

Si necesitas un objeto nuevo con el mismo contenido, tienes que copiarlo explícitamente. Las dos formas más usadas:

  • Spread (...): crea un objeto o array nuevo y copia dentro el primer nivel de contenido. Es una copia superficial.
  • structuredClone(): copia todo, incluidos los objetos que haya dentro de otros objetos. Es una copia profunda.
const original = { nombre: "Ana", gustos: ["cine"] };

const superficial = { ...original };
const profunda = structuredClone(original);

superficial.nombre = "Luis";         // no afecta al original
profunda.gustos.push("música");      // tampoco

console.log(original.nombre);        // Ana
console.log(original.gustos);        // [ 'cine' ]

Resumen

  • Hay 7 primitivos (string, number, bigint, boolean, undefined, null, symbol). Todo lo demás es un objeto, incluidos arrays y funciones.
  • typeof dice el tipo; ojo con typeof null, que devuelve "object".
  • Los primitivos son inmutables y se copian por valor.
  • Los objetos se copian por referencia: dos nombres pueden apuntar al mismo objeto.
  • === compara valores en los primitivos y referencias en los objetos.
  • Para un objeto nuevo usa { ...obj } (superficial) o structuredClone(obj) (profunda).

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Valor o referencia

Elige una respuesta en cada pregunta.

  1. ¿Cuál de estos valores no es primitivo?

  2. ¿Qué devuelve typeof null?

  3. ¿Qué da { a: 1 } === { a: 1 }?

  4. const a = [1, 2]; const b = a; b.push(3);
    ¿Qué contiene a?

Ordena la salida: Números y objetos copiados

Ordena las líneas tal como aparecerían en la consola. Antes de comprobar, piensa qué valor tiene cada una.

let x = 5;let y = x;y = y + 1; const p = { n: 5 };const q = p;q.n = q.n + 1; console.log("x:", x);console.log("y:", y);console.log("p.n:", p.n);

Consola, de arriba abajo

  1. p.n: 6
  2. x: 5
  3. y: 6

Detective: El usuario que no estaba

Este programa busca un usuario que no existe y se rompe. Encuentra la línea que falla y elige el arreglo correcto. Cuidado: uno de los arreglos parece correcto pero no lo es.

Consola

Buscando usuario...
perfil.js:3
console.log(usuario.nombre);
                    ^

TypeError: Cannot read properties of null (reading 'nombre')

Paso 1: toca la línea de código que causa el error.

Laboratorio: Haz una copia de verdad

Al cambiar copia.puntos, también cambia original.puntos. Arregla la línea 2 para que copia sea un objeto nuevo y el original se quede en 10.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 10 y después 99 (pendiente)
  • original y copia son objetos distintos (pendiente)
  • La copia conserva el nombre: copia.nombre es "Ana" (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.