浅谈js深拷贝和浅拷贝以及方法

1.现象

一句话解释下它俩的区别：
假设B复制了A，当修改A时，看B是否会发生变化，如果B也跟着改变，说明这是浅拷贝；如果B没变，那就是深拷贝。

实际开发中遇到的其实就是这样疑惑：

let a = {name: '我是A'}
let b = a
console.log(a)  // {name: "我是A"}
console.log(b)  // {name: "我是A"}

b.name = '我是B'
console.log(a)  // {name: "我是B"}
console.log(b)  // {name: "我是B"}

/*  为什么 a 的值也发生变化？  */

这里需要解释下js中数据类型 以及堆栈

2.数据类型

基本数据类型
String, Number, Boolean, Null, Undefined, Symbol
引用数据类型
Object, Array, Function, RegExp, Date 等

基本数据——类型它们键值都存在栈内存中：

let a = 1
let b = a

它们在内存中表现为：

let a =1; let b = a

所以说，基本数据类型做修改，修改a或者修改b不会对对方造成影响。

我们看下引用数据——键存在栈内存，值存在堆内存中：
但是栈内存会提供一个引用的地址指向堆内存中的值

let a = [0,1,2]
let b = a

let a = [0,1,2]

let b = a

let a = [0,1,2]
let b = a
b[0] = 1
console.log(a)  // [1, 1, 2]
console.log(b)  // [1, 1, 2]

b[0] = 1

开辟一个新的地址

3.方法

• Object.assign()

Object.assign(target, ...sources);

target: 目标对象
sources: 源对象

// demo
let obj1 = {a: 1, b: 2}
let obj2 = Object.assign({c: 4, d: 5}, obj1)

console.log(obj1); //  {a: 1, b: 2}
console.log(obj2); //  {c: 4, d: 5, a: 1, b: 2}

• Array.prototype.concat()

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])

let arr = [1, 2, { name: 'A' }]
let arr2 = arr.concat()    
arr2[2].name = 'B'
console.log(arr)  // [1, 2, { name: 'B' }]
console.log(arr2)  // [1, 2, { name: 'B' }]

• Array.prototype.slice()

arr.slice()
arr.slice(begin)
arr.slice(begin, end)

let arr = [1, 2, { name: 'A' }]
let arr2 = arr.slice()    
arr2[2].name = 'B'
console.log(arr)  // [1, 2, { name: 'B' }]
console.log(arr2)  // [1, 2, { name: 'B' }]

注意：以上方法对一维数组对象进行拷贝，也就是说，只有一层的时候它才是深拷贝

• JSON.parse(JSON.stringify())

用JSON.stringify将对象转成JSON字符串，再用JSON.parse()把字符串解析成对象，一去一来，新的对象产生了，而且对象会开辟新的栈，开辟一个新的地址，实现深拷贝
但是，不可以拷贝 undefined, function, RegExp 等

let obj1 = { a: 1, b: 2, c: 3 }
let str = JSON.stringify(obj1);
let obj2 = JSON.parse(str);
obj2.a = 5;
console.log(obj1.a);  // 1
console.log(obj2.a); // 5

• 递归

function deepClone(target) {
    // 定义一个变量
    let result;
    // 如果当前需要深拷贝的是一个对象的话
    if (typeof target === 'object') {
    // 如果是一个数组的话
        if (Array.isArray(target)) {
            result = []; // 将result赋值为一个数组，并且执行遍历
            for (let i in target) {
                // 递归克隆数组中的每一项
                result.push(deepClone(target[i]))
            }
         // 判断如果当前的值是null的话；直接赋值为null
        } else if(target===null) {
            result = null;
         // 判断如果当前的值是一个RegExp对象的话，直接赋值    
        } else if(target.constructor===RegExp){
            result = target;
        }else {
         // 否则是普通对象，直接for in循环，递归赋值对象的所有值
            result = {};
            for (let i in target) {
                result[i] = deepClone(target[i]);
            }
        }
     // 如果不是对象的话，就是基本数据类型，那么直接赋值
    } else {
        result = target;
    }
     // 返回最终结果
    return result;
}

注：此方法虽然可以拷贝Function, null, undefined 等类型，但是不是很完善，使用要根据自己逻辑进行更改。

最后，留下赞再走！