深浅拷贝

const shallowCloneByDeconst = obj => ({ ...obj });

const shallowCloneByObjectAssign = obj => Object.assign({}, obj);

// 1. Array.prototype.concat()
const shallowCloneByConcat = arr => arr.concat();
// 2. Array.prototype.slice()
const shallowCloneBySlice = arr => arr.slice();

const deepCloneByJson = obj => JSON.parse(JSON.stringify(obj));

// 获取构造函数类型
const getCtorType = tar => Object.prototype.toString.call(tar).slice(8, -1);
// 判断是否是引用类型
const isObject = target => target && (typeof target == 'object' || typeof target == 'function');
// 拷贝函数
const cloneFunction = func => {
    const bodyReg = /(?<={)(.|\n)+(?=})/m;
    const paramReg = /(?<=\().+(?=\)\s+{)/;
    const funcString = func.toString();
    if (func.prototype) {
        const param = paramReg.exec(funcString);
        const body = bodyReg.exec(funcString);
        if (body) {
            if (param) {
                const paramArr = param[0].split(',');
                return new Function(...paramArr, body[0]);
            } else {
                return new Function(body[0]);
            }
        } else {
            return null;
        }
    } else {
        return eval(funcString);
    }
}

/**
 * 递归深拷贝
 * @param {any} obj 待拷贝对象
 * @param {WeakMap | undefined} dict 处理循环引用所使用的字典
 */
const deepClone = (obj, dict = new WeakMap()) => {
    // 处理基本类型
    if (!isObject(obj)) return obj;
    // 处理环
    if (dict.has(obj)) return dict.get(obj);

    let newObj;
    let type = getCtorType(obj);

    switch (type) {
        case 'Number':
            newObj = new Number(obj.valueOf());
            break;

        case 'String':
            newObj = new String(obj.toString());
            break;

        case 'Boolean':
            newObj = new Boolean(obj.valueOf());
            break;

        case 'Date':
            newObj = new Date(obj.getTime());
            break;

        case 'Function':
            newObj = cloneFunction(obj);
            break;

        case 'Symbol':
            newObj = Object(Symbol.prototype.valueOf.call(newObj));
            break;

        case 'RegExp':
            newObj = new RegExp(obj.source /* 匹配表达式 */, /\w*$/.exec(obj) /* 匹配模式 */);
            // 重置上次匹配后的位置记录
            newObj.lastIndex = obj.lastIndex;
            break;

        case 'Error':
            newObj = new Error(obj.toString().slice(7, -1));
            break;

        default:
            newObj = new obj.constructor(obj);
            break;
    }
    for (const key in obj) {
        newObj[key] = isObject(obj[key])
            ? deepClone(obj[key])
            : obj[key];
    }
    dict.set(obj, newObj);

    return newObj;
};