手撕深拷贝引发的思考

一、以下是一份完整的深拷贝的代码：

const isComplexType = function(obj) { // 判断这个数据类型是不是对象，并且不是null
    return (typeof obj === 'object' || typeof obj === 'function') && obj !== null;
}
function deepClone(obj, hash = new WeakMap()) {
    const type = [ Date, RegExp, Set, Map, WeakMap, WeakSet ]; // 需要特殊处理的数据类型
  if (type.includes(obj.contructor)) {
      return new obj.constructor(obj);
  }
  if (hash.has(obj)) { // 处理循环引用
      return hash.get(obj);
  }
  // 获取传入参数所有键的特性
  const allDesc = Object.getOwnPropertyDescriptors(obj);
  // 根据原型对象创拷贝内容，继承了原型属性和属性的描述
  const cloneObj = Object.create(Object.getPrototypeOf(obj), allDesc);
  hash.set(obj, cloneObj);
  //  Relect.ownkeys() 可以枚举不可以枚举的类型和符号
  for (let key of Relect.ownkeys(obj)) {
      cloneObj[key] = (isComplexType(obj[key]) && typeof obj[key] !== 'function') ? deepClone(obj[key], hash) : obj[key];
  }
  return cloneObj
}

问题如下：

• Object.getPrototypeOf的用途
• Object.cteate的用途
• Object.getOwnPropertyDescriptors的用途
• Map和WeakMap的区别
• Reflect.ownkeys()用途以及和for in的区别，Reflect和proxy相关内容了解
• Symbol是什么东西
• 什么是元编程

  以上问题我们来一一解答。

  二、Object.getPrototypeOf的用途

  用法：Object.getPrototypeOf(obj);

  返回指定对象的原型，可以理解为返回对象的隐式原型，和它的构造函数的显式原型相等。

  obj：要返回其原型的对象。

  返回值：给定对象的原型。如果没有继承属性，则返回null。

  既然提到了原型，那就以下方神图镇一下

  

  补充：Object.setPrototypeOf(obj, prototype)，该方法表示obj对象要设置其原型对象。prototype是该对象的新原型。它的返回值是指定的对象。

  三、Object.create的用途

  用法：Object.create(proto, [propertiesObject])，第一个参数为新创建对象的原型对象和属性，第二个参数为一个对象，该传入对象的自有属性将为新对象添加指定的属性值和对应的属性描述。

  可以通过Object.create的方式来实现继承，代码如下：

  // 寄生组合继承的方式和组合继承的区别在于，在子类调用父类，但是不需要子类的原型再一次调用父类的构造函数
  function Parent(value) { // 父类
    this.value = value;
  }
  Parent.prototype.getValue = function() {
    return this.value;
  }
  function Child(value) { // 子类
  Parent.call(this, value);
  }
  Child.prototype = Object.create(Parent.prototype, {
    constructor: {
      value: Child,
    enumerable: false,
    writable: false,
    configurable: false
  }
  })

  四、Object.getOwnPropertyDescriptors的用途

  用法：Object.getOwenPropertyDescriptors(obj)，该方法用来获取一个对象的所有自身属性的描述符，返回值为所指定对象的所有自身属性的描述符，如果没有任何自身属性，就返回空对象。

  可以通过Object.getOwnPropertyDescriptors和Object.create的方式来创建进行浅拷贝一个对象，如果用object.assign方法只能拷贝源对象的可枚举的自身属性，同时拷贝时无法拷贝属性的特性，服务拷贝纸原型，而且访问属性被转成数据属性。

  以下是基本应用

  var a  = {
  b: 1,
  get c() {
    return 2
  }
  }
  var k = Object.getOwnPropertyDescriptors(a);
  /**
  输出结果：就是返回对象内部属性的描述
  k = {
    b: {
    configurable: true
    enumerable: true
    value: 1
    writable: true
  },
  c: {
    configurable: true
    enumerable: true
    get: ƒ c()
    set: undefined
  }
  }
  */
  // 可以通过一下形式进行拷贝对象，可以得到一个原型相同，并且属性具有描述的对象
  Object.create(Object.getPrototypeOf(a), Object.getOwnPropertyDescriptors(a));

  五、Map和WeakMap的区别

  首先说一下map和object的区别，object对象的key值只能是string或者symbol类型，map对象的key值可以是任意类型（可以是基础类型，也可以是引用类型）。map和weakMap的区别是，weakMap的key值只能是引用类型数据，并且weakMap的key的引用还是一个弱引用，可以被垃圾回收机制回收。

  六、Reflect.ownkeys以及周边Reflect相关内容

  Reflect.ownkeys()，返回一个包含自身所有属性的数组（不包含继承属性）， 不管属性名是symbol还是string都可以进行获取，也不受enumable的影响。它和for in的区别在于，for in不可以遍历symbol的属性名，Reflect.ownkeys无论属性名是什么数据类型都可以进行获取。

  Reflect的相关内容：

  Reflect是一个内置的对象，他提供拦截javascript操作方法。Reflect不是一个函数对象，因此它是不可构造的。

  Reflect与大多数全局对象不同，Reflect并非一个构造函数，所以它不能通过new运算符对其进行调用，或者将Reflect对象作为一个函数来调用。Reflect的所有属性和方法都是静态的。

