面试手写深拷贝

很多面试都有手写深拷贝,道理都是懂
面试的时候就是写不上来,所以找时间自己手写了一遍
主要通过一个forEach函数遍历+递归的方式实现
首先判断是否引用类型,不是直接返回,若为引用类型进行递归赋值
因为用到递归,所以加入了weakMap优化
递归每次进入都判断一次类型然后根据不同的进行创建不同的对象然后进行赋值

// 可遍历类型 Map Set Object Array
const typeArray = '[object Array]'
const typeObject = '[object Object]'
const typeMap = '[object Map]'
const typeSet = '[object Set]'
// 非原始类型的 不可遍历类型  Date RegExp Function
const typeDate = '[object Date]'
const typeRegExp = '[object RegExp]'
const typeFunction = '[object Function]'

// 非原始类型的 不可遍历类型的 集合（原始类型已经被过滤了不用再考虑了）
const simpleType = [typeDate, typeRegExp, typeFunction]

// 是否是引用类型
const isObject = (target) => {
  if (target === null)
    return false
  else {
    const type = typeof target
    return type === 'object' || type === 'function'
  }
};

// 获取标准类型
const getType = (target) => {
  return Object.prototype.toString.call(target)
};


//克隆函数
const deepClone = (target, map = new WeakMap()) => {

  //如果不是引用类型,直接返回
  if (!isObject(target))
    return target

  //性能优化,如果放入过map中,直接在map中找到返回
  if (map.get(target))
    return map.get(target)

  //获取类型并初始化返回对象
  let targetType = getType(target)
  let cloneTarget

  //处理不可循环对象
  if (simpleType.includes(targetType)) {
    switch (targetType) {
    //日期
      case typeDate:
        return new Date(target)

        //正则
      case typeRegExp:
        const reg = /\w*$/
        const result = new RegExp(target.source, reg.exec(target)[0])
          // lastIndex 表示每次匹配时的开始位置
        result.lastIndex = target.lastIndex
        return result

        //function
      case typeFunction:
        return target;

      default:
        return target;
    }
  }

  // 区分处理
  switch (targetType) {

    //数组
    case typeArray:
      cloneTarget = []
      map.set(target, cloneTarget)
      target.forEach((element, index) => {
        cloneTarget[index] = deepClone(element, map)
      })
      return cloneTarget

      //对象
    case typeObject:
      cloneTarget = {}
      map.set(target, cloneTarget);
      [...Object.keys(target),...Object.getOwnPropertySymbols(target)].forEach((item) => {
        cloneTarget[item] = deepClone(target[item], map)
      })
      return cloneTarget
      
      //set集合
    case typeSet:
      cloneTarget = new Set()
      map.set(target, cloneTarget)
      target.forEach(element => {
        cloneTarget.add(deepClone(element, map))
      })
      return cloneTarget

      //Map
    case typeMap:
      cloneTarget = new Map()
      map.set(target, cloneTarget)
      target.forEach((val, key) => {
        cloneTarget.set(key, deepClone(val, map))
      })
      return cloneTarget

    default:
      return target
  }
}


//测试用例
let testObj = {
  simple: {
    Date: new Date(),
    RegExp: /[\u4e00-\u9fa5]/gm,
    function: () => {
      console.log("我是一个function");
    }
  },
  base: {
    Number:111,
    String: "hello world",
    Boolean: true,
    Null: null,
    code: undefined
  },
  loop: {
    arr: [1,2,3,4],
  }
}

console.log(testObj)
console.log(deepClone(testObj))

测试结果:

image.png

最后编辑于：2020.06.28 23:34:54