JavaScript 引用赋值、浅拷贝与深拷贝完全解析

let a = 10;
let b = a; // 直接复制值
b = 20;
console.log(a); // 10（不受 b 修改影响）
console.log(b); // 20

let a = [1, 2, 5];
let b = a; // 引用赋值（复制指针）
a[1] = 4; // 修改 a 指向的数组
console.log(a); // [1, 4, 5]
console.log(b); // [1, 4, 5]（b 也受影响）
console.log(a === b); // true（指向同一个对象）

const a = [1, 2, [3, 4], 5];
const b = [...a]; // 浅拷贝

a[0] = 100;
console.log(b[0]); // 1（不受影响，基本类型独立）

a[2][1] = 400; // 修改子数组元素
console.log(b[2][1]); // 400（受影响，共享子数组引用）

// 原始对象
const a = {
  name: "alice",  // 基本类型（栈内存存储值）
  profile: {      // 引用类型（堆内存存储对象，栈内存存储指针）
    age: 25,
    city: "beijing"
  }
};

// 使用扩展运算符进行浅拷贝
const b = { ...a };

// 修改浅拷贝对象
b.name = "bob";
b.profile.age = 30;
b.profile.city = "shanghai";

// 查看结果
console.log("原始对象 a.name:", a.name); 
// 输出："alice"（基本类型值独立，不受影响）

console.log("原始对象 a.profile.age:", a.profile.age); 
// 输出：30（引用类型共享堆内存，被修改）

console.log("原始对象 a.profile.city:", a.profile.city); 
// 输出："shanghai"（引用类型共享堆内存，被修改）

console.log("a.profile === b.profile:", a.profile === b.profile); 
// 输出：true（两者指向堆中同一个对象）

const obj = { a: 1, b: { c: 2 } };
const shallowCopy = { ...obj };

const obj = { a: 1, b: { c: 2 } };
const shallowCopy = Object.assign({}, obj);

const arr = [1, 2, { a: 3 }];
const shallowCopy1 = arr.slice();
const shallowCopy2 = [].concat(arr);

const arr = [1, 2, { a: 3 }];
const shallowCopy = Array.from(arr);

// 原始对象
const a = {
  name: "alice",  // 基本类型（栈内存存储值）
  profile: {      // 引用类型（堆内存存储对象）
    age: 25,
    city: "beijing"
  }
};

// 实现深拷贝
const deepCopy = JSON.parse(JSON.stringify(a));

// 修改深拷贝对象的属性
deepCopy.name = "bob"; // 修改基本类型
deepCopy.profile.age = 30; // 修改嵌套引用类型
deepCopy.profile.city = "shanghai";

// 查看结果对比
console.log("原始对象 a.name:", a.name); 
// 输出："alice"（基本类型不受影响）

console.log("原始对象 a.profile.age:", a.profile.age); 
// 输出：25（嵌套引用类型也不受影响）

console.log("原始对象 a.profile.city:", a.profile.city); 
// 输出："beijing"（嵌套引用类型完全独立）

console.log("a.profile === deepCopy.profile:", a.profile === deepCopy.profile); 
// 输出：false（两者指向堆中不同对象）