ES6 新增 Map 是一组健值对。具有极快的查找速度 函数、对象、基本类型都可以作为键或值。** **解决了对象中只能使用 String 和 Symbol 作为键的问题 可以理解为加强型的对象

* Map 中的元素是有序的，拥有数字索引（类似数组）。每个索引对应的值是对象，该对象拥有两个属性：key 和 value
**

声明定义

new Map(array)

传递的数组是一个二维数组，二维数组中每个数组只有前两位有效，分别代表键和值*

**params** { array } array 二维数组 **return** { Map }

var map = new Map(
    [
      ["name", "zhangsan"],
    ["age", 18]
  ]
)
console.log(map);    // Map { "name" => "zhangsan", "age" => 18 }

元素管理

map.size

**_desc_** 获取数量 **params** { Map } map **return** { number }

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18],
  ["sex", "male"]
]);
console.log(map.size);    // 3

map.set(key, value)

* 支持链式操作

**_desc_** 添加元素 **params** { Map } map **params** { any } key 键 **params** { any } value 值 **return** { Map } 执行添加操作后的 Map

var map = new Map();
console.log(map);    // Map(0) {}
map.set("name", "zhangsan").set({ key: 0 }, 18)
console.log(map);    // Map { "name" => "zhangsan", { key: 0 } => 18 }

map.get(key)**

**_desc_** 获取值 **params** { Map } map **params** { any } key 键 **return**_ { any } 根据键获取的值

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18],
  ["sex", "male"]
]);
console.log(map.get("name"));    // "zhangsan"

map.delete(key)**

**_desc_** 删除元素 **params** { Map } map **params** { any } key 键 **return**_ { boolean }

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18],
  ["sex", "male"]
]);
map.delete("name");
console.log(map);    // Map { "age" => 18, "sex" => "male" }

map.clear()**

**_desc_** 清空 Map 中所有元素 **params** { Map } map **return**_ { void }

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18],
  ["sex", "male"]
]);
map.clear();
console.log(map);    // Map(0) {}

map.has(key)**

**_desc_** 检测元素是否存在 **params** { Map } map **params** { any } key 键 **return**_ { boolean }

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18],
  ["sex", "male"]
]);
var bool = map.has("name");
console.log(bool);    // true

迭代器

map.keys()

**params** { Map } map **return**_ { MapIterator } 键组成的 Map 迭代对象

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18]
]);
console.log(map.keys());    // MapIterator { "name", "age" }

map.values()

**params** { Map } map **return**_ { MapIterator } 值组成的 Map 迭代对象

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18]
]);
console.log(map.values());    // MapIterator { "zhangsan", 18 }

map.entries()

**params** { Map } map **return**_ { MapIterator } 键和值组成的 Map 迭代对象

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18]
]);
console.log(map.entries());    // MapIterator { "name" => "zhangsan", "age" => 18 }

数组转换

* Map 类型转换为数组类型

展开运算符

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18]
]);
console.log([...map]);                        // [["name", "zhangsan"], ["age", 18]]
console.log([...map.keys()]);            // ["name", "age"]
console.log([...map.values()]);        // ["zhangsan", 18]
console.log([...map.entries()]);    // [["name", "zhangsan"], ["age", 18]]

Array.from

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18]
]);
console.log(Array.from(map));                            // [["name", "zhangsan"], ["age", 18]]
console.log(Array.from(map.keys()));            // ["name", "age"]
console.log(Array.from(map.values()));        // ["zhangsan", 18]
console.log(Array.from(map.entries()));        // [["name", "zhangsan"], ["age", 18]]

循环遍历

for of

* 先通过迭代器操作，获取 Map 迭代对象，再进行循环遍历操作

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18]
]);
for(let key of map.keys()) {
    console.log(key);        // "name" --->  "key"
}
for(let value of map.values()) {
    console.log(value);    // "zhangsan" ---> 18
}

forEach

* 直接对 Map 操作，可以获取 Map 的键和值

var map = new Map([
    ["name", "zhangsan"],
  ["age", 18]
]);
map.forEach((value, key) => {
    console.log(`${key}=>${value}`);    // "name=>zhangsan" ---> "age=>18"
})

WeakMap**

WeakMap 是一种特殊的 Map

* 键名必须是对象，否则报错：Invalid value used as weak map key
* WeakMap 的键名是弱引用，健值是正常引用
* 垃圾回收不考虑 WeakMap 的键名，不会改变引用计数器，键在其他地方不被引用时即删除
* 因为 WeakMap 是弱引用，不可以进行 forEach 等遍历操作
*因为 WeakMap 是弱引用，WeakMap 没有迭代器方法和 size 属性
* 当键的外部引用删除时，需要自动删除数据时使用 WeakMap**

什么是弱引用？ 如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存 弱引用的对象不可遍历！

new WeakMap(array)

* 传递的数组是一个二维数组，二维数组中每个数组只有前两位有效，分别代表键和值

**_desc_** WeakMap 声明定义 **params** { array } array 二维数组 **return** { WeakMap }

var weakMap = new WeakMap([
    [{ key: "name" }, "zhangsan"],
  [{ key: "age" }, 18]
]);
console.log(weakMap);    // WeakMap {{...} => 18, {...} => "zhangsan"}