set&map

Set

Set 能够保存一组不重复的值，可以保存任何值，一般可以用于去重

基本api

// 内部基本是使用类似===来做判断，也可以区分出NaN为相同值

let a = new Set([1,2])
a.add('1');  // 1 和 '1' 不相同   { 1 ，2， '1' }
a.add(NaN); // { 1 ，2， '1',  NaN }
a.add(NaN); // NaN 和 NaN相同  { 1 ，2， '1',  NaN }
a.add(1);  // { 1 ，2， '1',  NaN }
a.add(3); // { 1 ，2， '1',  NaN， 3 }
a.size;  // 5 
a.delete(2); // { 1， '1',  NaN,  3 }
a.has(2); // false
a.clear(); // {}

// new Set() 初始化可以传入一个有iterable接口的值。字符串或者数组

const a = new Map([['a',1],['b',2]])
const b = new Set(a);
console.log(b)   // { ['a', 1], ['b', 2] }

使用场景

可以用来非对象数组去重和字符串去重，或者求交集，差集，并集

// 数组去重
const a = [1,2,3,4,3,3,4,5]
console.log([...new Set(a)])  // [1,2,3,4,5]

// 字符串去重
const a = "123456452";
console.log([...new Set(a)].join("")) // "123456"

//  set也可以利用数组的map和filter方法来计算
let a = new Set([1, 2, 3]);
let c = new Set([...a].map(v => v*2)) 
console.log(c); // {2,4,6}

// 求交集，并集，差集
let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);

new Set([...a, ...b]); // 并集
new Set([...a].filter(v => b.has(v))); // 交集
new Set([...a].filter(v => !b.has(v))); // 差集

遍历

// values() keys() entries()都返回一个iterator对象，需要使用for of遍历

const a = new Set([1,2,3,4])
for (let v of a.values()) {
    console.log(v)
}
for (let k of a.keys()) {
    console.log(k)
}
for (let [v, k] of a.entries()) {
    console.log(v)
    console.log(k)
}

//  Set 结构的实例默认可遍历，它的默认遍历器生成函数就是它的values方法
Set.prototype[Symbol.iterator] === Set.prototype.values

for (let v of a) {
  console.log(v) // 和a.values()行为一致
}

// 可以使用foreach
const a = new Set([1,2,3,4])

a.forEach((v,i) => {
    console.log(v, i);     // 1 1, 2 2, 3 3, 4 4 
})

weakSet

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

Map

Map 能够保存一组键值对的数据，可以使用任何数据结构当做key。

基本api

const a = new Map([['a',1], ['b',2]])
a.set('c', 3); // {'a' => 1, 'b' => 2, 'c' => 3}
a.set('c', 4); // {'a' => 1, 'b' => 2, 'c' => 4}  覆盖
a.get('c'); // 4
a.size; // 3
a.delete('a'); // {'b' => 2, 'c' => 4}
a.clear(); // {}

// new Map() 初始化可以传入一个有iterable接口的值。并且必须是二维的。set、map或者数组。

const a = new Set([['a',1], ['b',2]])
const b = new Map(a);
console.log(b);

遍历

const map = new Map([
  ['F', 'no'],
  ['T',  'yes'],
]);

for (let key of map.keys()) {
  console.log(key);
}
// "F"
// "T"

for (let value of map.values()) {
  console.log(value);
}
// "no"
// "yes"

for (let item of map.entries()) {
  console.log(item[0], item[1]);
}
// "F" "no"
// "T" "yes"

// 或者
for (let [key, value] of map.entries()) {
  console.log(key, value);
}
// "F" "no"
// "T" "yes"

// 等同于使用map.entries() 因为  map[Symbol.iterator] === map.entries
for (let [key, value] of map) {
  console.log(key, value);
}
// "F" "no"
// "T" "yes"

set和map快速转换成数组的方法都是使用扩展运算符...