1.set

ES6提供了新的数据结构Set。它类似于数组，但是成员的值都是唯一的，没有重复的值,set本身就是构造函数，所以可以通过new的方式来创建对象

1 // 例一 可以做数组去重用
2 var set = new Set([1, 2, 3, 4, 4]);
3 [...set]
4 // [1, 2, 3, 4]

那么set内部是怎么判断两个数据相不相等呢？使用的算法叫做“Same-value equality”，它类似于精确相等运算符（===），所以 5 和 ‘5‘是不同的，它和（===）唯一的不同就是它认为NaN是同一个值，是相等的。

Array.from方法可以将Set结构转为数组。这里就刚好提供了数组的去重方法

1 function dedupe(array) {
2   return Array.from(new Set(array)); //将set结构转化为数组
3 }
4 dedupe([1, 1, 2, 3]) // [1, 2, 3]    传入数组返回一个去重的数组

set的属性和方法

• Set.prototype.constructor:构造函数，默认就是set函数
• Set.prototype.size:返回成员总数
• add(value):添加值，返回Set对象本身
• delete(value):删除值,返回布尔值，是否删除成功
• has（value）:是否存在某个值，返回布尔值
• clear（）:清空所有成员
• keys():返回键名
• values():返回键 
• entires():返回键值对
• forEach():使用回调函数遍历每个成员
  

//操作数据类方法
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

操作数据类方法

//遍历方法
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"]
}

let set = new Set([1, 2, 3]);
set.forEach((value, key) => console.log(value * 2) )// 2 4 6

遍历方法

set应用

• 

  1 //扩展运算符（...）内部使用for...of循环,就可以去除数组的重复成员。
  2 let arr = [3, 5, 2, 2, 5, 5];
  3 let unique = [...new Set(arr)];    // [3, 5, 2]

  应用1，数组去重

• 

  1 //map和filter也可以用于set中了
  2 
  3 let set = new Set([1, 2, 3]);
  4 set = new Set([...set].map(x => x * 2));
  5 // 返回Set结构：{2, 4, 6}
  6 
  7 let set = new Set([1, 2, 3, 4, 5]);
  8 set = new Set([...set].filter(x => (x % 2) == 0));
  9 // 返回Set结构：{2, 4}

  应用2，set和map、filter

• 

  //因此使用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}

  应用3，实现交、并、差集

2.map

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

对象作为参数

var map = new Map();
map.set({p}, 555);
map.get({p}) // undefined
//虽然都是{p},但是map储存的是地址，他们代表的是两个不同对象

数组作为参数

var m = new Map([
  [true, ‘foo‘],
  [‘true‘, ‘bar‘]
]);

m.get(true) // ‘foo‘
m.get(‘true‘) // ‘bar‘
//这里的两个键的类型不同哦，所以得到的值也会不同

同一个键多次赋值将会覆盖

let map = new Map();

map
.set(1, ‘aaa‘)
.set(1, ‘bbb‘);

map.get(1) // "bbb"
//后面的赋值会覆盖前面的赋值

未知键的值返回undefined

new Map().get(‘asfddfsasadf‘)

其他 NaN -0和+0，在map里将视为是同一值

map的属性和方法

• size属性返回Map结构的成员总数。
• set(key, value )　　设置key所对应的键值，如果已经有键值那么就会更新
• get(key)　　获取key所对应的键值，找不到就会返回undefined
• has（key）　　是否存在这个键，返回布尔值
• delete（key）　　删除这个键，返回true则成功，false则不成功
• clear（）　　清除所有成员方法

遍历方法

• keys()：返回键名的遍历器。
• values()：返回键值的遍历器。
• entries()：返回所有成员的遍历器。
• forEach()：遍历Map的所有成员。

　　注：需要特别注意的是，Map的遍历顺序就是插入顺序。

es6之set和map