Set 和 Map 数据结构

Set

• ES6新增的一种新的数据结构，类似于数组，但是成员的值都是唯一的，没有重复的值

// Array.from 方法和拓展运算符可以将 Set 结构转为数组，可以利用set进行去重
// 数组去重
const set = new Set([1, 2, 3, 4, 4]);
Array.from(set) // [1, 2, 3, 4]
[...set] // [1, 2, 3, 4]

// 字符串去重
Array.from(new Set('aabbcc')).join('') // abc

• Set本身是一个构造函数，用来生成Set数据结构，可以接受一个数组（或者具有iterable接口的其他数据结构）作为参数，用来初始化
• 向Set加入值的时候，不会发生类型转换，所以5和"5"是两个不同的值。Set 内部判断两个值是否不同，使用的算法叫做“Same-value-zero equality”，它类似于精确相等运算符（===），主要的区别是向Set加入值时认为NaN等于自身，而精确相等运算符认为NaN不等于自身。

// NaN不会重复加入
let set = new Set();
let a = NaN;
let b = NaN;
let c = 5;
let d = "5";
let e = {};
let f = {};
set.add(a);
set.add(b);
set.add(c);
set.add(d);
set // Set(5) {NaN, 5, '5', {…}, {…}}
// 两个对象总是不相等的，所以两个空对象会被视作两个值

属性和方法：

• Set.prototype.constructor：构造函数，默认就是Set函数。
• Set.prototype.size：返回Set实例的成员总数。
• Set.prototype.add(value)：添加某个值，返回 Set 结构本身。
• Set.prototype.delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
• Set.prototype.has(value)：返回一个布尔值，表示该值是否为Set的成员。
• Set.prototype.clear()：清除所有成员，没有返回值

const s = new Set();
s.add(1).add(2).add(2);
// 注意2被加入了两次

s.size // 2

s.has(1) // true
s.has(2) // true
s.has(3) // false

s.delete(2);
s.has(2) // false

s.clear();
s // Set(0) {size: 0}

遍历操作：Set的遍历顺序就是插入顺序。

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

let set = new Set(['red', 'green', 'blue']);

for (let item of set.keys()) {
  console.log(item);
}
// red
// green
// blue

for (let item of set.values()) {
  console.log(item);
}
// red
// green
// blue

for (let item of set.entries()) {
  console.log(item);
}
// ["red", "red"]
// ["green", "green"]
// ["blue", "blue"]

由于 Set 结构没有键名，只有键值（或者说键名和键值是同一个值），所以keys方法和values方法的行为完全一致。entries方法返回的遍历器，同时包括键名和键值，所以每次输出一个数组，且两个成员完全相等

• forEach：与数组一样，对每个成员执行某种操作，没有返回值

let set = new Set([1, 2, 3]);
set.forEach((c,k) => console.log(k+':'+c))
// 1:1
// 2:2
// 3:3

应用：

// 两个数组并集并去重
let a = [1,2,3];
let b = [2,3,4];
let union = Array.from(new Set([...a, ...b]));
console.log(union) // [1, 2, 3, 4]

let a = [1,2,3];
let b = [2,3,4];
let common = [...a].filter(c => new Set(b).has(c)) // 选出共有元素
let aCommon = [...a].filter(c => !new Set(b).has(c)) // a中有b中没有的元素
let bCommon = [...b].filter(c => !new Set(a).has(c)) // b中有a中没有的元素
console.log(common) // [2, 3]
console.log(aCommon) // [1]
console.log(bCommon) // [4]

Map

• ES6新增的一种新的数据结构，它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是说，Object结构提供了字符串—值的对应，Map结构提供了值—值的对应，是一种更完善的Hash结构实现。如果你需要键值对的数据结构，Map比Object更合适。

const m = new Map();
const o = {p: 'Hello World'};

m.set(o, 'content') 
//  key: {p: 'Hello World'}
//  value: "content"
m.get(o) // "content"

m.has(o) // true
m.delete(o) // true
m.has(o) // false

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

const map = new Map([
  ['name', '111'],
  ['value', '222']
]);

其执行算法为：
const items = [
  ['name', '111'],
  ['value', '222']
];
const map = new Map();
items.forEach(
  ([key, value]) => map.set(key, value)
);

如果读取一个未知的key，返回undefined

new Map().get('abcdefg')
// undefined

如果Map的键是一个简单类型的值（数字、字符串、布尔值），则只要两个值严格相等，Map将其视为一个键，比如0和-0就是一个键，布尔值true和字符串true则是两个不同的键。另外，undefined和null也是两个不同的键。虽然NaN不严格相等于自身，但Map将其视为同一个键。如果键是复杂类型的值，只要内存地址不一样，就视为两个键

const map = new Map();

map.set({name: 111}, 111);
map.get({name: 111}) // undefined

map.set(-0, 123);
map.get(+0) // 123

map.set(true, 1);
map.set('true', 2);
map.get(true) // 1

map.set(undefined, 3);
map.set(null, 4);
map.get(undefined) // 3

map.set(NaN, 123);
map.get(NaN) // 123

属性和方法：

• size：属性返回Map结构的成员总数
• Map.prototype.set(key, value)：set方法设置键名key对应的键值为value，然后返回整个Map结构（因此可以使用链式写法）。如果key已经有值，则键值会被更新，否则就新生成该键
• Map.prototype.get(key)：读取key对应的值，如果找不到key，返回undefined
• Map.prototype.has(key)
• Map.prototype.delete(key)
• Map.prototype.clear()

遍历操作：Map的遍历顺序就是插入顺序

• Map.prototype.keys()：返回键名的遍历器。
• Map.prototype.values()：返回键值的遍历器。
• Map.prototype.entries()：返回所有成员的遍历器。
• Map.prototype.forEach()：遍历 Map 的所有成员。 结合数组的map方法、filter方法，可以实现 Map 的遍历和过滤（Map 本身没有map和filter方法），只有forEach方法

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'}