Map()和Set()

Map()

Map存储key和对应的value。
特点：
1、Map是一组键值对的形式，具有极快的查找速度。
2、Map 对象保存键值对。任何值(对象或者原始值) 都可以作为一个键或一个值。Set类似于数组，而Map就类似于键值对（Key, Value）；
3、Map是键值对的形式，通过键可以取到对应的值，键名不能重复。
4、ES6 提供了 Map 数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。
6、通过展开运算符(…)可以把Map集合转换成包含多个数组的数组。

背景，举个例子，假设要根据同学的名字查找对应的成绩，如果用Array实现，需要两个Array,给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，Array越长，耗时越长。

var names = ['Michael', 'Bob', 'Tracy'];
var scores = [95, 75, 85];

解决方法：使用Map:只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用JavaScript写一个Map如下：

var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95

Map用法实例：

var myMap=new Map([["name","lisa"],["age",12],["color","red"]]);
console.log(myMap);//结果为Map(3) {"name" => "lisa", "age" => 12, "color" => "red"}

Map使用方法：

//初始化Map对象
var m = new Map();
//使用set添加键值
m.set('小红', 30);
m.set('小青', 90);
m.set('小芳', 23);
console.log(m); //打印结果：Map(3) {"小红" => 30, "小青" => 90, "小芳" => 23}
//使用has判断某个键是否存在
console.log(m.has('小花')); //打印结果：false
console.log(m.has('小青')); //打印结果：true
//使用delete可以删除某个键
m.delete('小青');
console.log(m); //打印结果：Map(2) {"小红" => 30, "小芳" => 23}
console.log(m.size);//打印结果2
//使用get可以获取某个键的值
console.log(m.get('小芳')); //23
m.clear();//清楚所有的元素

注：
由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉.

属性值说明：

var x=new Map();
x.set(‘a’,‘b’)添加键值
x.has(‘a’)判断是否存在某个键值,返回true或false
x.delete(‘a’)删除某个键
x.get(‘x’)获取键对应的值
x.size获取有多少个元素
x.clear()，注“括号中没有参数”，清楚x对象中的所有元素。
keys()：返回键名的遍历器。
values()：返回键值的遍历器。
entries()：返回所有成员的遍历器。
forEach()：遍历 Map 的所有成员。

实例：

let m = new Map([
    ['name', '小芬'],
    ['title', '今天吃了什么']
]);
console.log(m); //Map(2) {"name" => "小芬", "title" => "今天吃了什么"}
console.log(m.size); //2

上面代码在新建 Map 实例时，就指定了两个键name和title。
Map构造函数接受数组作为参数，实际上执行的是下面的算法。上面的代码使用forEach实现：

let item = [
    ['color', 'red'],
    ['name', 'polo']
]; //定义一个数组
let m = new Map(); //实例化一个Map对象
item.forEach(([x, y]) => m.set(x, y)); //使用forEach对Map对象进行遍历，使用set()方法把item中的元素添加到Map对象中
console.log(m); //Map(2) {"color" => "red", "name" => "polo"}

用法看下面实例：

let m = new Map([
    ['name', 'jack'],
    ['color', 'red'],
    ['title', 'today']
]);
//使用keys()方法获取键名
for (let i of m.keys()) {
    console.log(i);
}
//name
//color
//title
//使用values()获取键值
for (let r of m.values()) {
    console.log(r);
}
//jack
//red
//today
//使用entries()获取键值对
for (let n of m.entries()) {
    console.log(n[0], n[1]);
}
//name jack
//color red
//title today
// 上述可以等同于
for (let [x, y] of m.entries()) {
    console.log(x, y);
}
//name jack
//color red
//title today
//上述还可以这么写
for (let [a, b] of m) {
    console.log(a, b);
}
//name jack
//color red
//title today

Map 结构转为数组结构，比较快速的方法是使用扩展运算符（…）

let m=new Map([
    [1,'one'],
    [2,'two'],
    [3,'three'],
    [4,'four']
]);
var a=[...m];
console.log(a);//(4) [Array(2), Array(2), Array(2), Array(2)]
var b=[...m.keys()];
console.log(b);//[1, 2, 3, 4]
var c=[...m.values()];
console.log(c);//["one", "two", "three", "four"]
var d=[...m.entries()];
console.log(d);//(4) [Array(2), Array(2), Array(2), Array(2)]

Set()

