ES6 —（Set 和 Map 数据结构）

1、Set

1.1、Set 基本用法

  ES6 提供了新的数据结构 Set ，它类似于数组，但是成员的值都是唯一的，没有重复的值。
  Set 本身是一个构造函数，用来生成 Set 构造函数。 Set 函数可以接受一个数组（或者具有 Iterable 接口的其他数据结构作为参数， 如类似数组的对象）。

var s1 = new Set();
var s2 = new Set([1, 2, 3]);

var arr = {
    '0': 0,
    '1': 1,
    length: 3
}
var s3 = new Set([...arr]); // 长度为 3， 2 的位置是 undefined

  可以使用 Set 实现数组去重。

function dedupe(array) {
    return Array.from(new Set(array)); 
}
//Array.from 方法可以将 Set 结构转为数组。
dedupe([1, 1, 2, 3]) // [1, 2, 3]

注意：
  （1）向 Set 加入值的时候，不会发生类型转换，所以 5 和 ‘5’ 是两个不同的值。
  （2）Set 内部判断两个值是否相同，使用的算法是 “Same-value equality”，它类似于精确相等运算符（===），主要的区别是 NaN 等于自身，而精确运算符认为 NaN 不等于自身。
  （3）两个对象总是不相等的。

1.2、Set 实例的属性和方法

  Set 结构的实例有以下属性。

• Set.prototype.constructor：构造函数，默认就是 Set 函数。
• Set.prototype.size：返回 Set 实例的成员总数。

  Set 实例的方法分为两大类：操作方法（用于操作数据）和遍历方法（用于遍历成员）。

• add(value)：添加某个值，返回 Set 结构本身。
• delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
• has(value)：返回一个布尔值，表示该值是否为 Set 的成员。
• clear()：清除所有成员，没有返回值。
• keys()；返回键名的遍历器。
• values()：返回键值的遍历器。
• entries()：返回键值对的遍历器。
• forEach()：返回回调函数遍历每个成员，参数是一个处理函数，该函数的参数依次是键值、键名、集合本身。此外，forEach 方法可以有第二个参数，表示绑定的 this 对象。

  由于 Set 结构没有键名，只有键值（或者说键名和键值是同一个值），所以 keys() 和 values() 方法的行为完全一致。

var s = new Set([1, 2, 3]);
console.log(s.size);  // 3
console.log(s.add(4)); // Set {1, 2, 3, 4}
console.log(s.has(2)); // true
console.log(s.keys()); // SetIterator {1, 2, 3, 4}
console.log(s.values()); // SetIterator {1, 2, 3, 4}
console.log(s.entries()); // SetIterator {[1, 1], [2, 2], [3, 3], [4, 4]}
s.forEach((value, key) => console.log(value * 2) ) // 2 4 6 8 

注意：Set 结构的实例默认可遍历，它的默认遍历器生成函数就是它的 values 方法，这意味着，可以省略 values 方法，直接用 for...of 遍历 Set。

Set.prototype[Symbol.iterator] === Set.prototype.values  // true

1.3、Set 应用

（1）扩展运算符（...）内部使用 for...of 循环，所以也可以用于 Set 结构。
（2）扩展运算符和 Set 结构组合，就可以去除数组的重复成员。
（3）数组的 map 和 filter 方法也可以用于 Set。
（4）使用 Set 可以很容易的实现并集、交集和差集。
（5）如果想在变量操作中，同步改变原来的 Set 结构方法：一是，利用原 Set 结构映射出一个新的结构，然后赋值给原来的 Set 结构；二是利用 Array.from 方法。

2、WeakSet

2.1、含义

  WeakSet 结构与 Set 结构类似，也是不重复的值的集合。但是，它与 Set 有两个区别，

• 一是，WeakSet 的成员只能是对象，而不是其他类型的值。
• 二是，WeakSet 中的对象都是弱引用，垃圾回收机制不考虑 WeakSet 对该对象的引用。即，如果其它对象都不在引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于 WeakSet 之中。

  这是因为垃圾回收机制依赖引用计数，如果一个值的引用次数不为 0，垃圾回收机制就不会释放这块内存。结束使用该值后，有时会忘记取消引用，导致内存无法释放，进而可能引发内存泄漏。WeakSet 里面的引用，都不计入垃圾回收机制，所以就不存在这个问题。因此，WeakSet 适合临时存放一组对象，以及存放跟对象绑定的信息。只要这些对象在外部消失，它在 WeakSet 里面的引用就会自动消失。

