深刻深刻再深刻 js 深拷贝对象

时间 2019-11-06

标签深刻拷贝对象栏目 JavaScript 繁體版

原文原文链接

前言

对象是 JS 中基本类型之一，并且和原型链、数组等知识息息相关。不论是面试中，仍是实际开发中咱们都会遇见深拷贝对象的问题。前端

顾名思义，深拷贝就是完完整整的将一个对象从内存中拷贝一份出来。因此不管用什么办法，必然绕不开开辟一块新的内存空间。node

一般有下面两种方法实现深拷贝：git

迭代递归法
序列化反序列化法

咱们会基于一个测试用例对经常使用的实现方法进行测试并对比优劣：github

let test = {
    num: 0,
    str: '',
    boolean: true,
    unf: undefined,
    nul: null,
    obj: {
        name: '我是一个对象',
        id: 1
    },
    arr: [0, 1, 2],
    func: function() {
        console.log('我是一个函数')
    },
    date: new Date(0),
    reg: new RegExp('/我是一个正则/ig'),
    err: new Error('我是一个错误')
}

let result = deepClone(test)

console.log(result)
for (let key in result) {
    if (isObject(result[key]))
        console.log(`${key}相同吗？ `, result[key] === test[key])
}

// 判断是否为对象
function isObject(o) {
    return (typeof o === 'object' || typeof o === 'function') && o !== null
}
复制代码

1. 迭代递归法

这是最常规的方法，思想很简单：就是对对象进行迭代操做，对它的每一个值进行递归深拷贝。面试

for...in 法

// 迭代递归法：深拷贝对象与数组
function deepClone(obj) {
    if (!isObject(obj)) {
        throw new Error('obj 不是一个对象！')
    }

    let isArray = Array.isArray(obj)
    let cloneObj = isArray ? [] : {}
    for (let key in obj) {
        cloneObj[key] = isObject(obj[key]) ? deepClone(obj[key]) : obj[key]
    }

    return cloneObj
}
复制代码

结果：
复制代码

咱们发现，arr 和 obj 都深拷贝成功了，它们的内存引用已经不一样了，但 func、date、reg 和 err 并无复制成功，由于它们有特殊的构造函数。
复制代码

Reflect 法

// 代理法
function deepClone(obj) {
    if (!isObject(obj)) {
        throw new Error('obj 不是一个对象！')
    }

    let isArray = Array.isArray(obj)
    let cloneObj = isArray ? [...obj] : { ...obj }
    Reflect.ownKeys(cloneObj).forEach(key => {
        cloneObj[key] = isObject(obj[key]) ? deepClone(obj[key]) : obj[key]
    })

    return cloneObj
}
复制代码

结果：
复制代码

咱们发现，结果和使用 for...in 同样。那么它有什么优势呢？读者能够先猜一猜，答案咱们会在下文揭晓。
复制代码

lodash 中的深拷贝

著名的 lodash 中的 cloneDeep 方法一样是使用这种方法实现的，只不过它支持的对象种类更多，具体的实现过程读者能够参考 lodash 的 baseClone 方法。算法

咱们把测试用例用到的深拷贝函数换成 lodash 的：数组
```
let result = _.cloneDeep(test)
复制代码
```
结果： bash

咱们发现，arr、obj、date、reg深拷贝成功了，但 func 和 err 内存引用仍然不变。ide

为何不变呢？这个问题留给读者本身去探寻，嘿嘿~不过能够提示下，这跟 lodash 中的 cloneableTags 有关。函数

因为前端中的对象种类太多了，因此 lodash 也给用户准备了自定义深拷贝的方法 cloneDeepWith，好比自定义深拷贝 DOM 对象：
```
function customizer(value) {
  if (_.isElement(value)) {
    return value.cloneNode(true);
  }
}

var el = _.cloneDeepWith(document.body, customizer);
 
console.log(el === document.body);
// => false
console.log(el.nodeName);
// => 'BODY'
console.log(el.childNodes.length);
// => 20
复制代码
```

2.序列化反序列化法