1.是一组key的集合，但不存储value。
2.对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。Set中,key不能重复。如果出现重复的key，Set会自动过滤。Set没有索引，它的键和值是一个。
3.Set()是一个类似数组解构，但它不是数组。它本身就是一个构造函数。
4.它最主要的作用是去重。
5.可以使用Array.from()把它变成一个数组。
6、通过展开运算符(…)可以把Set集合转换成一个数组。

let set = new Set([1, 2, 3, 3, 3, 4, 5]),
array = [...set];
console.log(array); // [1,2,3,4,5]

用法如下例子：

const set1=new Set([1,2,2,4,3,4]);
console.log(set1);//结果为：{1, 2, 4, 3}

实例2：

//实例化一个Set对象
var s=new Set();
//Set对象通过add方法添加元素
s.add(3);
s.add('3');//注意3和'3'是不同的元素
s.add('apple');
console.log(s);//打印结果：Set(3) {3, "3", "apple"}
//使用delete可以删除元素
s.delete('apple');
console.log(s);//打印结果：Set(2) {3, "3"}
s.clear();//清除s对象中的所有元素。

属性说明：

var s=new Set();
s.add(‘a’);添加一个元素
s.delete(‘a’);删除一个元素
s.size;获取元素的数量
s.clear()清除对象中的所有元素。
s.has(‘a’)判断s对象中是否有某个元素，返回true或false

例子，可以使用多个add()连起来：

var s = new Set();
s.add(3).add('哈').add('apple');
console.log(s);//Set(3) {3, "哈", "apple"}

Set中的方法：
由于 Set 结构没有键名，只有键值（或者说键名和键值是同一个值），所以keys方法和values方法的行为完全一致。

var s = new Set(['red', 'blue', 'orange']);
//通过使用for...of去遍历s，然后通过keys()可以获取对象中的每个value
for (let item of s.keys()) {
    console.log(item);
}
//通过使用for...of去遍历s，然后通过values()可以获取对象中的每个value
for (let a of s.values()) {
    console.log(a);
}
//通过使用for...of去遍历s，然后通过entries()可以获取对象中的键和值
for (let b of s.entries()) {
    console.log(b);
}

打印结果：

注解：解释一下for…of :
for…of 语句创建一个循环来迭代可迭代的对象。for…of 允许你遍历 Arrays（数组）, Strings（字符串）, Maps（映射）, Sets（集合）等可迭代的数据结构等。

注解：entries() 的用法
entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。迭代对象中数组的索引值作为 key， 数组元素作为 value。
如下使用：

var a=['apple','orange','pear'];
for(let i of a.entries())
{
    console.log(i);
}

打印结果：

使用forEach()
Set结构的实例的forEach方法，用于对每个成员执行某种操作，没有返回值。

let s=new Set([1,4,6,2,3]);
s.forEach((x,y)=>console.log(x*2));

使用…扩展符可以把Set对象变成一个数组：
先看一个例子：

let a = new Set([1, 2, 3]);
let c = a;
console.log(c);//Set(3) {1, 2, 3}
let b = [...a];
console.log(b);//(3) [1, 2, 3]

let s = new Set(['red', 'yellow', 'blue']);
let arr = [...s];//arr变成了一个数组，['red', 'yellow', 'blue']
console.log(arr); //["red", "yellow", "blue"]
let a = [3, 4, 5, 3, 4, 2, 3];
let u = [...new Set(a)];
console.log(u); // [3, 4, 5, 2]

也可以使用map和filter对Set对象进行处理：
注：使用map和filter进行处理之前记得使用…把Set对象变成一个数组，再进行一系列操作。
代码如下：
使用map

let a=new Set([1,2,4,6,2]);
console.log(a);//Set(4) {1, 2, 4, 6}
let b=[...a].map(x=>x*2);//使用map进行处理
console.log(b);//(4) [2, 4, 8, 12]
let c=new Set(b);//把数组变成Set类型
console.log(c);//Set(4) {2, 4, 8, 12}

使用filter

let a = new Set([1, 2, 5, 6, 2]);
console.log(a); //Set(4) {1, 2, 5, 6}
let b = [...a].filter(x => (x % 2) == 0);
console.log(b); //(2) [2, 6]

使用 Set 可以很容易地实现并集（Union）、交集（Intersect）和差集（Difference）。

let a=new Set([1,3,3,4]);
let b=new Set([3,4,2]);
let u=new Set([...a,...b]);//获取并集
console.log(u);//Set(4) {1, 3, 4, 2}
let inter=new Set([...a].filter(x=>b.has(x)));//获取交集
console.log(inter);//Set(2) {3, 4}
let diff=new Set([...a].filter(x=>!b.has(x)));//获取差集
console.log(diff);//Set(1) {1}