ES6的Set和Map

Set

字符串去重

var str = "1232132";
[...new Set(str)].join('');

数组去重

var arr = [1,2,3,4,1,2,3];
// 下面两个都可将 Set 结构转为数组。
[...new Set(arr)];
//扩展运算符（...）内部使用for...of循环，所以也可以用于 Set 结构。
Array.from(new Set(arr));

Set 内部判断相等是根据一种算法叫做“Same-value-zero equality”，
与===相似，不同的是判断NaN时前者认为相等.两个对象总是不相等的。

console.log(NaN === NaN,{} === {}); //false,false 
console.log(new Set([NaN,NaN,{},{}]).add(1));//NaN,{},{},1  

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

四个操作方法。

add(value)：添加某个值，返回 Set 结构本身。
delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
has(value)：返回一个布尔值，表示该值是否为Set的成员。
clear()：清除所有成员，没有返回值。

四个遍历方法，可以用于遍历成员。

由于 Set 结构没有键名，只有键值（或者说键名和键值是同一个值）。所以keys()和values()结果一样。
keys()：返回键名的遍历器
values()：返回键值的遍历器
entries()：返回键值对的遍历器
forEach()：使用回调函数遍历每个成员

Set 结构的实例默认可遍历，它的默认遍历器生成函数就是它的values方法。

Set.prototype[Symbol.iterator] === Set.prototype.values
// true
这样就可以直接用set，不用set.values();
let set = new Set(['red', 'green', 'blue']);
for (let x of set) {
  console.log(x);
}
// red
// green
// blue

Set实现并交差

let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);
//并交差
let union = new Set([...a,...b]); //并集
let intersect = new Set([...a].filter(e => b.has(e))); //交集
let diff = new Set([...a].filter(x => !b.has(x)));  //差集
//改变set结构的两种方式
console.log(
[...intersect].map(x => x*2),

WeakSet

WeakSet只能接受对象作为参数！！
(任何具有Iterable的对象，如数组或者类数组,注意，数组的成员也要是对象,因为是成员要变成WeakSet的成员)！
WeakSet适用于临时存放一组对象，以及跟对象绑定的信息。如果使用值之后，没有取消引用，就会导致内存无法释放，进而引发内存泄漏。
因为weakSet中的对象都是弱引用，也就是垃圾回收机制不会考虑WeakSet中的引用。
这是因为垃圾回收机制依赖引用计数，如果一个值的引用次数不为0，垃圾回收机制就不会释放这块内存。
由于上面这个特点，WeakSet 的成员是不适合引用的，因为它会随时消失。

Map

const map = new Map();

map.set(['a'], 555);
map.get(['a']) // undefined

上面代码的set和get方法，表面是针对同一个键，但实际上这是两个值，['a']是数组对象在栈中存的地址指针。而上面两个['a']的内存地址是不一样的，因此get方法无法读取该键，返回undefined。同理，

const map = new Map();
const k1 = ['a'];
const k2 = ['a'];
map.set(k1, 111).set(k2, 222);
map.get(k1) // 111
map.get(k2) // 222

Map 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键。这就解决了同名属性碰撞（clash）的问题，我们扩展别人的库的时候，如果使用对象作为键名，就不用担心自己的属性与原作者的属性同名。
如果 Map 的键是一个简单类型的值（数字、字符串、布尔值），则只要两个值严格相等，Map 将其视为一个键。虽然NaN不严格相等于自身，但 Map 将其视为同一个键。

Map 结构的实例有以下属性和操作方法。

size 返回 Map 结构的成员总数。
set(key, value) 设置键名key对应的键值为value，返回的是当前的Map对象，所以可以采用链式写法。
get(key) 读取key对应的键值，如果找不到key，返回undefined。
has(key) has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中
delete(key) 删除某个键，返回true。如果删除失败，返回false。
clear() 清除所有成员，没有返回值。

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

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

Map 结构的默认遍历器接口（Symbol.iterator属性），是entries方法。所以下面两个效果一样：

for (let [key, value] of map.entries()) {
  console.log(key, value);
}
// 等同于使用map.entries()
for (let [key, value] of map) {
  console.log(key, value);
}
//结果都是
// "F" "no"
// "T" "yes"

map变数组

Map 结构转为数组结构，比较快速的方法是使用扩展运算符（…）。

const map = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
]);

[...map.keys()]  // [1, 2, 3]
[...map.values()]  // ['one', 'two', 'three']
[...map.entries()]  // [[1,'one'], [2, 'two'], [3, 'three']]
[...map]  // [[1,'one'], [2, 'two'], [3, 'three']]

结合数组的map方法、filter方法，可以实现 Map 的遍历和过滤（Map 本身没有map和filter方法）。

const map0 = new Map()
  .set(1, 'a')
  .set(2, 'b')
  .set(3, 'c');

const map1 = new Map(
  [...map0].filter(([k, v]) => k < 3)
);
// 产生 Map 结构 {1 => 'a', 2 => 'b'}

const map2 = new Map(
  [...map0].map(([k, v]) => [k * 2, '_' + v])
    );
// 产生 Map 结构 {2 => '_a', 4 => '_b', 6 => '_c'}

WeakMap

WeakMap与Map的区别有两点。

1. WeakMap只接受对象作为键名（但null除外,null是object类型），不接受其他类型的值作为键名。
   （与WeakSet类似）基本上，如果你要往对象上添加数据，又不想干扰垃圾回收机制，就可以使用 WeakMap。只要所引用的对象的其他引用都被清除，垃圾回收机制就会释放该对象所占用的内存
   一个典型应用场景是，在网页的 DOM 元素上添加数据，就可以使用WeakMap结构。当该 DOM 元素被清除，其所对应的WeakMap记录就会自动被移除。
2. 其次，WeakMap的键名所指向的对象，不计入垃圾回收机制。
   注意，WeakMap 弱引用的只是键名，而不是键值。键值依然是正常引用。

const wm = new WeakMap();
let key = {};
let obj = {foo: 1};

wm.set(key, obj);
obj = null;
wm.get(key)
// Object {foo: 1}

上面代码中，键值obj是正常引用。所以，即使在 WeakMap 外部消除了obj的引用，WeakMap 内部的引用依然存在。

WeakMap 与 Map 在 API 上的区别主要是两个，
一是没有遍历操作（即没有keys()、values()和entries()方法），也没有size属性。
因为没有办法列出所有键名，某个键名是否存在完全不可预测，跟垃圾回收机制是否运行相关。这一刻可以取到键名，下一刻垃圾回收机制突然运行了，这个键名就没了，为了防止出现不确定性，就统一规定不能取到键名。
二是无法清空，即不支持clear方法。
因此，WeakMap只有四个方法可用：get()、set()、has()、delete()。