Shallow Copy vs Deep Copy - ¿Que son realmente?
Ejemplos con JavaScript y Python
Introducción
En el mundo de la programación, copiar datos es una tarea común. Sin embargo, no todas las copias son iguales. Dos términos que a menudo aparecen son shallow copy (copia superficial) y deep copy (copia profunda). Entender la diferencia entre ellas es crucial para evitar errores que pueden ser difíciles de detectar.
¿Qué es un Shallow Copy?
Una shallow copy copia solo el primer nivel de un objeto, dejando las referencias a los datos originales en los niveles más profundos. Esto significa que si el objeto original tiene otros objetos dentro de él (anidados), la shallow copy solo copiará las referencias a esos objetos, no los objetos en sí.
Ejemplo en JavaScript
const originalArray = [1, 2, [3, 4]];
const shallowCopy = originalArray.slice();
shallowCopy[2][0] = 99;
console.log(originalArray); // [1, 2, [99, 4]]
console.log(shallowCopy); // [1, 2, [99, 4]]
Ejemplo en Python
import copy
original_list = [1, 2, [3, 4]]
shallow_copy = copy.copy(original_list)
shallow_copy[2][0] = 99
print(original_list) # [1, 2, [99, 4]]
print(shallow_copy) # [1, 2, [99, 4]]
Tip:
Una shallow copy es útil cuando sabes que no necesitas modificar objetos anidados. Es más rápida y consume menos memoria que una deep copy.
Nota:
En JavaScript, si usas Array.slice() o Object.assign(), ¡estás haciendo una shallow copy!
¿Qué es una Deep Copy?
Una deep copy copia todos los niveles de un objeto, duplicando incluso las estructuras anidadas. Esto significa que cualquier cambio realizado en la copia no afectará al objeto original.
Ejemplo en JavaScript
const originalArray = [1, 2, [3, 4]];
const deepCopy = JSON.parse(JSON.stringify(originalArray));
deepCopy[2][0] = 99;
console.log(originalArray); // [1, 2, [3, 4]]
console.log(deepCopy); // [1, 2, [99, 4]]
Ejemplo en Python
import copy
original_list = [1, 2, [3, 4]]
deep_copy = copy.deepcopy(original_list)
deep_copy[2][0] = 99
print(original_list) # [1, 2, [3, 4]]
print(deep_copy) # [1, 2, [99, 4]]
Tip:
Si estás trabajando con estructuras de datos complejas o anidadas, la deep copy es la opción más segura para evitar efectos colaterales no deseados.
Nota:
En Python, copy.deepcopy() es tu amigo cuando necesitas duplicar objetos complejos con seguridad.
Comparación Directa: Shallow Copy vs Deep Copy
Aquí te dejo una comparación directa entre shallow copy y deep copy:
Tip:
Recuerda, una shallow copy es más rápida, pero una deep copy es más segura cuando trabajas con objetos complejos.
Casos de Uso Comunes
Cuándo Usar Shallow Copy
Cuando trabajas con objetos o estructuras de datos simples.
Cuando necesitas mejorar el rendimiento y las modificaciones profundas no son un problema.
Ejemplos: Configuraciones de aplicaciones, duplicación de datos temporales.
Cuándo Usar Deep Copy
Cuando trabajas con estructuras de datos anidadas o complejas.
Cuando necesitas asegurarte de que los cambios en la copia no afecten el original.
Ejemplos: Manipulación de datos complejos, aplicaciones que requieren alta seguridad y consistencia.
Nota:
¡Las shallow copies son geniales para duplicar configuraciones de aplicaciones ligeras o datos temporales!
Problemas Comunes y Cómo Evitarlos
Problemas con Shallow Copy
Un error común es usar una shallow copy en lugar de una deep copy cuando los datos son anidados. Esto puede llevar a modificaciones no deseadas en el objeto original.
Ejemplo:
const originalArray = [1, 2, [3, 4]];
const shallowCopy = originalArray.slice();
shallowCopy[2][0] = 99;
console.log(originalArray); // [1, 2, [99, 4]] (¡No esperado!)
Tip:
Siempre verifica si tu objeto tiene niveles anidados antes de decidir entre una shallow o deep copy.
Herramientas y Funciones para Realizar Copias en JavaScript
Uso de Object.assign() para Shallow Copy
const originalObject = { a: 1, b: { c: 2 } };
const shallowCopy = Object.assign({}, originalObject);
Uso de ...spread para Shallow Copy
const originalArray = [1, 2, 3];
const shallowCopy = [...originalArray];
Uso de structuredClone() para Deep Copy
const originalObject = { a: 1, b: { c: 2 } };
const deepCopy = structuredClone(originalObject);
Tip:
structuredClone() es perfecto para copiar estructuras complejas o circulares sin romper tu cabeza.
Uso de Librerías como Lodash para Deep Copy
const _ = require('lodash');
const originalObject = { a: 1, b: { c: 2 } };
const deepCopy = _.cloneDeep(originalObject);
Herramientas y Funciones para Realizar Copias en Python
Uso del Módulo copy
import copy
original_list = [1, 2, [3, 4]]
shallow_copy = copy.copy(original_list)
deep_copy = copy.deepcopy(original_list)
Diferencias entre copy.copy() y copy.deepcopy()
copy.copy(): Shallow copy.copy.deepcopy(): Deep copy.
Nota:
¡En Python, una copia superficial a veces es todo lo que necesitas para evitar cambios accidentales en tus listas!
Resumen y Conclusión
En resumen, tanto las shallow copies como las deep copies tienen sus usos. La clave es entender la estructura de los datos con los que estás trabajando y elegir el método de copia adecuado.
FAQs
1. ¿Es shallow copy siempre más rápida que deep copy?
Sí, debido a que copia menos datos.
2. ¿Se puede hacer una deep copy sin librerías externas en JavaScript?
Sí, con JSON.parse(JSON.stringify()) o structuredClone().
3. ¿Qué sucede si intento modificar un objeto anidado en una shallow copy?
El objeto original también se verá afectado.
4. ¿Es mejor usar siempre deep copy para evitar problemas?
No necesariamente, solo cuando trabajas con estructuras de datos complejas.
5. ¿Qué ventajas tiene structuredClone() frente a otros métodos de deep copy en JavaScript?
Es nativo, soporta estructuras circulares y es más eficiente que JSON.parse(JSON.stringify()), además de que permite transferir por completo los valores de un objeto a otro.
¡Los errores al usar copias superficiales en lugar de profundas son más comunes de lo que piensas! Espero que esta pequeña guía te ayude a evitar cualquier problema a la hora de copiar datos.
Déjame saber en los comentarios, ¿ya conocías las deep y shallow copies y has tenido problema alguna vez debido a ellas?
Photo by Mohammad Rahmani on Unsplash