深拷贝.js

/**
 * 深拷贝：将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象
 */

/**
 * JSON.parse 方法
 *
 * 缺点：
 * 1. 他无法实现对函数 、RegExp等特殊对象的克隆
 * 2. 会抛弃对象的constructor,所有的构造函数会指向Object
 * 3. 对象有循环引用,会报错
 */
function deepClone(target) {
  return JSON.parse(JSON.stringify(target));
}

/**
 * 基础版本
 * 1. 考虑到数组类型
 * 2. 深层遍历
 */
function deepClone(target) {
  if (typeof target !== "object" || target === null) {
    return target;
  }
  const cloneTarget = Array.isArray(target) ? [] : {};
  for (const key in target) {
    cloneTarget[key] = deepClone(target[key]);
  }
  return cloneTarget;
}

/**
 * 升级版本
 * 1. 考虑循环引用，使用键值为弱引用类型的 WeakMap 对象，缓存已遍历对象
 * 2. 性能优化，使用 while 循环语句代替 for in
 */
const forEach = (array, iterator) => {
  let index = -1;
  while (++index < array.length) {
    iterator(array[index], index);
  }
};

function deepClone(target, map = new WeakMap()) {
  if (typeof target !== "object" || target === null) {
    return target;
  }
  const isArray = Array.isArray(target);
  const cloneTarget = isArray ? [] : {};
  if (map.has(target)) {
    return map.get(target);
  }
  map.set(target, cloneTarget);
  const keys = isArray ? undefined : Object.keys(target);
  forEach(keys || target, (value, key) => {
    if (keys) {
      key = value;
    }
    cloneTarget[key] = deepClone(target[key], map);
  });
  return cloneTarget;
}

/**
 * 最终版本
 * 考虑深拷贝类型：Set、Map、Function、Array、Object、Arguments 类型
 * 考虑特殊拷贝类型：Boolean、Number、String、Error、Date、RegExp、Symbol 类型
 */
const deepCloneMapping = ["Set", "Map", "Array", "Object", "Arguments"];

const getType = target => Object.prototype.toString.call(target).slice(8, -1);

const forEach = (array, iterator) => {
  let index = -1;
  while (++index < array.length) {
    iterator(array[index], index);
  }
};

const cloneReg = targe => {
  const regFlags = /\w*$/;
  const result = new targe.constructor(targe.source, regFlags.exec(targe));
  result.lastIndex = targe.lastIndex;
  return result;
};

const cloneSymbol = target => Object(Symbol.prototype.valueOf.call(targe));

const cloneFunction = target => {
  if (!target.prototype) return eval(funcString);
  const bodyReg = /(?<={)(.|\n)+(?=})/m;
  const paramReg = /(?<=\().+(?=\)\s+{)/;
  const funcString = target.toString();
  const param = paramReg.exec(funcString);
  const body = bodyReg.exec(funcString);
  if (body) {
    if (param) {
      const params = param[0].split(",");
      return new Function(...params, body[0]);
    } else {
      return new Function(body[0]);
    }
  } else {
    return null;
  }
};

const cloneOtherType = (targe, type) => {
  switch (type) {
    case "Boolean":
    case "Number":
    case "String":
    case "Error":
    case "Date":
      return new targe.constructor(targe);
    case "RegExp":
      return cloneReg(targe);
    case "Symbol":
      return cloneSymbol(targe);
    case "Function":
      return cloneFunction(targe);
    default:
      return null;
  }
};

function deepClone(target, map = new WeakMap()) {
  const type = getType(target);
  const isArray = type === "Array";
  let cloneTarget = isArray ? [] : {};
  if (target && typeof target !== "object") {
    return target;
  }
  if (deepCloneMapping.includes(type)) {
    cloneTarget = new target.constructor();
  } else {
    return cloneOtherType(target, type);
  }
  if (map.has(target)) {
    return map.get(target);
  }
  map.set(target, cloneTarget);
  if (type === "Set") {
    target.forEach(value => {
      cloneTarget.add(deepClone(value));
    });
    return cloneTarget;
  }
  if (type === "Map") {
    target.forEach((value, key) => {
      cloneTarget.set(key, deepClone(value));
    });
    return cloneTarget;
  }
  const keys = isArray ? undefined : Object.keys(target);
  forEach(keys || target, (value, key) => {
    if (keys) {
      key = value;
    }
    cloneTarget[key] = deepClone(target[key], map);
  });
  return cloneTarget;
}