ES6入门总结（三）

ES6入门总结之Set和Map

摘抄自阮一峰：http://es6.ruanyifeng.com/#docs/set-map

Set

1. set实例的属性和方法
2. 遍历操作
3. WeakSet

1. set实例的属性和方法

• es6提供了新的数据结构Set，类似于数组，但成员的值都是唯一的，没有重复的值，本身是一个构造函数，用类似生成Set数据结构。

const s = new Set();
[2,3,4,5,6,3,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]
const items = new Set([1,2,3,4,5,5,5,5]);
items.size//5
//set函数可以接受数组作为参数
const set = new Set(document.querySelectorAll('div'));
set.size //56
const set = new Set();
document
.querySelectorAll('div')
.forEach(div => set.add(div));
set.size // 56
//set函数也可以接受类似于数组的对象作为参数
[...new Set(array)]//数组去重的其中一种方法
[...new Set('ababbc')].join('')//"abc" 也可以用于去除字符串里面的重复字符

向Set加入值时不会发生类型转换，类似于（=== ），主要区别是向set加入值时认为NaN等于自身 ，在全等于中认为NaN不等于自身

let set = new Set();
let a = NaN;
let b = NaN;
set.add(a);
set.add(b);
set//set {NaN}
//在set中NaN等于自身

let set = new Set();
set.add({});
set.size//1
set.add({});
set.size//2
//两个对象总是不相等的，由于两个空对象不相等所以被视为两个值

• set实例的属性和方法

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

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

const items = new Set([1,2,3,4,5]);
const array = Arrar.from(items);
function dedupe(array){
  return Array.from(new Set(array));
}
dedupe([1,1,2,3])//[1,2,3]
//提供了数组去重的另一种方式

2.遍历操作

• 四个遍历方法

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

a. keys()，values()，entries() 返回的都是遍历器对象，由于Set结构没有键名只有键值，所以keys方法和values方法的行为完全一致，entries方法返回的遍历器，同时包括键名和键值，所以每次输出一个数组，他的两个成员完全相等。

let set = new Set(['red','green','blue']);
for(let item of set.keys()){
  console.log(items);
}
//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方法返回键值对，但是由于键名=键值，所以输出的数组两个成员完全相等

Set.prototype[Symbol.iterator] === Set.prototype.values//true
//Set结构的实例默认可遍历。他的默认遍历器生成函数就是它的values方法
let set = new Set(['red','green','blue']);
for(let x of set){
  console.log(x);
}
//red
//green
//blue
//可以省略values方法，直接用for...of循环遍历Set

b. forEach()
forEach()的参数就是一个处理函数，该函数的参数与数组的forEach一致，一次为键值、键名、集合本身（由于set结构中键名与键值相等，所以第一个参数与第二个参数永远都一样），另外forEach方法还可以有第二个参数，表示绑定处理函数内部的this对象

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

c. 遍历的应用

1. 扩展运算符(…)和Set结构的结合，可以去除数组的重复成员

let set = new Set([3,5,6,7,5,3,2,6])
let unique = [...new Set(arr)];
//[3,5,6,7,2]

2. 数组的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}

3. 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}

4. 在遍历操作中同步原来的Set结构，一种时利用原Set结构映射出一个新的结构，然后赋值给原来的Set结构，另一种是利用Array.from方法

//方法一：利用原Set结构映射出一个新的结构，赋值给原来的set结构
let set = new Set([1,2,3]);
set = new Set([...set].map(val => val * 2));
//set的值是2,4,6

//方法二：利用Array.from
let set = new Set([1,2,3]);
set = new Set(Array.from(set, val => val * 2));
//set的值是2,4,6

d.WeakSet
WeakSet结构与Set类似，也是不重复的值的集合，与set有两个区别：WeakSet的成员只能是对象，而不能是其他类型的值；WeakSet中的对象都是弱引用，垃圾回收机制不考虑WeakSet对该对象的引用，如果没有其他对象引用，就会被垃圾回收机制自动回收该对象所占用的内存，因此适合临时存放一组对象，以及存放跟对象绑定的信息

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

