深克隆（deepclone）

悠悠 2023-08-17 15:55 99阅读 0赞

1.简单版：

<script type="text/javascript">
    const newObj = JSON.parse(JSON.stringify(oldObj));
    </script>

局限性：  
他无法实现对函数 、RegExp等特殊对象的克隆  
会抛弃对象的constructor,所有的构造函数会指向Object  
对象有循环引用,会报错

2.面试版:

<script type="text/javascript">
                /**
                 * deep clone
                 * @param  {[type]} parent object 需要进行克隆的对象
                 * @return {[type]}        深克隆后的对象
                 */
                const clone = parent => {
                    // 判断类型
                    const isType = (obj, type) => {
                        if (typeof obj !== "object") return false;
                        const typeString = Object.prototype.toString.call(obj);
                        let flag;
                        switch (type) {
                            case "Array":
                                flag = typeString === "[object Array]";
                                break;
                            case "Date":
                                flag = typeString === "[object Date]";
                                break;
                            case "RegExp":
                                flag = typeString === "[object RegExp]";
                                break;
                            default:
                                flag = false;
                        }
                        return flag;
                    };
    
                    // 处理正则
                    const getRegExp = re => {
                        var flags = "";
                        if (re.global) flags += "g";
                        if (re.ignoreCase) flags += "i";
                        if (re.multiline) flags += "m";
                        return flags;
                    };
                    // 维护两个储存循环引用的数组
                    const parents = [];
                    const children = [];
    
                    const _clone = parent => {
                        if (parent === null) return null;
                        if (typeof parent !== "object") return parent;
    
                        let child, proto;
    
                        if (isType(parent, "Array")) {
                            // 对数组做特殊处理
                            child = [];
                        } else if (isType(parent, "RegExp")) {
                            // 对正则对象做特殊处理
                            child = new RegExp(parent.source, getRegExp(parent));
                            if (parent.lastIndex) child.lastIndex = parent.lastIndex;
                        } else if (isType(parent, "Date")) {
                            // 对Date对象做特殊处理
                            child = new Date(parent.getTime());
                        } else {
                            // 处理对象原型
                            proto = Object.getPrototypeOf(parent);
                            // 利用Object.create切断原型链
                            child = Object.create(proto);
                        }
    
                        // 处理循环引用
                        const index = parents.indexOf(parent);
    
                        if (index != -1) {
                            // 如果父数组存在本对象,说明之前已经被引用过,直接返回此对象
                            return children[index];
                        }
                        parents.push(parent);
                        children.push(child);
    
                        for (let i in parent) {
                            // 递归
                            child[i] = _clone(parent[i]);
                        }
    
                        return child;
                    };
                    return _clone(parent);
                };
            </script>

局限性:  
  
一些特殊情况没有处理: 例如Buffer对象、Promise、Set、Map  
另外对于确保没有循环引用的对象，我们可以省去对循环引用的特殊处理，因为这很消耗时间

转载于:https://www.cnblogs.com/wangxi01/p/11590189.html

发表评论取消回复

表情：

评论列表（有 0 条评论，99人围观）

还没有评论，来说两句吧...

相关阅读

相关浅克隆(ShallowClone)和深克隆(DeepClone)区别以及实现

什么是克隆克隆就是依据已经有的数据，创造一份新的完全一样的数据拷贝。浅克隆和深克隆区别浅克隆：被Clone的对象的所有变量都含有原来对象相同的值，而

超、凢脫俗/ 2023年05月22日 08:45/ 0 赞/ 122 阅读

相关浅克隆和深克隆

什么是浅克隆和浅克隆基本定义：浅克隆：直接将存储在栈中的值赋值给对应变量，如果是基本数据类型，则直接赋值对应的值，如果是引用类型，则赋值的是地址。深克隆：就是把

怼烎@/ 2022年12月01日 11:57/ 0 赞/ 224 阅读

相关 JS_js深克隆

function deepClone(obj){ //判断是否是简单数据类型 if(typeof obj === 'object'){

拼搏现实的明天。/ 2022年10月31日 12:12/ 0 赞/ 143 阅读

相关 JAVA深复制(深克隆)与浅复制(浅克隆)

1．浅复制与深复制概念 ⑴浅复制（浅克隆）被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑

「爱情、让人受尽委屈。」/ 2022年07月15日 07:51/ 0 赞/ 380 阅读

相关深克隆一个对象

<table style="border-collapse:collapse; border-spacing:0px; margin:0px; width:auto; bord

我不是女神ヾ/ 2022年06月16日 07:18/ 0 赞/ 230 阅读

相关 Java之浅克隆和深克隆

克隆就是复制一个对象的副本，但一个对象中有可能有基本数据类型，如 int,long,float等，也可能含有对象引用数据类型，如数组，集合等浅克隆：被复制对象的所

灰太狼/ 2022年05月31日 04:44/ 0 赞/ 268 阅读

相关 Java对象克隆——浅克隆和深克隆的区别

在[Java][]中对象的克隆有深克隆和浅克隆之分。有这种区分的原因是Java中分为基本数据类型和引用数据类型，对于不同的数据类型在内存中的存储的区域是不同的。基本数据类型存储

秒速五厘米/ 2022年05月16日 00:55/ 0 赞/ 298 阅读

相关 JAVA深复制(深克隆)与浅复制(浅克隆)

浅复制与深复制概念 1.浅复制（浅克隆）被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的

「爱情、让人受尽委屈。」/ 2022年04月22日 15:18/ 0 赞/ 228 阅读

相关 JavaScript之深度克隆（deepClone）

var obj = \{ name : 'abc', age : 18,

男娘i/ 2022年03月12日 08:41/ 0 赞/ 225 阅读

相关 Java 浅/深克隆、克隆数组

文章目录 1 clone 方法介绍 2 浅克隆示例 3 深克隆简单引用示例 4 深克隆列表示例 5 深

﹏ヽ暗。殇╰゛Y/ 2022年01月25日 15:41/ 0 赞/ 335 阅读