深入深入再深入 js 深拷贝对象

最新推荐文章于 2024-08-23 15:07:54 发布
最新推荐文章于 2024-08-23 15:07:54 发布
阅读量162 收藏
点赞数
文章标签： 面试 测试 json
原文链接：https://juejin.im/post/5ad6b72f6fb9a028d375ecf6
版权

前言

对象是 JS 中基本类型之一，而且和原型链、数组等知识息息相关。不管是面试中，还是实际开发中我们都会碰见深拷贝对象的问题。

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

通常有下面两种方法实现深拷贝：

  1. 迭代递归法
  2. 序列化反序列化法

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

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. 迭代递归法

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

// 迭代递归法：深拷贝对象与数组
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)
复制代码

    结果：

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

    为什么不变呢？这个问题留给读者自己去探寻，嘿嘿~不过可以提示下，这跟 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))
}
复制代码

结果：

我们发现，它也只能深拷贝对象和数组，对于其他种类的对象，会失真。这种方法比较适合平常开发中使用，因为通常不需要考虑对象和数组之外的类型。

深入深入再深入

  1. 对象成环怎么办？ 我们给 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 作为哈希表，因为它的键是弱引用的，而我们这个场景里键恰好是对象，需要弱引用。

  2. 键不是字符串而是 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
}
复制代码

  3. 拷贝原型上的属性

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

    我们创建一个 childTest 变量，让 result 为它的深拷贝结果，其他不变：

    let childTest = Object.create(test)
let result = deepClone(childTest)
复制代码

    这时，我们最初提供的四种实现只有 for...in 的实现能正确拷贝，为什么呢？原因还是在结构化克隆算法里：原形链上的属性也不会被追踪以及复制。

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

  4. 需要拷贝不可枚举的属性

    第四种情况，就是我们需要拷贝类似属性描述符，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
}
复制代码

    结果：

结语

  1. 日常深拷贝，建议序列化反序列化方法。
  2. 面试时遇见面试官搞事情，写一个能拷贝自身可枚举、自身不可枚举、自身 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)
}

复制代码

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

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