1. WeakSet语法：是一个构造函数，可以使用new命令，可以接受一个数组或者类似于数组的对象作为参数（具有iterable接口的对象），都会自动成为WeakSet的实例对象成员。

const ws = new WeakSet();
const a = [[1,2],[3,4]];
const ws = new WeakSet(a);
//WeakSet{[1,2],[3,4]}
//a数组成为WeakSet的成员，而不是a数组本身，这意味着数组成员只能是对象
const b = [3,4];
const ws = new WeakSet(b);
//Uncaught TypeError:Invalid value used inweak set(...)
//数组b的成员不是对象，加入WeakSet就会报错

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

const ws = new WeakSet();
const obj = {};
const foo = {};
ws.add(window);
ws.add(obj);
ws.has(window);//true
ws.has(foo);//false
ws.delete(window);//清除某个指定的值
ws.has(window);//false 清除过后不存在

ws.size//undefined
ws.forEach//undefined
ws.forEach(function(item){console.log('WeakSet has' + item)})
//TypeError:undefined is not a function               
//WeakSet不能遍历，成员都是弱引用，随时可能消失，遍历机制无法保证成员的存在

const foos = new WeakSet()
class Foo {
  constructor(){
    foos.add(this)
  }
  method(){
     if(!foos.has(this)){
       throw new TypeError('Foo.prototype.method只能在Foo的实例上调用！')
    }
  }
}
//保证了Foo的实例方法只能在Foo的实例上调用，foos对实例的引用不会被计入内存回收机制中，删除的时候不用考虑foos，不会出现内存泄漏

Map

1. 实例属性和操作方法
2. 遍历方法
3. 与其他结构的互相转换
4. WeakMap

• es6提供了Map数据结构，类似于对象，也是键值对的集合，但是各种类型的值（包括对象）都可以当作键，作为构造函数，Map接受一个数组作为参数。

const items = [
  ['name','张三'],
  ['title','Author']
];
const map = new Map();
items.forEach(
 ([key,value]) => map.set(key,value)
);
//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
//任何具有Iterator接口、且每个成员都是一个双元素的数组的数据结构，都可以当作构造函数的参数。set和map都可以用来生成新的map

//如果对同一个键多次赋值。后面的值将覆盖前面的值
const map = new Map();
map
.set(1,'aaa')
.set(1,'bbb');
map.get(1)//"bbb"
new Map().get('sgdfsafaf')
//undefined  读取一个未知的值，则返回undefined

const map = new Map();
map.set(['a'],555);
map.get(['a'])//undefined
//Map结构中只有对同一个对象引用，才会视为同一键，但实际上时两个不同数组的实例，内存地址不一样，所以get无法读取该值，返回undefined
const map = new Map();
const k1 = ['a'];
const k2 = ['a'];
map
.set(k1,111)
.set(k2,222);
map.get(k1)//111
map.get(k2)//222
//同样值的两个实例，在Map结构中被视为两个键，map的键实际上是跟内存地址绑定的，只要内存地址不同就被视为两个键，解决了同名属性碰撞的问题(clash)

let map = new Map();
map.set(-0,123);
map.get(+0)//123 默认0和-0是同一个键，布尔值true和字符串true则是两个不同的键，undefined和null也是两个不同的键，虽然NaN不严格相等于自身，但Map将其视为同一个键

• map的遍历方法

属性和方法	内容
size属性	返回Map结构的成员总数
Map,prototype.set(key,value)	set方法设置键名key对应的键值为value，然后返回整个Map结构，如果key已经有值，则键值会被更新，否则就新生成该键，set方法返回的是当前的map对象，可以采用链式写法
Map.prototype.get(key)	get方法读取key对应的键值，如果找不到key，返回undefined
Map.prototype.has(key)	has方法返回一个布尔值，表示某个键是否在当前Map对象之中
Map.prototype.delete(key)	delete方法删除某个键，返回true,如果删除失败，返回false.
Map.prototype.clear()	clear方法清除所有成员，没有返回值