注意：
  （1）WeakSet 的成员不适合引用，因为它会随时消失。
  （2）WeakSet 内部有多少个成员，取决于垃圾回收机制有没有运行，运行前后很可能成员个数是不一致的，而垃圾回收机制何时运行时不可预测的，因此 ES6 规定 WeakSet 不可遍历。
  （3）ES6 规定 WeakSet 不可遍历。

2.2、语法

  WeakSet 是一个构造函数，可以使用 new 命令，创建 WeakSet 数据结构。构造函数的可以接受一个数组或者类似数组的对象作为参数。（实际上，任何具有 Iterable 接口的对象，都可以作为 WeakSet 的参数）该数组的所有成员，都会自动成为 WeakSet 实例对象的成员。

注意：是数组的成员成为 WeakSet 的成员，而不是数组本身，这意味着，数组的成员只能是对象。

var a = [[1, 2], [3]];
var wa = new WeakSet(a);
console.log(wa);  // WeakSet {[3], [1, 2]} 或 WeakSet {[1, 2], [3]} 顺序不定

var b = [1, 2, 3];
var wb = new WeakSet(b); // 报错，因为 b 的成员不是对象

WeakSet 结构有以下三个方法：

• WeakSet.prototype.add(value)：向 WeakSet 实例添加一个新成员。
• WeakSet.prototype.delete(value)：清除 WeakSet 实例的指定成员。
• WeakSet.prototype.has(value)：返回一个布尔值，表示某个值是否在 WeakSet 实例之中。

应用：WeakSet 的一个用处是存储 DOM 节点，而不用担心这些节点从文档移除时，会引发内存泄漏。

3、Map

3.1、含义和基本用法

  JavaScript 的对象，本质上是键值对的集合（Hash 结构），但是传统上只能用字符串当作键，为解决这个问题，ES6 提供了 Map 数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是，Object 结构提供了“字符串-值”的对应，Map 提供了“值-值的对应，是一种更完善的 Hash 结构的实现。
  Map 是一个构造函数，使用 new 命令创建一个 Map对象。该构造函数也可以接受一个数组作为参数。该数组的成员是一个个表示键值对的数组。事实上，不仅仅是数组，任何具有 Iterator 接口、且每个成员都是一个双元素的数组的结果都可以当作 Map 构造函数的参数。也就是说，Set 和 Map 都可以用来生成新的 Map。

var m1 = new Map();
var m2 = new Map([
            ['name','张三'],
            ['title','Author']  ]);
var set = new Set([ ['foo',1], ['bar',2] ]);
var m3 = new Map(set);
var m4 = new Map(m2);
console.log(m1); // Map {}
console.log(m2); // Map {"name" => "张三", "title" => "Author"}
console.log(m3); // Map {"foo" => 1, "bar" => 2}
console.log(m4); // Map {"name" => "张三", "title" => "Author"}
console.log(m2 === m4); // false 

3.2、实例的属性和操作方法

（1）size 属性
  size 属性返回 Map 结构的成员总数。

console.log(m1.size); // 0
console.log(m2.size); // 2

（2）set(key, value)
  set 方法设置键名 key 对应的键值为 value ，然后返回整个 Map 结构。如果 key 已经有值，则键值会被覆盖，否则生成新的键值对。set 返回的是当前 Map 对象，因此可以采用链式写法。

var m5 = m4.set('name','李四');
console.log(m4);  // Map {"name" => "李四", "title" => "Author"}
console.log(m5);  // Map {"name" => "李四", "title" => "Author"}
console.log(m2);  // Map {"name" => "张三", "title" => "Author"}
console.log(m4 === m5); // true
m4.set('name','四');
console.log(m4); // Map {"name" => "四", "title" => "Author"}
console.log(m5); // Map {"name" => "四", "title" => "Author"}

注意：
  1）如果对同一个键多次赋值，后面的值将覆盖前面的值。
  2）Map 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键。所以要注意引用类型的值。