Reflect的静态方法：

1、Reflect.apply(target, thisArgument, argumentList)，对一个函数进行调用，同时可以传入一个数组作为调用参数。和Function.prototype.apply()功能类似。

2、Reflect.construct(target, argument[, newTarget])，对构造函数进行new操作，相当于执行了

new target(…args)。

3、Reflect.defineProperty(target, properkey, attribute)和Object.defineProperty类似。如果设置成功就会返回true。

4、Reflect.deleteProperty(target, properkey)，作为函数的delete操作符，相当于执行了

delete target[name]。

5、Reflect.get(target, properkey[, receiver])，获取对象身上某个属性的值，类似于target[name]。

6、Reflect.getOwnPropertyDescriptor(target, properkey)，类似于Object.getOwnPropertyDescriptor()，如果对象中存在该属性，则返回对应属性描述符，否则返回undefined。

7、Reflect.getPrototypeOf(target)，类似于Object.getPrototypeOf，返回对象的原型对象。

8、Reflect.has(target, properkey)，判断一个对象是否存在某个属性，和in运算符功能相同。

9、Reflect.ownKeys(target)，返回一个包含所有自身属性（ 不包含继承属性）的数组。

10、Reflect.set(target, properkey, value[, receviver])，将值分配给属性的函数，返回一个boolean，如果成功返回true。

七、Symbol与元编程

1、基本概念

在ES6之前的javascript的数据类型有undefined、null、string、number、boolean、object，现在symbol最为第七种基本数据类型。表示独一无二唯一的，最多的用法就是用来定义对象的唯一属性名。

2、Symbol的基本用法

Symbol函数不能用new命令，因为Symbol是原始数据类型，不是对象。可以接受一个字符串作为参数，为新创建的Symbol提供描述。

let sy = Symbol('one');
console.log(sy); // Symbol(one)
typeof(sy); // Symbol
// 相同参数Symbol()返回值是不相同的
let sy1 = Symbol('one');
console.log(sy === sy1); // false

3、Symbol.for

symbol.for类似于单例模式，首先会在全局搜索被登记的Symbol中是否有该字符串参数作为名称的Symbol值，如果有即返回该Symbol的值，若没有则新建并返回一个以该字符串为名称的Symbol值，并登记在全局环境中以供搜索。（注意：Symbol.for只能查询使用Symbol.for全局登记的Symbol，不能使用Symbol登记的）。

let yellow = Symbol('yello');
let yellow1 = Symbol.for('yello');
console.log(yellow === yellow1); // false
let yellow2 = Symbol.for('yellow');
console.log(yellow1 === yellow2); // true

4、Symbol.keyFor

Symbol.keyFor返回一个已经登记的Symbol类型的key值，用来检测该字符串作为参数名称的Symbol是否进行过登记。（注意：这个注册的Symbol需要通过Symbol.for的方式进行注册）

let yellow1 = Symbol.for('yellow');
Symbol.keyFor(yellow1); // yellow

5、Symbol的应用场景

场景一：使用Symbol值作为对象的属性名

let obj = {
    num: 123,
  text: 'abc'
}
console.log(obj['num']); // 123
console.log(obj['text']); // abc
const osNum = Symbol('num');
const osText = Symbol('text');
let objS = {
    [osNum]: 123,
  [osText]: 'abc'
}
console.log(objS[osNum]); // 123
console.log(objS[osText]); // abc

