Saltar al contenido
Objetos

Copias superficiales y profundas

Lección 4 de 711 min4 ejercicios

Haces una copia de un objeto, la modificas… y el original también cambió. Es uno de los errores más comunes en JavaScript, y tiene una explicación concreta: copiar un objeto que tiene otros objetos adentro no es tan simple como parece.

Qué mirar en el pizarrón

Sigue las flechas → array #… dentro de cada objeto. Después del spread, el original y la copia apuntan al mismo array. Compáralo con lo que hace structuredClone.

En el pizarrón

const original = { nombre: "Ana", gustos: ["cine"] };const copia = { ...original }; copia.nombre = "Eva";copia.gustos.push("mar"); const profunda = structuredClone(original);profunda.gustos.push("rock"); console.log(original.gustos);

Variables

  1. original→ objeto #1
  2. objeto #1{ nombre: 'Ana', gustos: → array #2 }
  3. array #2[ 'cine' ]
Consola(vacía)

El objeto tiene otro objeto adentro: un array. En realidad son dos objetos en memoria: el #1 guarda una referencia al array #2.

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

Ver todos los pasos en texto
  1. Paso 1: El objeto tiene otro objeto adentro: un array. En realidad son dos objetos en memoria: el #1 guarda una referencia al array #2. Variables: original → objeto #1, objeto #1 { nombre: 'Ana', gustos: → array #2 }, array #2 [ 'cine' ].
  2. Paso 2: El spread crea un objeto nuevo (#3) y copia cada propiedad. Pero gustos es una referencia, y lo que se copia es la referencia: los dos objetos apuntan al mismo array #2. Es una copia superficial. Variables: original → objeto #1, copia → objeto #3, objeto #1 { nombre: 'Ana', gustos: → array #2 }, objeto #3 { nombre: 'Ana', gustos: → array #2 }, array #2 [ 'cine' ].
  3. Paso 3: Cambiar nombre en la copia no afecta al original: en el primer nivel, cada objeto tiene sus propias propiedades. Variables: original → objeto #1, copia → objeto #3, objeto #1 { nombre: 'Ana', gustos: → array #2 }, objeto #3 { nombre: 'Eva', gustos: → array #2 }, array #2 [ 'cine' ].
  4. Paso 4: Pero copia.gustos.push modifica el array compartido. El original también "ve" el cambio, porque es el mismo array. Variables: original → objeto #1, copia → objeto #3, objeto #1 { nombre: 'Ana', gustos: → array #2 }, objeto #3 { nombre: 'Eva', gustos: → array #2 }, array #2 [ 'cine', 'mar' ].
  5. Paso 5: structuredClone hace una copia profunda: duplica el objeto y también todo lo que tiene adentro, en todos los niveles. profunda tiene su propio array #5. (La tarjeta de copia se omite para despejar el pizarrón.) Variables: original → objeto #1, profunda → objeto #4, objeto #1 { nombre: 'Ana', gustos: → array #2 }, array #2 [ 'cine', 'mar' ], objeto #4 { nombre: 'Ana', gustos: → array #5 }, array #5 [ 'cine', 'mar' ].
  6. Paso 6: El push va al array #5. El original no se entera. Variables: original → objeto #1, profunda → objeto #4, objeto #1 { nombre: 'Ana', gustos: → array #2 }, array #2 [ 'cine', 'mar' ], objeto #4 { nombre: 'Ana', gustos: → array #5 }, array #5 [ 'cine', 'mar', 'rock' ].
  7. Paso 7: El original tiene mar, que entró por la copia superficial, pero no rock, que fue a la profunda. Regla: el spread copia un nivel; structuredClone, todos. Variables: original → objeto #1, profunda → objeto #4, objeto #1 { nombre: 'Ana', gustos: → array #2 }, array #2 [ 'cine', 'mar' ], objeto #4 { nombre: 'Ana', gustos: → array #5 }, array #5 [ 'cine', 'mar', 'rock' ].

Asignar no es copiar

Como viste en Valores primitivos y objetos, una variable no guarda el objeto: guarda una referencia. Asignar copia la referencia, no el objeto:

const a = { puntos: 10 };
const b = a;        // b apunta al MISMO objeto

b.puntos = 99;
console.log(a.puntos);  // 99
console.log(a === b);   // true

Copia superficial

Una copia superficial crea un objeto nuevo y copia cada propiedad del primer nivel. Hay tres formas equivalentes:

const original = { nombre: "Ana", edad: 31 };

const c1 = { ...original };
const c2 = Object.assign({}, original);
const lista = [1, 2, 3];
const c3 = [...lista];  // con arrays, igual

c1.nombre = "Eva";
console.log(original.nombre);  // Ana: el primer nivel es independiente

El problema aparece con objetos anidados, como muestra el pizarrón: si una propiedad es un objeto o un array, se copia la referencia, y los dos objetos lo comparten.

Copia profunda con structuredClone

structuredClone (disponible en todos los navegadores y en Node.js desde 2022) duplica el objeto en todos los niveles:

const perfil = {
  nombre: "Luis",
  direccion: { ciudad: "Quito" },
  etiquetas: new Set(["admin"]),
};

const copia = structuredClone(perfil);
copia.direccion.ciudad = "Lima";
copia.etiquetas.add("editor");

console.log(perfil.direccion.ciudad);  // Quito
console.log(perfil.etiquetas.size);    // 1

Conserva Date, Map, Set, arrays tipados e incluso las referencias circulares. Lo que no puede copiar:

  • Funciones y métodos: lanza DataCloneError.
  • Elementos del DOM.
  • El prototipo de las instancias de clases: devuelve objetos simples, sin sus métodos.

El viejo truco de JSON

Antes de structuredClone se usaba JSON.parse(JSON.stringify(obj)). Todavía lo vas a ver, pero tiene trampas:

const evento = {
  titulo: "Charla",
  fecha: new Date(2026, 10, 20),
  nota: undefined,
  mostrar() {},
};

const copia = JSON.parse(JSON.stringify(evento));
console.log(typeof copia.fecha);  // string: ya no es una fecha
console.log("nota" in copia);     // false: undefined desaparece
console.log("mostrar" in copia);  // false: las funciones también

¿Cuál uso?

Situación Copia
El objeto solo tiene valores primitivos Superficial: { ...obj }
Vas a cambiar algo de primer nivel Superficial con el cambio: { ...obj, hecha: true }
Hay objetos o arrays adentro y vas a modificarlos Profunda: structuredClone(obj)
Tiene métodos y datos anidados Spread + structuredClone de lo anidado

Resumen

  • const b = a no copia: las dos variables apuntan al mismo objeto.
  • { ...obj }, Object.assign y [...array] hacen copias superficiales: un nivel.
  • Lo anidado queda compartido entre el original y la copia superficial.
  • structuredClone hace una copia profunda: conserva fechas, Map, Set y referencias circulares, pero no funciones.
  • JSON.parse(JSON.stringify(...)) pierde fechas, undefined y funciones.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Un nivel o todos

Elige una respuesta en cada pregunta.

  1. const b = a; con un objeto a, ¿crea una copia?

  2. ¿Qué copia el spread { ...a }?

  3. ¿Qué problema tiene JSON.parse(JSON.stringify(obj)) como copia profunda?

  4. ¿Qué no puede copiar structuredClone?

Ordena la salida: Quién comparte qué

Una copia superficial y una profunda del mismo objeto. Ordena lo que aparecería en la consola.

const a = { n: 1, sub: { n: 1 } };const b = { ...a };const c = structuredClone(a); b.n = 2;b.sub.n = 2;c.sub.n = 3; console.log(a.n);console.log(a.sub.n);console.log(c.sub.n);console.log(a.sub === b.sub);

Consola, de arriba abajo

  1. true
  2. 2
  3. 1
  4. 3

Detective: Clonar algo con un método

Se quería una copia independiente del pedido para editarla. Encuentra la línea que falla y elige la copia correcta.

Consola

pedido.js:6
const copia = structuredClone(pedido);
              ^

DOMException [DataCloneError]: total() { return this.items.length; } could not be cloned.

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

Laboratorio: Una copia que no se filtra

Al editar la copia, el carrito original también cambia. Arregla duplicar para que la copia sea independiente en todos los niveles.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 1: el carrito original no cambia (pendiente)
  • duplicar copia todos los niveles (pendiente)
  • Las fechas siguen siendo fechas en la copia (pendiente)

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