Set、Map结构笔记

Set

ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。

1. Set本身是一个构造函数，用来生成 Set 数据结构(new Set)。
2. add()方法向 Set 结构加入成员， Set 结构不会添加重复的值
3. Set函数接受数组作为参数，也可接受类似数组的对象作为参数，提供了一种数组去重的方法。

	[...new Set(array)]
	Array.from(new Set(array))

4. 在 Set 内部，两个NaN是相等的，两个对象总是不相等的。
5. Set 结构的实例有以下属性。

//Set.prototype.constructor：构造函数，默认就是Set函数。
	//Set.prototype.size：返回Set实例的成员总数。
	//Set 实例的方法分为两大类：操作方法（用于操作数据）和遍历方法（用于遍历成员）。下面先介绍四个操作方法。
	
	//Set.prototype.add(value)：添加某个值，返回 Set 结构本身。
	//Set.prototype.delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
	//Set.prototype.has(value)：返回一个布尔值，表示该值是否为Set的成员。
	//Set.prototype.clear()：清除所有成员，没有返回值。
	//Set.prototype.keys()，values()，entries()：返回set键值、键名、键值对

6. 数组的map和filter方法也可以间接用于 Set 了

let set = new Set([1, 2, 3]);
	set = new Set([...set].map(x => x * 2));
	// 返回Set结构：{2, 4, 6}
	
	let set = new Set([1, 2, 3, 4, 5]);
	set = new Set([...set].filter(x => (x % 2) == 0));
	// 返回Set结构：{2, 4}

7. 使用 Set 可以很容易地实现并集（Union）、交集（Intersect）和差集（Difference）

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

// 并集
let union = new Set([...a, ...b]);
// Set {1, 2, 3, 4}

// 交集
let intersect = new Set([...a].filter(x => b.has(x)));
// set {2, 3}

// 差集
let difference = new Set([...a].filter(x => !b.has(x)));
// Set {1}

Map

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

1. 只有对同一个对象的引用，Map 结构才将其视为同一个键。

	const map = new Map();

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

2. Map 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键。这就解决了同名属性碰撞（clash）的问题

	let map = new Map();
	
	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

3. 实例的属性和操作方法
   （1）size 属性

    size属性返回 Map 结构的成员总数。
   

   （2）Map.prototype.set(key, value)

    set方法设置键名key对应的键值为value，然后返回整个 Map 结构。
    如果key已经有值，则键值会被更新，否则就新生成该键。
    
    set方法返回的是当前的Map对象，因此可以采用链式写法。
   

   （3）Map.prototype.get(key)

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

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

（4）Map.prototype.has(key)

	has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中。
	
（5）Map.prototype.delete(key)

	delete方法删除某个键，返回true。如果删除失败，返回false。
	
（6）Map.prototype.clear()

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

5. 与其他数据结构的类型转换
   （1）Map 转为数组

   前面已经提过，Map 转为数组最方便的方法，就是使用扩展运算符（…）。

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

（2）数组 转为 Map

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

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

（3）Map 转为对象

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

function strMapToObj(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);
	strMapToObj(myMap)
	// { yes: true, no: false }

如果有非字符串的键名，那么这个键名会被转成字符串，再作为对象的键名。

（4）对象转为 Map

function objToStrMap(obj) {
	  let strMap = new Map();
	  for (let k of Object.keys(obj)) {
	    strMap.set(k, obj[k]);
	  }
	  return strMap;
	}
	
	objToStrMap({yes: true, no: false})
	// Map {"yes" => true, "no" => false}

（5）Map 转为 JSON

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

function strMapToJson(strMap) {
	  return JSON.stringify(strMapToObj(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"]]]'

（6）JSON 转为 Map

JSON 转为 Map，正常情况下，所有键名都是字符串。

function jsonToStrMap(jsonStr) {
	  return objToStrMap(JSON.parse(jsonStr));
	}
	
	jsonToStrMap('{"yes": true, "no": false}')
	// Map {'yes' => true, 'no' => false}

但是，有一种特殊情况，整个 JSON 就是一个数组，且每个数组成员本身，又是一个有两个成员的数组。
这时，它可以一一对应地转为 Map。这往往是 Map 转为数组 JSON 的逆操作。

function jsonToMap(jsonStr) {
  return new Map(JSON.parse(jsonStr));
}

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