看似简单的应用场景，其实这里隐藏了好几个值得注意的问题，使用Symbol值作为对象的属性名不能被for in和for of正常枚举，不能使用Object.keys、Object.getOwnPropertyNames正常获取属性名，但是Object.getOwnPropertyDescriptor获取对象属性描述中enumerable的值为true，也就是说从对象的描述符所表示的来看Symbol值作为对象属性名是可以被枚举的，但是需要一个特定的枚举方式来实现：Object.getOwnPropertySymbols和Reflect.ownkeys的方式来进行获取。

for (var key in objS) {
    console.log(key); // 无输出
}
Object.keys(obj); // ['num', 'text']
Object.keys(objS); // []
Object.getOwnPropertyNames(obj); // ['num', 'text']
Object.getOwnPropertyNames(objS); // []
Object.getOwnPropertyDescriptor(objS, osNum); // [ value: 123, writable: true, emunerabel: true, configurable: true]
Object.getOwnPropertyDescriptors(objS); // [Symbol(num), Symbol(text)]

由枚举的区别可以看出普通枚举方法不能枚举Symbol值作为名称的属性，这也就是说可以通过这样的特性来定义’对内操作的属性’，可以快捷的区分对内操作和对外操作。

6、Symbol元编程

元编程可以简单理解为针对程序本身编程，用来操作目标程序本身的行为特性的编程方式。

7、Symbol元编程的自身静态方法

（1）、Symbol.hasInstance：来实现instanceof关键字底层计算逻辑。

var a = {
  [Symbol.hasInstance]: function (data) {
    return data instanceof Array
  }
}
console.log([1, 2, 3] instanceof a) // true
// 该方式会给a这个对象内部加入一个[Symbol.hasInstance]方法，当调用instanceof方法时，会先走这个[Symbol.hasInstance]方法，起到拦截作用，也可以理解AOP变成模式的一种。

备注：Symbol.hasInstance只适合Object类型，不能自定义Function类型上的Instance指令。

（2）、Symbol.isConcatSpreadable：该属性返回一个boolean值，表示对象使用Array.prototype.concat时是否可以展开

var arr1 = ['c', 'd']
console.log(['a', 'b'].concat(arr1, 'e')); // ["a", "b", "c", "d", "e"]
console.log(arr1[Symbol.isConcatSpreadable]); // undefined
arr1[Symbol.isConcatSpreadable] = false;
console.log(['a', 'b'].concat(arr1, 'e')); // ["a", "b", Array(2), "e"]
arr1[Symbol.isConcatSpreadable] = true;
console.log(['a', 'b'].concat(arr1, 'e')); // ["a", "b", "c", "d", "e"]
console.log(arr1[Symbol.isConcatSpreadable]);
arr1[Symbol.isConcatSpreadable] = undefined;
console.log(['a', 'b'].concat(arr1, 'e')); // ["a", "b", "c", "d", "e"]

当给数组的[Symbol.isConcatSperadable]的值设置为false的时候，当调用concat方法的是，此数组是不能被展开的，当[Symbol.isConcatSperadable]的值设置为true或者undefined时，调用concat方法是可以展开的。

（3）、Symbol.iterator：迭代器，在Array，set，Map，NodeList对象的原型上都有这个迭代器函数，具备迭代器特性的对象可以被for of等迭代方法作用。

var obj = {
    0: 'a',
  1: 'b',
  2: 'c',
  length: 3,
  [Symbol.iterator]: function() {
      let currentIndex = 0;
    let next = () => {
        return {
          value: this[currentIndex],
        done: this.length === currentIndex++
      }
    }
    return {
        next
    }
  }
}
for (let p of obj) {
    console.log(p) // a, b, c
}

（4）、Symbol.toPrimitive：该方法是对象被转换为原始数据类型时触发。这个参数根据执行的原始值转换类型分别是string、number和boolean

var a = {
    [Symbol.toPrimitive](hint) {
      if (hint === 'string') {
        return 'hello';
    }
    if (hint === 'number') {
        return 10;  
    }
    return true;
  }
}
console.log(+a); // 10
console.log(`${a}`); // hello
console.log(a == 1); true

以上总结了四种元编程的能力，还有七种，后续会进行补充。