ES6学习之Set和Map

一、Set

1.Set

定义：Set类似于数组，但成员的值都是唯一的，没有重复的值

let s = new Set([1,2,3,4,5,2,4]);   //Set { 1, 2, 3, 4, 5 }

Set转数组

let s = new Set([1, 2, 3, 4, 5, 2, 4]);
//方法一：
let arr = [...s]; //[ 1, 2, 3, 4, 5 ]
//方法二
let arr2 = Array.from(s); //[ 1, 2, 3, 4, 5 ]

利用Set实现数组去重

let arr = [1, 2, 3, 5, 2, 1,NaN,NaN,"5",0,-0];
//Set内部使用精确等于，类似于===，但NaN等于NaN
let arr2 = [...new Set(arr)]; 
console.log(arr2)   //[ 1, 2, 3, 5, NaN, '5', 0 ]

Set实例的属性

• constructor（构造函数，默认就是Set函数）

let s = new Set();
s.constructor   //[Function: Set]

• size（返回Set实例的成员总数）

let s = new Set([1, 2, 6, 5, 4, 3, 3, 1]);
s.size //6

Set实例的方法

add(value)：添加成员，返回Set结构本身

delete(value)：删除成员，返回Set结构本身

has(value)：判断成员是否存在，返回布尔值

clear()：清除所有成员，没有返回值

let s = new Set();
s.add(1).add(2); //Set { 1, 2 }
s.delete(1); //Set { 2 }
s.has(1) //false
s.clear()
console.log(s) //Set {}

Set遍历操作

keys()：返回键名的遍历器

values()：返回键值的遍历器

entries()：返回键值对的遍历器

forEach()：使用回调函数遍历每个成员

let s = new Set(["green", "blue", "red"]);
for (let item of s) { //默认取values
    console.log(item) //green blue red
}

for (let item of s.values()) {
    console.log(item) //green blue red
}

for (let item of s.keys()) {
    console.log(item) //green blue red
}

for (let item of s.entries()) {
    console.log(item) //[ 'green', 'green' ]    [ 'blue', 'blue' ]  [ 'red', 'red' ]
}

s.forEach((value, key) => {
    console.log(key + ":" + value)
}) //green:green   blue:blue   red:red

Set取交集，并集和差集（数组的map好filter方法可以应用于Set）

let s1 = new Set([1, 2, 3, 4, 5]);
let s2 = new Set([1, 3, 5, 7, 9]);
//并集
let s3 = new Set([...s1, ...s2]); //Set { 1, 2, 3, 4, 5, 7, 9 }
//交集
let s4 = new Set([...s1].filter(x => s2.has(x))); //Set { 1, 3, 5 }
//差集
let s5 = new Set([...s1].filter(x => !s2.has(x)))   //Set { 2, 4 }

2.WeakSet

定义：不重复的值的集合，成员只能是对象（obj,arr），而不能是其他类型的值。WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用。

let s = new WeakSet([[1,2],[3,4]]); //ok
let s2 = new WeakSet([1,2,3]);  //error

方法：add(value),delete(value),has(value),不能遍历（不能使用forEach等）也没有size属性

let s = new WeakSet();
let foo = {};
let obj = {};

s.add(foo).add(obj);
s.delete(foo);
s.has(foo)

二、Map

 1.Map

定义：类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。

const m = new Map();
const o = {p: 'Hello World'};

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

任何具有 Iterator 接口、且每个成员都是一个双元素的数组的数据结构都可以当作Map构造函数的参数。

//数组
let map = new Map([
    ["name", "fred"],
    ["age", 23]
])
console.log(map) //Map { 'name' => 'fred', 'age' => 23 }

//Set
let set = new Set([
    ["name", "fred"],
    ["age", 23]
])
let map1 = new Map(set);
console.log(map1) //Map { 'name' => 'fred', 'age' => 23 }

//Map
let m = new Map([
    ["name", "fred"],
    ["age", 23]
])
let map2 = new Map(m);
console.log(map2) //Map { 'name' => 'fred', 'age' => 23 }

Map的键：对象（绑定内存地址，只有对同一对象的引用，才视为同一个键），简单数据类型（只要两个值严格相等（===），Map 将其视为一个键）

let map = new Map();
let a = ['a'];
let b = ['a'];
map.set(a, "111").set(b, "222"); //引用类型a和b的内存地址不一样，视为两个key
console.log(map) //Map { [ 'a' ] => '111', [ 'a' ] => '222' }

let map2 = new Map();
map2.set(-0, "111").set(0, "222"); //简单数据类型，严格等于-0===0，后者覆盖前者
console.log(map2) //Map { 0 => '222' }

属性和方法

size()：返回 Map 结构的成员总数

set(key,value)：设置键名key对应的键值为value

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

delete(key)：删除某个键，返回true

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

clear()：清除所有成员，没有返回值

let map = new Map();
map.set("name","fred");
map.get("name");
map.has("name");
map.size;
map.delete("name");
map.clear()

遍历方法

keys()：返回成员的key

values()：返回成员的value

entries()：返回成员的键值对

forEach()：遍历所有成员（Map 的遍历顺序就是插入顺序）

let map = new Map([
    ["name","fred"],
    ["age",23]
]);
for (let item of map.keys()){
    console.log(item)
}   //name age

for (let item of map.values()){
    console.log(item)
}   //fred 23

for (let item of map.entries()){
    console.log(item)
}   //[ 'name', 'fred' ] [ 'age', 23 ]

for (let [key,value] of map){
    console.log(key,value)
}   //name fred      age 23

map.forEach(function(value, key, map) {
  console.log("Key: %s, Value: %s", key, value);
}); //Key: name, Value: fred     Key: age, Value: 23

与数组的map方法、filter方法结合使用

let map = new Map([
    [1,"fred"],
    [2,23]
]);

let map1 = new Map(
    [...map].filter(([k,v])=>k<2)
)   //Map { 1 => 'fred' }

let map2 = new Map(
    [...map].map(([k,v])=>[k*2,v])
)   //Map { 2 => 'fred', 4 => 23 }

2.WeakMap

定义：与Map结构类似，也是用于生成键值对的集合。键名只能是对象，键名所指向的对象，不计入垃圾回收机制。

let map = new WeakMap();
let key = {foo: 1};
map.set(key, 2) //ok
map.set(1, 2) //error

语法：没有遍历操作（即没有key()、values()和entries()方法），也没有size属性。只有四个方法可用：get()、set()、has()、delete()

const wm = new WeakMap();

// size、forEach、clear 方法都不存在
wm.size // undefined
wm.forEach // undefined
wm.clear // undefined