06 ES6标准入门(Set 和 Map 数据结构)

Set

Set类似于数组，但成员都是唯一的。

Set本身是一个构造函数，用来生成Set数据结构

const set = new Set();
let arr = [1, 2, 2, 3, 4, 4, 5];
arr.forEach(x = > set.add(x));
console.log(set); // 1,2,3,4,5

Set函数可以接受一个函数作为参数，用来初始化

const set = new Set([1, 2, 2, 3, 4, 4, 5]); // Set(5) {1, 2, 3, 4, 5}
const set2 = new Set('test'); // Set(3) {"t", "e", "s"}

Set可以用扩展运算符取值

const set = new Set([1,2,2,3,4,4,5]);
console.log([...set]) // [1,2,3,4,5]

可以利用Set来进行数组成员去重

let arr = [1, 2, 2, 3, 4, 4, 5];
arr = [...new Set(arr)];
//  另一种
arr = Array.from(new Set(arr))

注意，想Set中增加数值的时候，不会发生类型转换，所以5和‘5’是不同的值，Set内部判断值是否相等方法与Object.is()规则相同

注意，两个对象（包括数组）总是不等的（因为指向不同的地址），所以被视为两个值

let a = new Set();
a.add({});
a.add({});
console.log(a.size) //2

Set的方法

add(value)：返回值是Set结构本身
has(value)
delete(value)：返回值是布尔值，表示删除是否成功
clear()：没有返回值

Array.from可以将Set转换为数组

keys()：返回键名
values()：返回键值
entires()：返回键值对
forEach()：使用回调函数遍历每个成员

要特别注意的有：
1. Set结构的键值和键名相同，所以keys和values方法行为结果一致
2. Set的遍历顺序就是插入顺序（用处是按添加顺序执行回调函数）
3. 可以直接使用for...of对Set实例进行遍历
4. forEach的第二个参数是处理函数内部的this对象
5. 可以使用扩展运算符...展开Set结构

对象的遍历顺序：
1. 首先遍历数值键，按数值升序排列
2. 然后遍历字符串键，按照加入时间升序排列
3. 最后遍历Symbol键，按照加入时间升序排列

可以使用利用Set结构实现并集、交集和差集

let a = new Set([1, 2, 3]),
b = new Set([2, 3, 4]);
// 并集
let union = new Set([...a, ...b]);
console.log(union); // set4 {1,2,3,4}
// 交集
let intersect = new Set([...a].filter((x) = > b.has(x)));
console.log(intersect); // set4 {2,3}
// 差集
let difference = new Set([...a].filter((x) = > !b.has(x)));
console.log(difference); // set1 {1}

想要在遍历过程中改变Set中的值，都需要将Set转换为数组，处理后再转换回去

let a = new Set([1, 2, 3]);
a = new Set([...a].map((x) = > x * 2)); //Set(3) {2, 4, 6}
// 另一种方法
a = new Set(Array.from(a, (x) = > x * 2))

WeakSet

（不清楚WeakSet的作用，不知道到底是干什么用的）

WeakSet与Set的区别在于：
1. WeakSet的成员只能是对象
2. WeakSet的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于 WeakSet 之中。

WeakSet 适合临时存放一组对象，以及存放跟对象绑定的信息。只要这些对象在外部消失，它在 WeakSet 里面的引用就会自动消失。

由于上面这个特点，WeakSet 的成员是不适合引用的，因为它会随时消失。

WeakSet 不可遍历。

WeakSet中的成员只能是对象，如果成员是数组，则是数组的成员是WeakSet的成员，所以数组的成员只能是对象

const a = [[1, 2], [3, 4]];
const ws = new WeakSet(a);
// WeakSet {[1, 2], [3, 4]}

const b = [3, 4];
const ws = new WeakSet(b);
// Uncaught TypeError: Invalid value used in weak set(…)

Map

Map数据结构的目的就是弥补传统的Object对象的键名只能是字符串的缺点，键名可以使各种类型的值。

也就是说，Object结构是“字符串-值”的对应，Map结构提供了“值-值”对应，是一种更完善的Hash结构实现。

构造函数Map可以接受一个数组作为参数，该数组的成员是一个个表示键值对的数组。

const map = new Map([
  ['name', '张三'],
  ['title', 'Author']
]);

map.size // 2
map.has('name') // true
map.get('name') // "张三"
map.has('title') // true
map.get('title') // "Author"

事实上，不仅仅是数组，任何具有 Iterator 接口、且每个成员都是一个双元素的数组的数据结构都可以当作Map构造函数的参数。这就是说，Set和Map都可以用来生成新的 Map。

对同一个键多次赋值，后面的值将覆盖前面的值

const map = new Map();

map
.set(1, 'aaa')
.set(1, 'bbb');

map.get(1) // "bbb"

注意，只有对同一个对象的引用，Map 结构才将其视为同一个键。这一点要非常小心。

const map = new Map();

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

同理，同样的值的两个实例，在 Map 结构中被视为两个键。

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 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键。

Map 实例的属性和方法

size 属性，返回 Map 实例的成员总数
set(key, value) 方法，设置键名 key 对应的键值为 value，返回整个 Map 结构，因此可以采用链式写法
JS let map = new Map() .set(1, 'a') .set(2, 'b') .set(3, 'c') .set(3, 'd') // Map(3) {1 => "a", 2 => "b", 3 => "d"}
get(key) 方法，读取 key 对应的键值，如果找不到返回 undefined
has(key) 方法，返回一个布尔值，表示某个键是否在当前 Map 对象之中。
delete(key) 方法，删除某个键，删除成功返回 true，否则返回 false
clear() 方法，清除所有成员，无返回值

Map 的遍历方法

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

需要特别注意的是，Map 的遍历顺序就是插入顺序。

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

`WeakMap`

WeakMap 与 Map 的区别有两点。首先，WeakMap 只接受对象作为键名（null 除外），不接受其他类型的值作为键名。

const map = new WeakMap();
map.set(1, 2)
// TypeError: 1 is not an object!
map.set(Symbol(), 2)
// TypeError: Invalid value used as weak map key
map.set(null, 2)
// TypeError: Invalid value used as weak map key

其次，WeakMap 的键名所指向的对象，不计入垃圾回收机制。

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

基本上，如果你要往对象上添加数据，又不想干扰垃圾回收机制，就可以使用 WeakMap。一个典型应用场景是，在网页的 DOM 元素上添加数据，就可以使用WeakMap结构。当该 DOM 元素被清除，其所对应的 WeakMap 记录就会自动被移除。

const wm = new WeakMap();

const element = document.getElementById('example');

wm.set(element, 'some information');
wm.get(element) // "some information"

上面代码中，先新建一个 Weakmap 实例。然后，将一个 DOM 节点作为键名存入该实例，并将一些附加信息作为键值，一起存放在 WeakMap 里面。这时，WeakMap 里面对 element 的引用就是弱引用，不会被计入垃圾回收机制。

也就是说，上面的 DOM 节点对象的引用计数是 1，而不是 2。这时，一旦消除对该节点的引用，它占用的内存就会被垃圾回收机制释放。Weakmap 保存的这个键值对，也会自动消失。

总之，WeakMap 的专用场合就是，它的键所对应的对象，可能会在将来消失。WeakMap 结构有助于防止内存泄漏。