1. Revisa los tipos de variables

tipo básico

booleano (bool)

número

cadena

nulo

indefinido

tipo de referencia

objeto

función

matriz

Almacenamiento de tipos primitivos y tipos de referencia

Los tipos básicos generalmente se almacenan en la pila (la pila es pequeña)

Una vez que se fija el tamaño de la pila, puede causar un desbordamiento
La pila es generalmente el primero en entrar, el último en salir.
La dirección del montón utilizada para almacenar tipos básicos y tipos de referencia.
corre rapido

Los tipos de referencia generalmente se almacenan en el montón (tamaño del montón)

El tamaño del montón no está confirmado y se puede expandir
JS no puede manipular directamente los datos del montón
Almacenamiento fuera de servicio
Es lento porque su tamaño no es fijo y el orden no es fijo

Diagrama de pila

Contenido de la pila Cuando el programa termina de ejecutarse, la pila está vacía

Sin embargo, si falta el contenido del montón, debe estar vacío. Puede parecer que no hay ningún puntero al contenido del montón, por lo que se convertirá en basura.

Por lo tanto, debemos apuntar manualmente a nulo para permitir que se destruya.

Dos, copia superficial

Copia profunda y superficial en dos casos Tipo de referencia Tipo básico

Los tipos básicos son copias profundas

La mayoría de los tipos de referencia son copias superficiales y también pueden convertirse en copias profundas.

La dirección de la copia profunda es diferente, uno cambia al otro y no sigue el cambio, es decir, la dirección del contenido de la copia profunda es diferente

La dirección de la copia superficial es la misma, una cambia y la otra cambia en consecuencia, es decir, la copia superficial copia la dirección

深拷贝
let a = 10;
let b = a;
console.log(1,a,b,a===b);
a = 88;
console.log(2,a,b,a===b);
console.log("======================");
浅拷贝
let obj1 = {
n : 88
}
let obj2 = obj1;
console.log(1,obj1,obj2,obj1===obj2);
obj1.a = 99;
console.log(2,obj1,obj2,obj1===obj2);

实现深拷贝 array object
1.JSON.stringify JSON.parse
let obj1 = {
n : 88
}
let obj2 = JSON.parse(JSON.stringify(obj1)); //深拷贝
console.log(1,obj1,obj2,obj1===obj2);
obj1.a = 99;
console.log(2,obj1,obj2,obj1===obj2);
2. ... 解构
let arr1 = [1,5,6,7];
let arr2 = [...arr1];
console.log(1,arr1,arr2,arr1===arr2);
arr1[0] = "222"
console.log(2,arr1,arr2,arr1===arr2);

// 伪拷贝一般情况下是第一层深拷贝后面层浅拷贝
let arr1 = [1,2,3,[6,7,8]];
let arr2 = arr1.slice();
console.log(1,arr1,arr2,arr1 === arr2);
arr1[0] = 180;
arr1[3][0] = 666;
console.log(2,arr1,arr2,arr1 === arr2);
let arr1 = [1,2,3,[6,7,8]];
let arr2 = arr1.concat();
console.log(1,arr1,arr2,arr1 === arr2);
arr1[0] = 180;
arr1[3][0] = 666;
console.log(2,arr1,arr2,arr1 === arr2);

let menu1 = {
menu: "菜单",
item:{
type: "menu",
name: "子菜单"
}
}
// Object.assign(目标,源)
let menu2 = Object.assign({},menu1)
console.log(1,menu1,menu2,menu1 === menu2);
menu1.menu = "编辑"
menu1.item.name = "保存"
console.log(2,menu1,menu2,menu1 === menu2);

Qué hacer si quieres resolver la copia real

Aplane el método de pensamiento multicapa anidado para aplanar el pensamiento recursivo para él

pensamiento recursivo

Ordinario como normal

La profundidad (tipo de referencia) se procesa recursivamente hasta que no haya tipos de referencia...

let woniu = {
name: "张三",
age: 8,
school: [
{
id: 1,
name: "清华校区"
},
{
id: 2,
name: "北大校区"
},
{
id: 3,
name: "上交校区"
},
{
id: 4,
name: "国科大校区"
}
],
subject: {
web: "web前端",
java: "java后端",
python: "python",
ui: "设计"
}
}
function copyData(source) {
// 定义一个容器容器需要根据源来决定源是对象你就是你对象源是数组你就是数组
let result = Array.isArray(source) ? [] : {};
for (const item in source) { // 遍历源对象与数组的统一遍历方式是 for in
if (typeof source[item] === "object") { //区分引用类型与普通类性别引用类型继续处理(遍历)基本类型直接返回
result[item] = copyData(source[item])
} else {
result[item] = source[item];
}
}
return result; // 最终将结果返回
}
let fanyun = copyData(woniu);
console.log(1,woniu,fanyun);
woniu.subject.web = "web大前端"
woniu.school[0].name = "总校区"
console.log(2,woniu,fanyun);

[Frontend] Copia profunda y superficial