a. size属性

const map = new Map();
map.set('foo',true);
map.set('bar',false);
map.size //2 size返回Map结构的成员总数

b. Map.prototype.set(key,value)

const m = new Map();
m.set('edition',6) //键是字符串
m.set(262,'standard')//键是数值
m.set(undefined,'nah')//键是undefined 
//如果key已经有值，则键值会被更新，否则就新生成该键
let map = new Map()
.set(1,'a')
.set(2,'b')
.set(3,'c');
//set方法返回的是当前map对象，可以采用链式写法

c. Map.prototype.get(key)

const m = new Map();
const hello = function(){console.log('hello');};
m.set(hello,'Hello ES6!') //键是函数
m.get(hello) //Hello ES6!
//get方法读取key对应的键值，找不到key,返回undefined

d.Map.prototype.has(key)

const m = new Map();
m.set('edition',6);
m.set(262,'standard');
m.set(undefined,'nah');
m.has('edition') //true
m.has('years') //false
m.has(262) //true
m.has(undefined) //true
//返回布尔值，表示某个键是否在当前Map对象之中

e. Map.prototype.delete(key)

const m = new Map();
m.set(undefined,'nah');
m.has(undefined) //true
m.delete(undefined)
m.has(undefined) //false
//删除某个键，返回true，如果删除失败，返回false

f. Map.prototype.clear()

let map = new Map();
map.set('foo',true);
map.set('bar',false);
map.size //2
map.clear()
map.size //0
//清除所有成员，没有返回值

• 遍历方法

1. Map.prototype.keys():返回键名的遍历器
2. Map.prototype.values():返回键值的遍历器
3. Map.prototype.entries():返回所有成员的遍历器
4. Map.prototype.forEach():遍历Map的所有成员

Map的遍历顺序就是插入顺序，结合数组的map方法、filter方法可以实现Map的遍历和过滤（Map本身没有map和filter方法）

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}

• 与其他数据结构的互相转换
  1. Map转为数组，最方便的方法是使用扩展运算符(…)

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

2. 数组转为Map

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

3. 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}

• WeakMap
  结构与map结构类似，也是用于生成键值对的集合
  区别有两点：
  1. WeakMap只接受对象作为键名(null除外)，不接受其他类型的值作为键名。
  2. WeakMap的键名所指向的对象，不计入垃圾回收机制(WeakMap弱引用的只是键名，而不是键值。键值依然是正常引用)。WeakMap的专用场合就是，它的键所对应的对象，可能会在将来小时。WeakMap结构有助于防止内存泄漏。

const wm = new WeakMap();
const element = document.getElementById('example');
wm.set(element,'some information');
wm.get(element) //"some information"
//要往对象上添加数据，又不想干扰垃圾回收机制，这时WeakMap里面对element的引用就是弱引用，不会被记入垃圾回收机制

const wm = new WeakMap();
let key = {};
let obj = {foo:1};
wm.set(key,obj);
obj = null;
wm.get(key)
// Object{foo:1}
//WeakMap弱引用的只是键名，而不是键值。键值依然是正常引用。即使在WeakMap外部消除了obj的引用，内部的引用依然存在。

• WeakMap语法
  与Map在API上的区别：
  1. 没有遍历操作，也没有size属性，没有办法列出所有键名，某个键名是否存在完全不可预测，跟垃圾回收机制是否运行有关
  2. 无法清空。不支持clear方法，只有四种方法可用：get()、set()、has()、delete()

const wm = new WeakMap();
//size、forEach、clear方法都不存在
wm.size //undfined
wm.forEach //undefined
wm.clear // undefined

WeakMap的用途

1. dom节点作为键名，一旦节点删除，该状态就会自动消失，不存在内存泄漏风险
2. 部署私有属性，因为是内部属性是实例的弱引用，所以如果删除实例它们也就随之消失，不会造成内存泄漏