这个方法很是有趣，它先把代码序列化成数据，再反序列化回对象：

// 序列化反序列化法
function deepClone(obj) {
    return JSON.parse(JSON.stringify(obj))
}
复制代码

结果：

咱们发现，它也只能深拷贝对象和数组，对于其余种类的对象，会失真。这种方法比较适合日常开发中使用，由于一般不须要考虑对象和数组以外的类型。

深刻深刻再深刻

对象成环怎么办？咱们给 test 加一个 loopObj 键，值指向自身：
```
test.loopObj = test
复制代码
```
这时咱们使用第一种方法中的 for..in 实现和 Reflect 实现都会栈溢出：

而使用第二种方法也会报错：

但 lodash 却能够获得正确结果：

为何呢？咱们去 lodash 源码看看：

由于 lodash 使用的是栈把对象存储起来了，若是有环对象，就会从栈里检测到，从而直接返回结果，回头是岸。这种算法思想来源于 HTML5 规范定义的结构化克隆算法，它同时也解释了为何 lodash 不对 Error 和 Function 类型进行拷贝。

固然，设置一个哈希表存储已拷贝过的对象一样能够达到一样的目的：
```
function deepClone(obj, hash = new WeakMap()) {
    if (!isObject(obj)) {
        return obj
    }
    // 查表
    if (hash.has(obj)) return hash.get(obj)

    let isArray = Array.isArray(obj)
    let cloneObj = isArray ? [] : {}
    // 哈希表设值
    hash.set(obj, cloneObj)

    let result = Object.keys(obj).map(key => {
        return {
            [key]: deepClone(obj[key], hash)
        }
    })
    return Object.assign(cloneObj, ...result)
}
复制代码
```
这里咱们使用 WeakMap 做为哈希表，由于它的键是弱引用的，而咱们这个场景里键刚好是对象，须要弱引用。

键不是字符串而是 Symbol

咱们修改一下测试用例：

var test = {}
let sym = Symbol('我是一个Symbol')
test[sym] = 'symbol'

let result = deepClone(test)
console.log(result)
console.log(result[sym] === test[sym])
复制代码

运行 for...in 实现的深拷贝咱们会发现：

拷贝失败了，为何？

由于 Symbol 是一种特殊的数据类型，它最大的特色即是独一无二，因此它的深拷贝就是浅拷贝。

但若是这时咱们使用 Reflect 实现的版本：

成功了，由于 for...in 没法得到 Symbol 类型的键，而 Reflect 是能够获取的。

固然，咱们改造一下 for...in 实现也能够：

function deepClone(obj) {
    if (!isObject(obj)) {
        throw new Error('obj 不是一个对象！')
    }

    let isArray = Array.isArray(obj)
    let cloneObj = isArray ? [] : {}
    let symKeys = Object.getOwnPropertySymbols(obj)
    // console.log(symKey)
    if (symKeys.length > 0) {
        symKeys.forEach(symKey => {
            cloneObj[symKey] =  isObject(obj[symKey]) ? deepClone(obj[symKey]) : obj[symKey]
        })
    }
    for (let key in obj) {
        cloneObj[key] = isObject(obj[key]) ? deepClone(obj[key]) : obj[key]
    }

    return cloneObj
}
复制代码

拷贝原型上的属性

众所周知，JS 对象是基于原型链设计的，因此当一个对象的属性查找不到时会沿着它的原型链向上查找，也就是一个非构造函数对象的 __proto__ 属性。

咱们建立一个 childTest 变量，让 result 为它的深拷贝结果，其余不变：
```
let childTest = Object.create(test)
let result = deepClone(childTest)
复制代码
```
这时，咱们最初提供的四种实现只有 for...in 的实现能正确拷贝，为何呢？缘由仍是在结构化克隆算法里：原形链上的属性也不会被追踪以及复制。

落在具体实现上就是：for...in 会追踪原型链上的属性，而其它三种方法(Object.keys、Reflect.ownKeys 和 JSON 方法)都不会追踪原型链上的属性：

须要拷贝不可枚举的属性

