一. Set

1. 基本用法

类似于数组，但是成员的值都是唯一的，没有重复的值。
Set 本身是一个构造函数，用来生成 Set 数据结构。
Set 函数可以接受一个数组（或者具有 iterable 接口的其他数据结构）作为参数，用来初始化。

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

const items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
items.size // 5

数组去重的另外一种方法：

1	[...new Set(array)]

向 Set 加入值的时候，不会发生类型转换，所以2和”2”是两个不同的值。

Set 内部判断两个值是否不同，类似于精确相等运算符（===），主要的区别是NaN等于自身。

2. Set实例的属性和方法

1) 属性：
Set.prototype.constructor: 构造函数，默认是Set函数
Set.prototype.size: 返回Set实例的成员总数

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

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

var s = new Set();
s.add(1).add(2).add(2);

s.size;      // 2
s.has(1);    //true
s.has(2);    //true
s.has(3);    //false
s.delete(2); 
s.has(2);    //false

Array.from方法可以将 Set 结构转为数组:

1 2	const items = new Set([1, 2, 3, 4, 5]); const array = Array.from(items);

数组去重的另外一种方法：

1	Array.from(new Set(array));

B：遍历方法
keys() : 返回键名的遍历器
values() : 返回键值的遍历器
entries() : 返回键值对的遍历器
forEach() : 使用回调函数遍历每个成员

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

var s = new Set(["red","yellow", "green"]);

for( var item of s.keys() ){
	console.log(item);
}
// red  yellow green

for( var item of s.values() ){
	console.log(item);
}
// red  yellow green

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

Set 结构的实例与数组一样，也拥有forEach方法，用于对每个成员执行某种操作，没有返回值。

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

3. Set遍历的应用

扩展运算符（…）内部使用for…of循环，所以也可以用于 Set 结构。

1
2
3

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

1) 数组去重

1	[...new Set([1,1,3,4,5])]; // [1,3,4,5]

2) 数组的map和filter方法也可以间接用于 Set

var set = new Set([1,2,3]);
set = new Set([...set].map(x => x*2 ));
//{2,4,6}

let set = new Set([1, 2, 3, 4, 5]);
set = new Set([...set].filter(x => (x % 2) == 0));
//{2,4}

3) 实现并集、交集、差集

let a = new Set([1,2,3]);
let b = new Set([4,3,2]);

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

二. WeakSet

1. 含义

WeakSet 结构与 Set 类似，也是不重复的值的集合。
WeakSet 的成员只能是对象，而不能是其他类型的值。
WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于 WeakSet 之中。
WeakSet 的成员是不适合引用的，因为它会随时消失。
ES6 规定 WeakSet 不可遍历。

2. 语法

WeakSet 是一个构造函数，可以使用new命令：

1	const ws = new WeakSet();

WeakSet 可以接受一个数组或类似数组的对象作为参数,该数组的所有成员，都会自动成为 WeakSet 实例对象的成员。

1
2
3

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

3. WeakSet结构的方法

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

WeakSet 没有size属性，没有办法遍历它的成员

三. Map

1. 含义

类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是说，Object 结构提供了“字符串—值”的对应，Map 结构提供了“值—值”的对应，是一种更完善的 Hash 结构实现。

const m = new Map();
const o = {p:"hello world"};

m.set(o, 'content');
m.get(o);   // 'content'

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

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

const m = new Map([
	["name":"xiaoming"],
	["title": "author"]
]);

m.size   //2
m.has('name');   //true
m.get('name');   // "xiaoming"
m.has("title");  // true
m.get("title");  // "author"

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

const set = new Set([
	['foo':1],
	['bar':2]
]);

const m1 = new Map(set);
m1.get('foo'); // 1

const m2 = new Map([['baz', 3]]);
const m3 = new Map(m2);
m3.get('baz') // 3

如果对同一个键多次赋值，后面的值将覆盖前面的值。
如果读取一个未知的键，则返回undefined。
只有对同一个对象的引用，Map 结构才将其视为同一个键。
同样的值的两个实例，在 Map 结构中被视为两个键。
Map 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键。

2. Map实例的属性和操作方法

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

1
2
3

const map = new Map();
map.set("foo", true);
map.size   //1

2) set(key, value)
设置键名为key对应的值为value，返回整个Map结构。如果key已经有值则会更新值，否则生成新键：

1 2	const m = new Map(); m.set("a", "hello world");

可以采用链式写法：

let map = new Map()
	.set("a",1)
	.set("b",2)
	.set("c",3);

3) get(key)
get方法读取key对应的键值，如果找不到key，返回undefined

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

let map = new Map()
	.set("a",1)
	.set("b",2);
map.has("a");  // true
map.has("c");  // false

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

let map = new Map()
	.set("a",1)
	.set("b",2);
map.has("a");  // true
map.delete("a");
map.has("a");  // false

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

let map = new Map()
	.set("a",1)
	.set("b",2);
map.size;   //2
map.clear();
map.size;   // 0

3. Map的遍历方法

Map 结构原生提供三个遍历器生成函数和一个遍历方法：
keys() : 返回键名的遍历器
values() : 返回键值的遍历器
entries() : 返回所有成员的遍历器
forEach() : 遍历Map的所有成员

Map 的遍历顺序就是插入顺序

const map = new Map([
	["a":1],
	["b":2]
]);

for( let key of map.keys() ){
	console.log(key);
}
//"a","b"

for( let values of map.values() ){
	console.log(values);
}
//"1","2"

for( let item of map.entries() ){
	console.log(item[0], item[1]);
}
//or
for( let [key,value] of map.entries() ){
	console.log(key, value);
}
//"a" "1"
//"b" '2'

4. Map与其他数据结构的互相转换

1) Map转为数组
Map 转为数组最方便的方法，就是使用扩展运算符（…）

const m = new Map([
	[1,"a"],
	[2,"b"],
	[3,"c"]
]);
[...m.keys()];     // [1,2,3]
[...m.values()];   // ["a","b","c"]
[...m.entries()];  // [[1,"a"],[2,"b"],[3,"c"]]
[...m];            // [[1,"a"],[2,"b"],[3,"c"]]

2) 数组转为Map
将数组传入 Map 构造函数，就可以转为 Map

new Map([
  [true, 7],
  [{foo: 3}, ['abc']]
])
// Map {
//   true => 7,
//   Object {foo: 3} => ['abc']
// }

3) Map 转为对象
如果所有 Map 的键都是字符串，它可以无损地转为对象

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

const myMap = new Map()
  .set('yes', true)
  .set('no', false);
mapToObj(myMap)
// { yes: true, no: false }

4) 对象转为Map

function objToMap( obj ){
	let map = new Map();
	for( let key of Object.keys(obj) ){
		map.set(key,obj[k]);
	}
	return map;
}
objToMap({1:"a"，2:"b"});
// Map {"yes" => true, "no" => false}

5) Map转为JSON
Map 转为 JSON 要区分两种情况。一种情况是，Map 的键名都是字符串，这时可以选择转为对象 JSON。

function strMapToJson(strMap) {
  return JSON.stringify(mapToObj(strMap));
}

let myMap = new Map().set('yes', true).set('no', false);
strMapToJson(myMap)
// '{"yes":true,"no":false}'

另一种情况是，Map 的键名有非字符串，这时可以选择转为数组JSON。

function mapToArrayJson(map) {
  return JSON.stringify([...map]);
}

let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
mapToArrayJson(myMap)
// '[[true,7],[{"foo":3},["abc"]]]'