js-utils-chs/src/object/deepClone.js

自定义工具函数库

/**
 *  对象深度克隆
 * @param {any} target 
 * @param {Map()} map 
 * @returns any
 */

/**
 *  测试数据
        const obj1 = {
            a: 1,
            b: ['e', 'f', 'g'],
            c: { h: { i: 2 } },
            d: function () { }
        }
        obj1.b.push(obj1.c)
        obj1.c.j = obj1.b

        let datas = deepClone(obj1);
 */

export function deepClone(target, map = new Map()) {
    if (target !== null && typeof target === 'object') {
        // 从缓存容器中读取克隆对象
        let cloneTarget = map.get(target)
        // 如果存在, 返回前面缓存的克隆对象
        if (cloneTarget) {
            return cloneTarget
        }
        // 创建克隆对象(可能是{}或者[])  
        if (target instanceof Array) {
            cloneTarget = []
            // 缓存到map中
            map.set(target, cloneTarget)
            target.forEach((item, index) => {
                cloneTarget[index] = deepClone(item, map)
            })
        } else {
            cloneTarget = {}
            // 缓存到map中
            map.set(target, cloneTarget)
            Object.keys(target).forEach(key => {
                cloneTarget[key] = deepClone(target[key], map)
            })
        }
        return cloneTarget
    }
    return target
}

/**
 * 对象深度合并
 * @param {Object} target 
 * @param {Object} soutce 
 */
export function deepMege(target = {}, soutce = {}) {
    if (typeof target !== 'object' || typeof soutce !== 'object') return false;
    target = deepClone(target);

    for (let prop in soutce) {
        if (!soutce.hasOwnProperty(prop)) continue;
        if (prop in target) {
            if (typeof target[prop] !== 'object') {
                target[prop] = soutce[prop];
            } else {
                if (typeof soutce[prop] !== "object") {
                    target[prop] = soutce[prop];
                } else {
                    // 判断是不是数组，是数组就合并数组
                    if (target[prop].concat && soutce[prop].concat) {
                        target[prop] = target[prop].concat(soutce[prop])
                    } else {
                        // 如果都是对象，递归合并
                        target[prop] = deepMege(target[prop], soutce[prop]);
                    }
                }
            }
        } else {
            target[prop] = soutce[prop]
        }
    }
    return target
}