【面试题】面试官：请你实现一个深拷贝，那如果是正则/set/函数怎么拷贝？

let obj = {
    name : '123'
}
console.log(Object.getOwnPropertyDescriptor(obj,'name'))
/*
  输出内容
  configurable：true 能否通过delete删除此属性
  enumerable ： true  表示属性是可以枚举 即是否通过for in 或 Object.keys() 返回属性
  value: '123'
  writable: true 表示能否修改属性的值
*/
// 设置属性
Object.defineProperty(obj,'名字',{
    value:'不可枚举属性',
    enumerable:false
})

// 方法一：看颜色
console.log(obj)
/*
  输出：
  {
    name: "123" // 控制台里是深色字体
    名字: "不可枚举属性" // 控制台里是浅色字体
  }
*/
// 方法二：使用以下四个方法
/*
  四个操作会忽略enumerable为false
  for in 
  Object.keys()
  Object.assign()
  JSON.stringify()
*/
// 我们实测下
for(let prop in obj){
  console.log(prop)
}
/*
  输出:name
*/
console.log(Object.keys(obj))
/*
  输出: ['name']
*/
console.log(Object.assign({},obj))
/*
  输出: {name: '123'}
*/
console.log(JSON.stringify(obj))
/*
  输出: '{"name":"123"}'
*

let obj2 = {...obj1}
let arr2 = [...arr1] //跟arr.slice()一样的效果

let arr1 = [1,2,3]
let arr2 = arr1.concat()

let arr1 = [1,2,3]
let arr2 = arr1.slice()

var deepClone = target => {
    //判断是否是对象类型，不是对象类型的话，直接返回本身
  if ((typeof target === "object" || typeof target === 'function') && target !== null) {
      //判断目标是数组还是对象
    const cloneTarget = Array.isArray(target) ? [] : {};
    for (let prop in target) {
        //只拷贝自身属性，不拷贝继承属性，所以使用hasOwnProperty(),当属性是继承属性则返回false
      if (target.hasOwnProperty(prop)) {
        cloneTarget[prop] = target[prop];
      }
    }
    return cloneTarget;
  } else {
    return target;
  }
};

JSON.parse(JSON.stringify(target))

function deepCopy(target) {
  if((typeof target !== 'object' || typeof target !== 'function') && target === null) return false
    let res = Array.isArray(target) ? [] : {}
      for(let k in target) {
        // 如果目标数据上有属性（键）(key)
        if(target.hasOwnProperty(k)) {
          // 如果目标数据上属性的值，为object，就递归，不是object，就取到属性值，并放入我们新建的空数组/对象中
          res[k] = typeof target[k] === 'object' ? deepCopy(target[k]) : target[k]
        }
     }
  return res
}

// test用例1: null
var a = null // false
// test用例2: 不可枚举属性
var b = {name:'张三',like:['girl','cat']}
Object.defineProperty(b,'age',{
    value: '18不可枚举属性',
    enumerable: false
})
for(let prop in b){
  console.log(prop)
}
/*
'name'
'like'
*/
// test用例3: 非数组、对象的引用类型
var c = new Date()
var d = deepCopy(c) 
console.log(d)
/*
  {}
*/
// test用例4: 
  const e = {}
  e.e = e
  deepClone(e)
/*
  出现内存泄漏
*/
// test用例5: 对象、数组深层嵌套
var i = {rep:'apple',like:['women',{boy:{name:'王五',like:[69,'sex']}}]}
// 可以

const isObject = (target) => (typeof target === 'object' || typeof target === 'function') && typeof target !== null
function deepClone(target,map = new WeakMap()) {
  //当weakmap 中已经存在这个对象，直接返回即可，不用在进行拷贝
  if(map.get(target)) return target
  if(!isObject(target)) return target
  // 没有存在 就在weakmap中添加
  map.set(target,true)
  let res = Array.isArray(target) ? [] : {}
  for(let k in target) {
    if(target.hasOwnProperty(k)) {
      res[k] = typeof target[k] === 'object' ? deepClone(target[k],map) : target[k]
    }
  }
  return res
}

  function deepClone (val) {
      if (isSet(val)) {
        const set = new Set()
        val.forEach(item => {
          set.add(deepClone(item))
        })
      }
  }

  function deepClone (val) {
  const Ctor = val.constructor
  if (isDate(val)) {
    return new Ctor(+val)
  } else if (isRegExp(val)) {
    const reFlags = /\w*$/;
    // 此处不用flags的原因在于flags方法返回的修饰符是按照字母顺序排列的
    const reg = new Ctor(val.source, reFlags.exec(val))
    reg.lastIndex = val.lastIndex
    return reg
  }
}