浅拷贝与深拷贝——它们到底是什么? - 使用 JavaScript 和 Python 的示例

王林
发布: 2024-08-29 06:33:01
原创
304 人浏览过

介绍

在编程世界中,复制数据是一项常见任务。然而,并非所有副本都是一样的。经常出现的两个术语是浅拷贝深拷贝。了解它们之间的差异对于避免难以检测的错误至关重要。

什么是浅拷贝?

浅拷贝仅复制对象的第一层,留下对更深层次的原始数据的引用。这意味着如果原始对象内部有其他对象(嵌套),浅复制只会复制对这些对象的引用,而不是对象本身。

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]]
登录后复制

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]]
登录后复制

提示:

当您知道不需要修改嵌套对象时,浅复制非常有用。与深拷贝相比,它速度更快,消耗的内存更少。

笔记:

在 JavaScript 中,如果您使用 Array.slice() 或 Object.assign(),您就是在进行浅复制!

什么是深拷贝?

深层复制复制对象的所有级别,甚至复制嵌套结构。这意味着对副本所做的任何更改都不会影响原始对象。

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]]
登录后复制

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]]
登录后复制

提示:

如果您正在使用复杂或嵌套的数据结构,深度复制是避免不必要的副作用的最安全选择。

笔记:

在 Python 中,当您需要安全地复制复杂对象时,copy.deepcopy() 是您的朋友。

直接比较:浅复制与深复制

这是浅复制和深复制的直接比较:

Característica Shallow Copy Deep Copy
Copia superficial No
Copia profunda No
Modificaciones al objeto original afectan la copia No
Complejidad Baja Alta

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?


Shallow Copy vs Deep Copy - ¿Qué son realmente? - Ejemplos con JavaScript y Python

La libreta de BYXN ? | Substack

¡Mi libreta de apuntes pública! ???. Click to read La libreta de BYXN ?, a Substack publication. Launched 17 days ago.

Shallow Copy vs Deep Copy - ¿Qué son realmente? - Ejemplos con JavaScript y Python bhyxen.substack.com

Photo by Mohammad Rahmani on Unsplash

以上是浅拷贝与深拷贝——它们到底是什么? - 使用 JavaScript 和 Python 的示例的详细内容。更多信息请关注PHP中文网其他相关文章!

来源:dev.to
本站声明
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn
热门教程
更多>
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
关于我们 免责声明 Sitemap
PHP中文网:公益在线PHP培训,帮助PHP学习者快速成长!