m3.set(['baz'], 3); // 这两个 ['baz'] 表面是针对同一个值
m3.set(['baz'], 4); // 但实际上这是两个值，内存地址不一样
console.log(m3); // Map {"foo" => 1, "bar" => 2, ["baz"] => 3, ["baz"] => 4}

  3）如果 Map 的键是一个简单类型的值（数字、布尔值、字符串），则只要两个值严格相等，Map 将其视为一个键，其中，Map 将 NaN 视为同一个键。
（3）get(key)
  get 方法读取 key 对应的键值，如果找不到 key ，返回 undefined。

console.log(m3.get('too'));     // undefined
console.log(m3.get('bar'));     // 2
console.log(m3.get(['baz']));  // undefined 内存地址不一样无法读取上面的键。

（4）has(key)
  has 方法返回一个布尔值，表示某个键是否在当前 Map 对象之中。

console.log(m3.has('foo')); // true
console.log(m3.has('too')); // false
console.log(m3.has(['baz'])); // false

（5）delete(key)
  delete 方法删除某个键，返回 true。如果删除失败，返回 false。

console.log(m3.delete('foo')); // true
console.log(m3.delete('too')); // false
console.log(m3.delete(['baz'])); // false
console.log(m3); // Map {"bar" => 2, ["baz"] => 3, ["baz"] => 4}

（6）clear()
  clear 方法是清除所有成员没有返回值。

3.3、遍历方法

Map 结构原生提供三个遍历器生成函数和一个遍历方法。

• keys()：返回健名的遍历器
• values()：返回键值的遍历器
• entries()：返回所有成员的遍历器
• forEach()：遍历 Map 的所有成员

注意：
  1）Map 的遍历顺序就是插入顺序。
  2）Map 结构的默认遍历器接口（Symbol.iterator）是 entries 方法。

3.4、Map 与其他数据结构的互相转换

（1）Map 转为 数组，使用扩展运算符（...）。
（2）数组 转为 Map，将数组传入 Map 构造函数，就可转为 Map。
（3）Map 转为 对象，若所有 Map 的键都是字符串，就可转为对象。

function strMapToObj(strMap){
    let obj = Object.creat(null);
    for(let [k, v] of strMap){
        obj[k] = v;
    }
    return obj;
}

（4）对象 转为 Map。

function objToStrMap(obj){
    let strMap = new Map();
    for(let k of Object.keys(obj)){
        strMap.set(k, obj[k]);
    }
    return strMap;
}

（5）Map 转为 JSON，如果 Map 的键名都是字符串，这时可以选择转为对象 JSON；如果 Map 的键名有非字符串，这时可以选择转为数组 JSON。

function strMapToJson(strMap){
    return JSON.stringify(strMapToObj(strMap));
} // Map 的键名都是字符串
function mapToArrayJson(map){
    return JSON.stringify([...map]);
}

（6）JSON 转为 Map，将 JSON 数据转为对象 再转为 Map。

function jsonToStrMap(jsonStr){
    return objToStrMap(JSON.parse(jsonStr));
} // 如果键名都是字符串
function jsonToMap(jsonStr){
    return new Map(JSON.parse(jsonStr));
} // 如果整个 JSON 就是一个数组，且每个数组成员本身，又是一个有两个成员的数组。

4、WeakMap

4.1、含义

  WeakMap 结构与 Map 结构类似，也是用于生成键值对的集合。但是其与 Map 有两点区别：

• WeakMap 只接受对象作为键名（null 除外），不接受其他类型的值作为键名。
• WeakMap 的键名所指向的对象，不计入垃圾回收机制。即它的键名所引用的对象是弱引用。

注意：WeakMap 弱引用的只是键名，而不是键值。键值依然是正常引用。

4.2、WeakMap 的语法

  WeakMap 与 Map 在 API 上的区别主要是两个：

• WeakMap 没有遍历操作，即没有 key、values、entries 方法。因为没有办法列出所有键名，某个键名是否存在完全不可预测，跟垃圾回收机制是否运行相关。
• WeakMap 无法清空，即不支持 clear 方法。

因此，WeakMap 只有四个方法可用：get、set、has、delete。

阮一峰：ECMAScript 6入门