es6标准入门教程学习（四）

11.Symbol

1. Symbol.prototype.description: 直接返回Symbol的描述zuoweisjh
2. 作为属性名的Symbol   
3. 消除魔术字符串 ：把常出现字符串用变量代替
4. 属性名遍历：Object.getOwnPropertySymbols()

5. Symbol.for()	字符串为参数，有这个就返回这个Symbol值，没有 新建 是为Symbol值登记的名字，是全局环境的
   Symbol.keyFor()	返回一个已登记的Symbol的key

   Symbol.for("bar") === Symbol.for("bar")
   // true
   Symbol("bar") === Symbol("bar")
   // false
   
   Symbol.for("bar") === Symbol.for("bar")
   // true
   Symbol("bar") === Symbol("bar")
   // false 未登记

6.再看看（1/n）

Symbol.hasInstance()	在instanceof 运算时自动调用
Symbol.isConcatSpreadable()	属性等于一个布尔值，表示对象用于Array.prototype.concat()时，是否可以展开 诡异
Symbol.species()	指向一个构造函数，
Symbol.match()	指向一个函数，调用方法返回值
Symbol.replace()	指向一个方法，方法返回值
Symbol.search()	方法，返回值
Symbol.split()	方法，返回值
Symbol.iterator()	该对象默认遍历器方法
Symbol.toPrimitive()	指向一个方法。该对象被转为原始类型的值时，会调用这个方法，返回该对象对应的原始类型值。
Symbol.toStringTag()	指向一个方法。在该对象上面调用Object.prototype.toString方法时，如果这个属性存在，它的返回值会出现在toString方法返回的字符串之中，表示对象的类型。也就是说，这个属性可以用来定制[object Object]或[object Array]中object后面的那个字符串。
Symbol.unscopables()	指向一个对象。该对象指定了使用关键字with时，哪些属性会被with环境排除。

class MyClass {
  [Symbol.hasInstance](foo) {
    return foo instanceof Array;
  }
}
[1, 2, 3] instanceof new MyClass() // true

class A1 extends Array {
  constructor(args) {
    super(args);
    this[Symbol.isConcatSpreadable] = true;
  }
}
class A2 extends Array {
  constructor(args) {
    super(args);
  }
  get [Symbol.isConcatSpreadable] () {
    return false;
  }
}
let a1 = new A1();
a1[0] = 3;
a1[1] = 4;
let a2 = new A2();
a2[0] = 5;
a2[1] = 6;
[1, 2].concat(a1).concat(a2)
// [1, 2, 3, 4, [5, 6]]

12.Set Map

1.Set 构造函数，用来生成Set数据结构 +add（）

Set函数接受一个数组(类数组)作为参数初始化 const a = new Set（[1,1,1,2,3]）

[...new Set('ababbc')].join('')
// "abc"

Set.prototypr.constructor	构造函数
Set.prototype.size	size，成员总数
Set.prototype.add(value)	add
Set.prototype.delete(value)	delete
Set.prototype.has(value)	has?
Set.prototype.clear()	clear

• Set.prototype.keys()：返回键名的遍历器
• Set.prototype.values()：返回键值的遍历器
• Set.prototype.entries()：返回键值对的遍历器
• Set.prototype.forEach()：使用回调函数遍历每个成员

let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);
// 并集
let union = new Set([...a, ...b]);
// Set {1, 2, 3, 4}
// 交集
let intersect = new Set([...a].filter(x => b.has(x)));
// set {2, 3}
// （a 相对于 b 的）差集
let difference = new Set([...a].filter(x => !b.has(x)));
// Set {1}

2.WeakSet：成员只能是对象

WeakSet中的对象都是弱引用，垃圾回收机制不考虑WeakSet对对象的引用。

不能遍历

3.Map

map：键值对的集合

map的键是和地址绑定的

size set get has delete clear 

Map.prototypr.constructor	构造函数
Map.prototype.size	size，成员总数
Map.prototype.add(value)	add
Map.prototype.delete(value)	delete
Map.prototype.has(value)	has?
Map.prototype.clear()	clear

• Map.prototype.keys()：返回键名的遍历器
• Map.prototype.values()：返回键值的遍历器
• Map.prototype.entries()：返回键值对的遍历器
• Map.prototype.forEach()：使用回调函数遍历每个成员

map互相转换

• map转数组 

  const myMap = new Map()
    .set(true, 7)
    .set({foo: 3}, ['abc']);
  [...myMap]
  // [ [ true, 7 ], [ { foo: 3 }, [ 'abc' ] ] ]

• 数组转map

  new Map([
    [true, 7],
    [{foo: 3}, ['abc']]
  ])
  // Map {
  //   true => 7,
  //   Object {foo: 3} => ['abc']
  // }

• Map转对象

  function strMapToObj(strMap) {
    let obj = Object.create(null);
    for (let [k,v] of strMap) {
      obj[k] = v;
    }
    return obj;
  }
  const myMap = new Map()
    .set('yes', true)
    .set('no', false);
  strMapToObj(myMap)
  // { yes: true, no: false }

• 对象转Map

  let obj = {"a":1, "b":2};
  let map = new Map(Object.entries(obj));

• Map转json

  function strMapToJson(strMap) {
    return JSON.stringify(strMapToObj(strMap));
  }
  let myMap = new Map().set('yes', true).set('no', false);
  strMapToJson(myMap)
  // '{"yes":true,"no":false}'
  
  function mapToArrayJson(map) {
    return JSON.stringify([...map]);
  }
  let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
  mapToArrayJson(myMap)
  // '[[true,7],[{"foo":3},["abc"]]]'

• json转map

  function jsonToStrMap(jsonStr) {
    return objToStrMap(JSON.parse(jsonStr));
  }
  jsonToStrMap('{"yes": true, "no": false}')
  // Map {'yes' => true, 'no' => false}
  
  function jsonToMap(jsonStr) {
    return new Map(JSON.parse(jsonStr));
  }
  jsonToMap('[[true,7],[{"foo":3},["abc"]]]')
  // Map {true => 7, Object {foo: 3} => ['abc']}

  WeakMap

• WeakMAp只接受对象作为键名
• Weakxx的键名所引用的对象都是弱引用，即垃圾回收机制不将该引用考虑在内。因此，只要所引用的对象的其他引用都被清除，垃圾回收机制就会释放该对象所占用的内存。也就是说，一旦不再需要，WeakMap 里面的键名对象和所对应的键值对会自动消失，不用手动删除引用。
• 没有遍历
• 没有size