完全弄懂ES6中的Map和Set

Map

Map对象保存键值对。任何值(对象或者原始值) 均可以做为一个键或一个值。构造函数Map能够接受一个数组做为参数。

Map和Object的区别

• 一个Object 的键只能是字符串或者 Symbols，但一个Map 的键能够是任意值。

• Map中的键值是有序的（FIFO 原则），而添加到对象中的键则不是。

• Map的键值对个数能够从 size 属性获取，而 Object 的键值对个数只能手动计算。

• Object 都有本身的原型，原型链上的键名有可能和你本身在对象上的设置的键名产生冲突。

1. Map对象的属性

• size：返回Map对象中所包含的键值对个数

1. Map对象的方法

• set(key, val): 向Map中添加新元素

• get(key): 经过键值查找特定的数值并返回

• has(key): 判断Map对象中是否有Key所对应的值，有返回true,不然返回false

• delete(key): 经过键值从Map中移除对应的数据

• clear(): 将这个Map中的全部元素删除

const m1 = new Map([['a', 111], ['b', 222]])
console.log(m1) // {"a" => 111, "b" => 222}
m1.get('a')  // 111

const m2 = new Map([['c', 3]])
const m3 = new Map(m2)
m3.get('c') // 3
m3.has('c') // true
m3.set('d', 555)
m3.get('d') // 555

1. 遍历方法

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

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

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

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

const map = new Map([['a', 1], ['b',  2]])

for (let key of map.keys()) {
  console.log(key)
}
// "a"
// "b"

for (let value of map.values()) {
  console.log(value)
}
// 1
// 2

for (let item of map.entries()) {
  console.log(item)
}
// ["a", 1]
// ["b", 2]

// 或者
for (let [key, value] of map.entries()) {
  console.log(key, value)
}
// "a" 1
// "b" 2

// for...of...遍历map等同于使用map.entries()

for (let [key, value] of map) {
  console.log(key, value)
}
// "a" 1
// "b" 2

1. map与其余数据结构的互相转换

• map转换为数组（使用扩展运算符）

const arr = [[{'a': 1}, 111], ['b': 222]]

const myMap = new Map(arr)

[...myMap] // map转数组。 [[{'a': 1}, 111], ['b': 222]]

• Map与对象的互换

const obj = {}
const map = new Map(['a', 111], ['b', 222])
for(let [key,value] of map) {
  obj[key] = value
}
console.log(obj) // {a:111, b: 222}

• JSON字符串要转换成Map能够先利用JSON.parse()转换成数组或者对象，而后再转换便可。

Set

Set对象容许你存储任何类型的值，不管是原始值或者是对象引用。它相似于数组，可是成员的值都是惟一的，没有重复的值。
Set 自己是一个构造函数，用来生成Set 数据结构。Set函数能够接受一个数组（或者具备 iterable 接口的其余数据结构）做为参数，用来初始化。

Set中的特殊值

Set 对象存储的值老是惟一的，因此须要判断两个值是否恒等。有几个特殊值须要特殊对待：

• +0 与 -0 在存储判断惟一性的时候是恒等的，因此不重复

• undefined 与 undefined 是恒等的，因此不重复

• NaN 与 NaN 是不恒等的，可是在 Set 中认为NaN与NaN相等，全部只能存在一个，不重复。

1. Set实例对象的属性

• size：返回Set实例的成员总数。

1. Set实例对象的方法

• add(value)：添加某个值，返回 Set 结构自己(能够链式调用)。

• delete(value)：删除某个值，删除成功返回true，不然返回false。

• has(value)：返回一个布尔值，表示该值是否为Set的成员。

• clear()：清除全部成员，没有返回值。

const mySet = new Set(['a', 'a', 'b', 1, 2, 1])
console.log(mySet)  // {'a', 'b', 1, 2}
myset.add('c').add({'a': 1})
console.log(mySet) // {'a', 'b', 1, 2, 'c', {a: 1}}
console.log(mySet.size) // 6

mySet.has(2) // true

1. 遍历方法

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

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

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

因为Set结构没有键名，只有键值（或者说键名和键值是同一个值），因此keys方法和values方法的行为彻底一致。

const set = new Set(['a', 'b', 'c'])

for (let item of set.keys()) {
  console.log(item)
}
// a
// b
// c

for (let item of set.values()) {
  console.log(item)
}
// a
// b
// c

for (let item of set.entries()) {
  console.log(item)
}
// ["a", "a"]
// ["b", "b"]
// ["c", "c"]

// 直接遍历set实例，等同于遍历set实例的values方法
for (let i of set) {
  console.log(i)
}
// a
// b
// c

set.forEach((value, key) => console.log(key + ' : ' + value))

// a: a
// b: b
// c: c

1. Set 对象做用

• 数组去重(利用扩展运算符)

const mySet = new Set([1, 2, 3, 4, 4])
[...mySet] // [1, 2, 3, 4]

• 合并两个set对象

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

• 交集

let a = new Set([1, 2, 3])
let b = new Set([4, 3, 2])
let intersect = new Set([...a].filter(x => b.has(x)))  // {2, 3} 利用数组的filter方法

• 差集

let a = new Set([1, 2, 3])
let b = new Set([4, 3, 2])
let difference = new Set([...a].filter(x => !b.has(x))) //  {1}