作者：米书林 参考文章：《菜鸟教程》、《 ECMAScript 6 入门》（阮一峰）
Map对象
Map对象简介
作用：Map对象用于保存键值对，它的键可以为任意类型的数据，常用于建立数据的映射关系。
Map对象和Object对象的对比
相同点：
-它们都是对象数据类型 -它们都是以键值对的形式存储数据
不同点：
-Object对象的键只能是字符串或Symbol，Map对象的键可以是任意数据类型(可以看作是值-值的关系) -Map 中的键值是有序的（FIFO 原则），而添加到Object对象中的键则不是 -Map 的键值对个数可以从 size 属性获取，而 Object 的键值对个数只能手动计算 -Object 都有自己的原型，原型链上的键名有可能和你自己在对象上的设置的键名产生冲突
Map 中的 key
key是字符串
用法： Map()是一个构造函数，需要用new来实例化，Map()构造函数貌似只能接收一个二维数组的参数null和undefined（至少目前遇到的是这样），其他类型参数会报错
// Map()可以接收一个二维数组，二维数组中取arr[][0]为key，arr[][2]为value，多余的数组元素会被忽略
let map = new Map([[1,20]]);
// Map(1) {1 => 20}
let map1 = new Map([[1,20,30]]);
// Map(1) {1 => 20}
// Map()可以接收null作为参数
let map2 = new Map(null); // Map(0) {}
// Map()可以接收undefined作为参数
let map3 = new Map(undefined); // Map(0) {}
注意：null和undefined作为参数时相当于不传参数，即直接new Map()
let smap = new Map();
// set设置Map值
smap.set("one",1);
// get获取Map键对应的值
smap.get("one");
应用场景：
1.处理英文缩写和汉语对应关系，下面以星期为例
function eToC(str){
// 实例化一个Map
let wmap = new Map();
// 使用实例化的Map存储具有对应关系的数据
wmap.set("Mon","星期一");
wmap.set("Tue","星期二");
wmap.set("Wed","星期三");
wmap.set("Thur","星期四");
wmap.set("Fri","星期五");
wmap.set("Sat","星期六");
wmap.set("Sun","星期日");
// 根据查询字符串，返回对应数据
return wmap.get(str);
}
// 直接调用
eToC("Thur"); // "星期四"
// 获取当前时间后调用
let nowDate = (new Date()).toString();
let end = nowDate.indexOf(" ");
let week = nowDate.slice(0,end);
eToC(week); // "星期三"
上面的方法来获取星期显然很笨拙，因为我们需要处理字符串，实际上我们可以通过getDay()获取到一个0~6的数字，然后再通过Map来对应，具体方法见key为数字小节。
2.模拟简单的自动回复机器人
因为对话机器人我们不需要作特别复杂的逻辑处理，以为都是使用判断添加来处理，但现在来看，好像Map结构数据更适合，我们还是直接来看代码吧。
// 呆板机器人回复
function ack(str){
let ack_map = new Map();
ack_map.set("你好","你好啊！");
ack_map.set("今天天气真不错","是啊，很适合出门！");
ack_map.set("吃饭了没","还没呢，你呢？");
ack_map.set("吃啦","我还有点事，先走了，拜拜！！");
ack_map.set("没吃呢","那赶快去吃吧，我还有点事，先走了，拜拜！！");
// 能匹配到就返回
if(ack_map.get(str)) return ack_map.get(str);
// 匹配不到就返回一个提示
else return "对不起，你说的话我听不懂"
}
上面代码只要调用函数就能简单的返回一些数据了，当然啦，工作上的自动回复机器人这么笨是会被老板开除的，我们要做一个稍微复杂机器人是少不了正则匹配和数组的，这个可以自己去探究。
#####key是对象
var myMap = new Map();
var keyObj = {},
myMap.set(keyObj, "和键 keyObj 关联的值");
myMap.get(keyObj); // "和键 keyObj 关联的值"
myMap.get({}); // undefined, 因为 keyObj !== {}
key是函数
var myMap = new Map();
var keyFunc = function () {}, // 函数
myMap.set(keyFunc, "和键 keyFunc 关联的值");
myMap.get(keyFunc); // "和键 keyFunc 关联的值"
myMap.get(function() {}) // undefined, 因为 keyFunc !== function () {}
key 是 NaN
var myMap = new Map();
myMap.set(NaN, "not a number");
myMap.get(NaN); // "not a number"
var otherNaN = Number("foo");
myMap.get(otherNaN); // "not a number"
虽然 NaN 和任何值甚至和自己都不相等(NaN !== NaN 返回true)，NaN作为Map的键来说是没有区别的。 ####key 是 数组
let map = new Map([
['name', '张三'],
['age', 23],
]);
map.size // 2
map.has('name') // true
map.get('name') // "张三"
map.has('age') // true
map.get('age') // 23
Map的key可以是任何类型的值，包括正则等；
要点
1.Map的key可以为任意类型的值；
2.new一个Map就是新实例化了一个Map；
3.对同一个key值进行多次赋值，后面的会覆盖前面的；
4.未被set的Map关键字使用get方法会返回`undefined`;
5.Map 的键是跟内存地址绑定的，引用类型数据需要指向同一个地址才是同一个键；
6.原始数据类型，只要他们的值严格相等，Map 将其视为一个键；
7.NaN不严格相等于自身，但 Map 将其视为同一个键；
8.undefined和null是两个不同的键
// new一个Map就是新实例化了一个Map
let myMap1 = new Map();
let myMap2 = new Map();
myMap1 === myMap2 ; // false
// 对同一个key值进行多次赋值，后面的会覆盖前面的；
let myMap = new Map();
myMap.set("a", 'a')
myMap.get("a") // "a"
myMap.set("a", 'aa');
myMap.get("a") // "aa"
// 未被set的Map关键字使用get方法会返回undefined;
let myMap3 = new Map();
myMap3.get("b"); // undefined
// Map 的键是跟内存地址绑定的，引用类型数据需要指向同一个地址才是同一个键
let myMap4 = new Map();
myMap4 .set(['12'], 12);
myMap4 .get(['12']) // undefined
myMap4 .set({name:"abc"}, "abc");
myMap4 .get({name:"abc"}) // undefined
let obj = {name:"abc"}
myMap4 .set(obj , "abc");
myMap4 .get(obj) // "abc"
// 原始数据类型，只要他们的值严格相等，Map 将其视为一个键；
let map = new Map();
map.set(-0, 123);
map.get(+0) // 123
map.set(true, 1);
map.set('true', 2);
map.get(true) // 1
// undefined和null是两个不同的键
map.set(undefined, 3);
map.set(null, 4);
map.get(undefined) // 3
// NaN不严格相等于自身，但 Map 将其视为同一个键；
map.set(NaN, 123);
map.get(NaN) // 123
//
Map的常用方法
1.set()
set方法设置键名key对应的键值为value，然后返回整个 Map 结构。如果key已经有值，则键值会被更新，否则就新生成该键。
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
注意：set方法返回的是当前的Map对象，因此可以采用链式写法。
2.get()
get方法读取key对应的键值，如果找不到key，返回undefined。
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
myMap.get(90); // "优秀"
myMap.get(59); // undefined
3.has()
has方法判断某个键是否在当前 Map 对象之中，返回一个布尔值。
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
myMap.has(90); // true
myMap.has(30); // false
4.delete()
delete方法用于删除某个键，删除成功返回true，删除失败(不存在的键)返回false。
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
myMap.delete(90); // true
myMap.has(90); // false
myMap.delete(90); // false
5.clear()
clear方法清除所有成员
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
myMap.has(60); // true
myMap.clear();
myMap.has(60); // false
Map的属性
1.size
size属性返回 Map 结构的成员总数
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
myMap.size; // 4
Map的遍历(迭代)
for...of
Map 结构原生提供三个遍历器生成函数： -
Map.prototype.keys()：返回键名的遍历器。 -Map.prototype.values()：返回键值的遍历器。 -Map.prototype.entries()：返回所有成员的遍历器。
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
// 遍历myMap
for (var [key, value] of myMap) {
console.log(key + " = " + value);
}
// 结果：
// 60 = 及格
// 80 = 良
// 90 = 优秀
// 100 = 非常优秀
for (var [key, value] of myMap.entries()) {
console.log(key + " = " + value);
}
/* 这个 entries 方法返回一个新的 Iterator 对象，它按插入顺序包含了 Map 对象中每个元素的 [key, value] 数组。 */
// 结果：
// 60 = 及格
// 80 = 良
// 90 = 优秀
// 100 = 非常优秀
for (var key of myMap.keys()) {
console.log(key);
}
/* 这个 keys 方法返回一个新的 Iterator 对象， 它按插入顺序包含了 Map 对象中每个元素的键。 */
// 结果：
// 60
// 80
// 90
// 100
for (var value of myMap.values()) {
console.log(value);
}
/* 这个 values 方法返回一个新的 Iterator 对象，它按插入顺序包含了 Map 对象中每个元素的值。 */
// 结果：
// 及格
// 良
// 优秀
// 非常优秀
forEach()
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
myMap.forEach(function(value, key) {
console.log(key + " = " + value);
}, myMap)
// 执行结果
// 60 = 及格
// 80 = 良
// 90 = 优秀
//100 = 非常优秀
Map 结构的操作
1.Map 转为数组
Map结构可以通过扩展运算符(...)转为数组
let myMap = new Map()
.set(60, '及格')
.set(80, '良')
.set(90, '优秀')
.set(100, '非常优秀');
[...myMap]
// 返回：
[[60, "及格"],[80, "良"],[90, "优秀"],[100, "非常优秀"]]
返回的是一个二维数组，Map中的key和value被处理成数组的两个元素。
Map 的克隆
var myMap1 = new Map([["key1", "value1"], ["key2", "value2"]]);
var myMap2 = new Map(myMap1);
console.log(myMap1 === myMap2 );
// 打印 false。 Map 对象构造函数生成实例，迭代出新的对象。
Map 的合并
var myMap1 = new Map([[1, 'one'], [2, 'two'], [3, 'three'],]);
var myMap2 = new Map([[1, 'uno'], [2, 'dos']]);
// 合并两个 Map 对象时，如果有重复的键值，则后面的会覆盖前面的，对应值即 uno，dos， three
var myMap = new Map([...myMap1, ...myMap2]);
console.log(myMap);
// Map(3) {1 => "uno", 2 => "dos", 3 => "three"}
Set结构
Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。
Set要点
-Set允许存储任何类型的唯一值，但Set()不能接收Object、Boolean和NaN，使用add()方法可添加任意类型值； -向 Set 加入值的时候，不会发生类型转换，所以123和"123"是两个不同的值； -Set 内部使用“===”来判断两个值是否相等，但是NaN是个特例 -引用类型得地址指向相同才是唯一值，Symbol得用变量存储才能被has()取到 -+0 与 -0 在存储判断唯一性的时候是恒等的，所以不重复； -undefined 与 undefined 是恒等的，所以不重复； -Set 结构的键名就是键值
基本用法：
Set()是一个构造函数，需要用new来实例化，Set()构造函数可以接收一个具有 iterable 接口的其他数据结构（如数组，Map和Set结构等数据），其他类型会报错
// Set()可以接收一个数组参数
let set1 = new Set([1]);
// Set()可以接收一个Map结构数据参数
let map = new Map([[1,"one"]])
let set2 = new Set(map);
// Set()可以接收一个Set结构数据参数
let set3 = new Set([1]);
let set4 = new Set(map);
// Set()可以接收一个字符串作为参数，相当于将字符串使用split()方法后再传入Set()
let set10 = new Set("abc");
// Set(3) {"a", "b", "c"}
// Set()可以接收一个null作为参数
let set5 = new Set(null); // Set(0) {}
// Set()可以接收一个undefined作为参数
let set6 = new Set(undefined); // // Set(0) {}
// Set()不能接收一个NaN作为参数
let set7 = new Set(NaN);
// Uncaught TypeError: number NaN is not iterable
// Set()不能接收一个Object作为参数
let set8 = new Set({});
// Uncaught TypeError: object is not iterable
// Set()不能接收一个Bollean作为参数
let set9 = new Set(true);
// Uncaught TypeError: boolean true is not iterable
注意：null和undefined作为参数时相当于不传参数，即直接new Set()
Set的属性
Set.prototype.constructor：构造函数，默认就是Set函数。
Set.prototype.size：返回Set实例的成员总数。
let set = new Set([1,2,3,4]);
set.constructor; // ƒ Set() { [native code] }
set.size; // 4
Set的方法
Set.prototype.add(value)：添加某个值，返回 Set 结构本身。
Set.prototype.delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
Set.prototype.has(value)：返回一个布尔值，表示该值是否为Set的成员。
Set.prototype.clear()：清除所有成员，没有返回值。
let set1 = new Set();
// set的add方法可以添加任何类型的数据
// 添加数字
set1.add(1);
// 添加字符串
set1.add("abc");
// 添加布尔值true
set1.add(true);
// 添加布尔值false
set1.add("abc");
// 添加null
set1.add(null);
// 添加undefined
set1.add(undefined);
// 添加NaN
set1.add(NaN);
// 添加数组
set1.add([1,2,3]);
// 添加对象
set1.add({name:"张三"})
// 添加Symbol数据
set1.add(Symbol("123"));
// 添加Map数据
set1.add(new Map([[1,"one"]]));
// 添加Set数据
set1.add(new Set([1]));
// 添加函数
set1.add(function add(){});
console.log(set1);
// 结果为：Set(12) {1, "abc", true, null, undefined, …}
// has()检测是否含有某个Set成员
set1.has(1); // true
set1.has(NaN); // true NaN不严格相等，但是在Set中它是一个唯一值，即能直接用NaN检索到
set1.has(Symbol("123")); // false
// Symbol类型得通过变量定义才能被检测到
// delete()删除某个Set成员
set1.delete(NaN);
set1.has(NaN); // false
set1.has(undefined); // true
set1.clear();
set1.has(undefined); // false
Set的遍历(迭代)
for...of
Set结构原生提供三个遍历器生成函数： -Set.prototype.keys()：返回键名的遍历器。 -Set.prototype.values()：返回键值的遍历器。 -Set.prototype.entries()：返回所有成员的遍历器。
let set = new Set(['red', 123, true,null]);
for (let item of set.keys()) {
console.log(item);
}
// red
// 123
// true
// null
for (let item of set.values()) {
console.log(item);
}
// red
// 123
// true
// null
for (let item of set.entries()) {
console.log(item);
}
// ["red", "red"]
// [123, 123]
// [true, true]
// [null, null]
set.entries()方法返回的遍历器，同时包括键名和键值，所以每次输出一个数组，它的两个成员完全相等。
Set 结构的实例默认可遍历，它的默认遍历器生成函数就是它的values方法，因此可以省略values方法，直接用for...of循环遍历 Set。
let set = new Set(['red', 123, true,null]);
for (let item of set) {
console.log(item);
}
// red
// 123
// true
// null
forEach()
let set = new Set(['red', 123, true,null]);
set.forEach((value, key) => console.log(key + ' : ' + value))
// red : red
// 123 : 123
// true : true
// null : null
Set的应用场景
数组去重
let arr = [1,1,2,3,3,2,4,5,4];
let set = new Set(arr);
console.log(arr); // [1,1,2,3,3,2,4,5,4]
arr = [...set];
console.log(arr); // [1, 2, 3, 4, 5]
字符串去重
let str= "aabbccddab";
let set = new Set(str);
console.log(str); // "aabbccddab"
str= [...set].join("");
console.log(str);
// "abcd"
求数组并集
let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);
let set= new Set([...a, ...b]);
let union = [...set];
console.log(union); // [1, 2, 3, 4]
求数组交集
let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);
let set= new Set([...a].filter(x => b.has(x)));
let intersect = [...set];
console.log(intersect ); // [ 2, 3]
求数组差集
let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);
// 方法一：先求并集、交集
// 先求出并集
let set = new Set([...a, ...b]);
// 再求出交集
let set1= new Set([...a].filter(x => b.has(x)));
// 再利用并集求差集
let set2 = new Set([...set].filter(x => !set1.has(x)));
let difference = [...set2];
console.log(difference); // [1, 4]
// 方法二：分别求差集，再求并集
let set3=new Set([...[...a].filter(x => !b.has(x)),...[...b].filter(x => !a.has(x))]);
let difference1 = [...set3] // [1, 4]
工作中，若交集、并集都需要求，那适合用第一种方法，若只需要差集，那可以用第二种方式。