第四种状况，就是咱们须要拷贝相似属性描述符，setters 以及 getters 这样不可枚举的属性，通常来讲，这就须要一个额外的不可枚举的属性集合来存储它们。相似在第二种状况使用 for...in 拷贝 Symbol 类型键时：咱们给 test 变量里的 obj 和 arr 属性定义一下属性描述符：

Object.defineProperties(test, {
    'obj': {
        writable: false,
        enumerable: false,
        configurable: false
    },
    'arr': {
        get() {
            console.log('调用了get')
            return [1,2,3]
        },
        set(val) {
            console.log('调用了set')
        }
    }
})
复制代码

而后实现咱们的拷贝不可枚举属性的版本：

function deepClone(obj, hash = new WeakMap()) {
    if (!isObject(obj)) {
        return obj
    }
    // 查表，防止循环拷贝
    if (hash.has(obj)) return hash.get(obj)

    let isArray = Array.isArray(obj)
    // 初始化拷贝对象
    let cloneObj = isArray ? [] : {}
    // 哈希表设值
    hash.set(obj, cloneObj)
    // 获取源对象全部属性描述符
    let allDesc = Object.getOwnPropertyDescriptors(obj)
    // 获取源对象全部的 Symbol 类型键
    let symKeys = Object.getOwnPropertySymbols(obj)
    // 拷贝 Symbol 类型键对应的属性
    if (symKeys.length > 0) {
        symKeys.forEach(symKey => {
            cloneObj[symKey] = isObject(obj[symKey]) ? deepClone(obj[symKey], hash) : obj[symKey]
        })
    }

    // 拷贝不可枚举属性,由于 allDesc 的 value 是浅拷贝，因此要放在前面
    cloneObj = Object.create(
        Object.getPrototypeOf(cloneObj),
        allDesc
    )
    // 拷贝可枚举属性（包括原型链上的）
    for (let key in obj) {
        cloneObj[key] = isObject(obj[key]) ? deepClone(obj[key], hash) : obj[key];
    }

    return cloneObj
}
复制代码

结果：

结语

平常深拷贝，建议序列化反序列化方法。
面试时碰见面试官搞事情，写一个能拷贝自身可枚举、自身不可枚举、自身 Symbol 类型键、原型上可枚举、原型上不可枚举、原型上的 Symol 类型键，循环引用也能够拷的深拷贝函数：

// 将以前写的 deepClone 函数封装一下
function cloneDeep(obj) {
    let family = {}
    let parent = Object.getPrototypeOf(obj)

    while (parent != null) {
        family = completeAssign(deepClone(family), parent)
        parent = Object.getPrototypeOf(parent)
    }

    // 下面这个函数会拷贝全部自有属性的属性描述符,来自于 MDN
    // https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
    function completeAssign(target, ...sources) {
        sources.forEach(source => {
            let descriptors = Object.keys(source).reduce((descriptors, key) => {
                descriptors[key] = Object.getOwnPropertyDescriptor(source, key)
                return descriptors
            }, {})

            // Object.assign 默认也会拷贝可枚举的Symbols
            Object.getOwnPropertySymbols(source).forEach(sym => {
                let descriptor = Object.getOwnPropertyDescriptor(source, sym)
                if (descriptor.enumerable) {
                    descriptors[sym] = descriptor
                }
            })
            Object.defineProperties(target, descriptors)
        })
        return target
    }

    return completeAssign(deepClone(obj), family)
}

复制代码

有特殊需求的深拷贝，建议使用 lodash 的 copyDeep 或 copyDeepWith 方法。

最后感谢一下知乎上关于这个问题的启发，不管作什么，尽可能不要把简单的事情复杂化，深拷贝能不用就不用，它面对的问题每每能够用更优雅的方式解决，好比使用一个函数来获得对象，固然面试的时候装个逼是能够的。

深刻深刻再深刻 js 深拷贝对象

前言

1. 迭代递归法

for...in 法

Reflect 法

lodash 中的深拷贝

2.序列化反序列化法

深刻深刻再深刻

结语