weixin_34194317
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JS手写深浅拷贝，不同实现方法，它们的优缺？
小小前端攻城狮的博客
04-12 387
浅拷贝：只考虑对象类型。 function shallowCopy(obj) { if (typeof obj !== 'object') return obj let newObj = obj instanceof Array ? [] : {} for (let key in obj) { if (obj.hasOwnProperty(key)) { newObj[key] = obj[key] } }
深入理解对象的克隆及深浅拷贝
qq_41552331的博客
04-08 302
目录克隆对象为什么要用克隆?克隆的两种方式浅克隆：实现 Cloneable 接口并重写 Object 类中的 clone()方法；clone()方法下进行深拷贝：new 一个对象和clone一个对象的区别深克隆：实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，深浅拷贝浅拷贝（Shallow Copy）浅拷贝的实现方式：深拷贝（Deep Copy） ...
如何实现一个惊艳面试官的非递归版本的 js 对象深拷贝方法
flytam的博客
03-28 1009
众所周知，js 语言本身是不提供对象的深拷贝的功能，无论是直接赋值、Object.assign、展开运算符...都只是浅拷贝，关于 js 的深浅拷贝的一些概念可以参考我比较久以前写过的一篇文章 关于如何实现深拷贝，网上有很多相关的文章和实现都非常完美，本文主要讲述的是用一种非常规的使用非递归方法实现深拷贝 本文的深拷贝只考虑数组、对象、简单值三种数据类型 要实现判断数据类型，先来实现这 3...
死循环（栈溢出）——深拷贝和浅拷贝的原因
CW_SZDX的博客
05-14 682
死循环代码 private List<Map<String, Object>> getJinJiangChildren(List<Map<String, Object>> list, String pcode) { List<Map<String, Object>> result = new ArrayList(); //沿用ssx做法，和递归一个效果 for (Map<Strin
关于JS中对象的深拷贝问题
10-09 167
1、最简单最省事JSON 问题：function 和 undefined 两种类型的值会被忽略（不考虑自定义和API中提供的复杂类型） function clone(obj) { return JSON.parse(JSON.stringify(obj)) } 2、使用JQuery 问题：循环引用会导致内存溢出 $.extend( [deep ], target, object1 [, objectN ] ) 3、自己实现 版本1.0，简单实现，递归运行效率低，次数过多的话容易造成
javascript深拷贝、浅拷贝和循环引用深入理解
10-18
JavaScript中的深拷贝和浅拷贝是编程中常见的概念，主要涉及到对象和数组的复制。在JavaScript中，数据类型分为基本数据类型（如Number、String、Boolean等）和引用数据类型（如Object、Array等）。基本类型直接存储...
JavaScript基于遍历操作实现对象深拷贝功能示例
10-17
本篇文章将深入探讨如何基于遍历操作实现JavaScript对象的深拷贝。 首先，我们需要一个函数来确定变量的类型。在提供的代码中，`getType` 函数用于获取传入对象的类型，考虑到了 `typeof` 的特殊情况，如数组和null...
深入剖析javascript中的深拷贝和浅拷贝1
08-08
- `slice()`和`concat()`方法：对于一维数组，它们可以实现深拷贝，但如果数组包含对象，它们只会拷贝对象引用，不是真正的深拷贝。 - `JSON.parse()`和`JSON.stringify()`：可以将数组或对象转换为JSON字符串，...
javascript深拷贝(deepClone)详解
10-21
下面我们将深入探讨如何实现JavaScript的深拷贝。 首先，了解JavaScript的数据类型至关重要。JavaScript有七种原始数据类型（或称为基本类型）：Undefined、Null、Boolean、Number、String、Symbol（ES6新增）和...
实现JS深拷贝最简单粗暴的方法
weixin_30654583的博客
09-26 348
var obj = { name : 'zhl', age : 30 } var obj2 = JSON.parse(JSON.stringify(obj)); obj2.age = 40; console.log(obj.age); //30 转载于:https://www.cnblogs.com/vsmart/p/7596699.html
for(var key in object){}语句枚举
十三月的博客
04-26 8984
for in语句可以用来列举出一个变量的所有成员。如果object是函数(或类即构造函数)，那么将列出函数的所有静态成员；如果object是对象，那就是所有实例成员，key的类型是一个字符串，表示成员的名称。 运用实例： let list=''; let params = data.data.messages; ...
JS中for(var key in o )语法
热门推荐
weixin_42689147的博客
11-17 1万+
 1. o不只可以是对象，key也不只可以是对象中的键。  2. o也可以是一个数组，这时候的key就是数组的下标，从"0"开始，注意下标“0”是个字符串类型。  **注意：这种循环在 IE8浏览器下 对于数组 会有问题  会一直循环下去 即使o[key]为undefined。**...
JS实现深拷贝
weixin_30298497的博客
08-03 176
目录 深拷贝 一、赋值、浅拷贝与深拷贝的区别 二、深拷贝的方法 1.JSON转换 2.普通递归函数 3.防栈溢出函数 深拷贝 一、赋值、浅拷贝与深拷贝的区别 二、深拷贝的方法 1.JSO...
js对象深拷贝
小前端
10-11 6886
前置知识基本类型和引用类型　　基本类型：存放在栈内存中的简单数据段，数据大小确定，内存空间大小可以分配。　　5种基本数据类型有Undefined、Null、Boolean、Number 和 String，它们是直接按值存放的，所以可以直接访问。　　引用类型：存放在堆内存中的对象，变量实际保存的是一个指针，这个指针指向另一个位置。每个空间大小不一样，要根据情况开进行特定的分配。　　当我们需要访问引用类
原生js实现深拷贝
qq_41524596的博客
09-02 314
 思路：利用递归去遍历每一个引用类型值直到为值类型，然后对值类型进行赋值操作  基本知识： 　javascript原生遍历方法的建议用法： 用for循环遍历数组 用for-in遍历对象 用for-of遍历类数组对象（ES6） 用Object.keys()获取对象属性名的集合 var arrTmp = [{ aa: "value1", bb: "value2" }, "value2",...
「JavaScript」带你彻底搞清楚深拷贝、浅拷贝和循环引用
weixin_34186950的博客
05-26 282
一、为什么有深拷贝和浅拷贝？ 这个要从js中的数据类型说起，js中数据类型分为基本数据类型和引用数据类型。 基本类型值指的是那些保存在栈内存中的简单数据段，即这种值是完全保存在内存中的一个位置。包含Number，String，Boolean，Null，Undefined ，Symbol。 引用类型值指的是那些保存...
js递归实现深拷贝
我们明天会更好的博客
07-26 3535
function deepClone(source){ const targetObj = source.constructor === Array ? [] : {}; // 判断复制的目标是数组还是对象 for(let keys in source){ // 遍历目标 if(source.hasOwnProperty(keys)){ if(source[keys] ...
一道面试题 用深拷贝和递归实现（很像虚拟dom树）
weixin_33962621的博客
10-22 207
如何实现： 递归 深拷贝的三种实现方式 1、JSON方法实现 //_tmp和result是相互独立的，没有任何联系，有各自的存储空间。 let deepClone = function (obj) { let _tmp = JSON.stringify(obj);//将对象转换为json字符串形式 let result = JSON.parse(_tmp);//将转换而来的字符...
常见面试问题(Python)
最新发布
jiao_mrswang的博客
08-23 129
5、GIL全局解释锁。
深入理解jQuery对象复制：浅拷贝与深拷贝解析
"这篇文档主要讲解了jQuery中对象拷贝的相关知识，包括浅拷贝和深拷贝的概念，以及如何使用`$.extend`方法进行对象拷贝。文档通过实例展示了拷贝过程中属性值的覆盖以及对象嵌套时拷贝的特性。" 在JavaScript中，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值