Set

ES6提供了新的数据结构Set。它类似于数组。但是成的值都是唯一的，没有重复的值。
Set本身是一个构造函数，用来生成Set数据结构。
可以用来数组的去重。
向Set加入值的时候，不会发生类型的转换，所以5和‘5’是两个不同的值。Set内部判断两个值是否不同使用的算法类似于精确相等运算符(===)，于‘===’的主要的区别的NaN等于自身而‘===’ NaN是不等于自身的。
对象基于指针问题是不会相等的。

const s = new Set();
[2,3,4,5,6,4,3,4,2,2].forEach(x => s.add(x));
for(let i of s){
  console.log(i);
}
//2,3,4,5,6
const set = new Set([1,2,3,4,4])
[...set]
//1,2,3,4

let set = new Set();
let a = NaN;
let b = NaN;
set.add(a);
set.add(b);
set //Set{NaN};

Set实例的属性和方法
Set.prototype.constructor //指向本身
Set.prototype.size //Set实例的成员总数

方法：

add() //增加
delete() //删除
has() //查询返回Boolean
clear() //清除所有

遍历方法：

keys()//返回键名
values()//返回键值
entries()//返回键值对数组
forEach() //loop
由于Set结构没有键名，只有键值所以keys和values方法的行为完全一致。

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的value获取直接可以用for...of获取
for(let item of set){
  console.log(item);
// red
// green
// blue
}
//Set结构的实例于数组一样，也拥有forEach方法，用于对每个成员执行某种操作，没有返回值
set.forEach((key,value) => {console.log(key + ' : ' + value)});
// red:red
// green:green
// blue:blue

运用扩展运算符

let set = new Set(['red', 'green', 'blue']);
[...set]
//['red','green','blue']
//扩展运算符与Set结构相结合，就可以去除数组的重复成员
let set = [1,2,3,3,3,3,4,4,5];
[...new Set(set)]
//[1,2,3,4,5]
new Set([...set].filter(x => {return x % 2 === 0}));
//{2,4}

Set 实现并集/交集/差集

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}

改变Set值

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

WeakSet

WeakSet结构与Set相似，也是不重复的值的集合。但是它与Set有两个区别。
首先WeakSet的成员只能是对象，而不能是其他类型的值。其中的对象都是弱引用，随时可能小时，跟浏览器垃圾回收机制有关。不会出现内存泄漏。
比较适合临时存放一组对象，以及存放跟对象绑定的信息。
方法：add() delete() has()
WeakSet不可遍历所以也没有size属性

const ws = new WeakSet();
ws.add(1)
//TypeError:Invalid value used in weak set
ws.add(Symbol());
//TypeError:Invalid value used in weak set

具有Iterable接口的对象，都可以作为WeakSet的参数。
b数组的成员为WeakSet的成员，而不是b数组本身。这意味着，数组的成员只能是对象。

const a = [[1,2],[3,4]];
const ws = new WeakSet(a);
//WeakSet{[1,2],[3,4]}
const b = [1,2];
const ws = new WeakSet(b);
//uncaught TypeError:Invalid value used in weak set;

Map

Javascript的对象(Object)，本质上是键值对的集合(Hash结构),但是传统上只能用字符串当作键。
Map数据结构类似于对象，也是键值对的集合，但是与对象的区别是键的繁为不限于字符串，各种类型的值(包括对象)都可以当作键。也就是说Object结构提供了‘字符串-值’的对象，Map结构提供了‘值-值’的对象。这是一种更完善的Hash结构实现。如果你需要‘键值对’的数据结构，Map比Object更合适。

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

方法：set get has delete clear

//Map结构数据的增删改查。
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
m.clear();
m.size //0

遍历的方法 keys values entries forEach

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

//上面的例子解析执行的方法
const items = [
  ['name', '张三'],
  ['title', 'Author']
]

const map = new Map()
items.forEach(([key,value]) => map.set(key,value))

Set和Map都可以用来生成新的Map

const set = new Set([
  ['foo',1],
  ['bar',2]
]);
const m1 = new Map(set);
m1.get('foo')//1
const m2 = new Map([['bar',3]]);
const m3 = new Map(m2);
m3.get('bar')//3
m3.set('bar',4)
m3.get('bar')//4    如果对同一个键多次赋值，后面的值将覆盖前面的值

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

//如果键为对象要确定为同一个对象的引用
const map = new Map()
map.set(['a'],555);
map.get(['a']);//undefined

//同理，同样的值的两个实例，在Map结构中被视为两个键
const map = new Map()
var a = ['a'];
var b = ['a']
map.set(a,555);
map.set(b,666)
map.get(a);//555
map.get(b);//666

Map通过严格相等来判断是否为一个键。

0 === -0//true
true === 'true' //false
undefined === null //false
NaN === NaN //false   虽然NaN不严格相等于自身，但Map将其视为同一个键

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

Map转为数组

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

数组转为Map

new Map([...map])

Map转为对象

function Maptoobj(v){
  var obj = Object.create(null);
  for(let [key,value] of v){
    obj[key] = value
  }
  return obj
}
Maptoobj(map);

对象转化为Map

function objtomap(v){
  var map = new Map();
  for(let i of Object.keys(v)){
    map.set(i,v[i])
  }
  return map
}
objtomap({'a':1})

Map 转化为Json 如果Map的键名都是字符串

function maptojson(v){
  return JSON.stringify(Maptoobj(v))
}
let myMap = new Map().set('yes', true).set('no', false);
maptojson(myMap)
// '{"yes":true,"no":false}'

如果Map的键名有非字符串

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"]]]'

JSON转化为Map

function jsonToStrMap(jsonStr) {
  return objtomap(JSON.parse(jsonStr));
}

jsonToStrMap('{"yes": true, "no": false}')
// Map {'yes' => true, 'no' => false}

如果整个json是一个数组且每个数组成员本身又是一个又两个成员的数组

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

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

WeakMap

与Map数据结构类似，也是用于生成键值对的集合与Weakset一样突出弱引用的作用。
与Map的区别
1.和WeakSet一样只接受对象作为键名(null除外,null为对象但是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

与WeakSet一样 WeakMap没有遍历操作(即没有keys() values() entries()方法)也没有size属性。也不支持clear()方法。

const wm = new WeakMap()
wm.size //undefined
wm.clear//undefined
wm.forEach//undefined

ES6 Set、Map