Map

JavaScript的对象（Object），本质上是键值对的集合（Hash结构），但是传统上只能用字符串当做键。这给它的使用带来了很大的限制。
为解决这个问题，ES6提供了Map数据结构，它类似于对象，也是键值对的集合。但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当做键。

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

    m.set(o, 'content');//使用set方法，将对象o作为m的一个键
    //使用get方法读取
    console.log(m.get(o)); //content  
    console.log(m.has(o)); //true
    //使用delete方法删除
    m.delete(o);
    console.log(m.has(o)); //false

作为构造函数，Map也可以接受一个数组作为参数，该数组的成员是一个个表示键值对的数组

    const map = new Map([
        ['name', 'Mr Wang'],
        ['title', 'Author']
    ])

    console.log(map.size); //2 
    console.log(map.has('name')); // true
    console.log(map.get('name')); // Mr Wang
    console.log(map.has('title')); // true
    console.log(map.get('title')); // Author

Map构造函数接受数组作为参数，实际上是执行下面的操作

    const items = [
        ['name', 'Mr Wang'],
        ['title', 'Author']
    ]
    const map = new Map()
    items.forEach(
        ([key, value]) => map.set(key, value)
    )

注意：如果对一个键多次赋值，后面的值将覆盖前面的值

实例的属性和操作方法

• size属性

size属性返回Map结构的成员总数

    const map = new Map();
    map.set('one', 1);
    map.set('two', 2);

    console.log(map.size); // 2

-set(key,value)

set方法设置键名key对应值为value，然后返回整个Map结构，如果key已经有值，则键值会被更新，否则生成该键

    const map = new Map();
    map.set('one', 1);
    map.set('one', '一');
    map.set(2, 'two');
    map.set(undefined, true);

    console.log(map.get(undefined)); // true
    console.log(map.get(2)); // two
    console.log(map.get('one')); // 一

set方法返回的是当前的Map对象，因此可以采用链式写法

    let map = new Map().set(1, 'a').set(2, 'b').set(3, 'c')

• get(key)

get方法读取key对应的键值，如果找不到，返回undefined

    const map = new Map();

    const hello = function() { console.log('Hello') }
    map.set(hello, 'Hello Mr'); // 键是函数

    console.log(map.get(hello)); //Hello Mr

• has(key)

has方法返回一个布尔值，表示某个键是否在当前Map对象之中

    const map = new Map();
    map.set('one', 1);
    map.set(2, 'two');
    map.set(undefined, true);

    console.log(map.has(2)); //true
    console.log(map.has(undefined)); //true
    console.log(map.has("name")); //false

delete(key)
delete方法删除某个键，返回true，如果删除失败，返回false

    const map = new Map();
    map.set('one', 1);

    console.log(map.has('one')); //true
    console.log(map.delete('one')); //true
    console.log(map.has('one')); //false

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

    const map = new Map();
    map.set('one', 1);
    map.set(2, 'two');
    map.set(undefined, true);
    console.log(map.size); //3
    map.clear()
    console.log(map.has('one')); //false
    console.log(map.size); //0

遍历方法与Set结构的数据大同小异，唯一需要注意的是Map的遍历顺序就是插入顺序

    const map = new Map([
        ['F', 'no'],
        ['T',  'yes'],
    ]);
    
    for (let key of map.keys()) {
        console.log(key);
    }
    // "F"
    // "T"
    
    for (let value of map.values()) {
        console.log(value);
    }
    // "no"
    // "yes"
    
    for (let item of map.entries()) {
        console.log(item[0], item[1]);
    }
    // "F" "no"
    // "T" "yes"
    
    // 或者
    for (let [key, value] of map.entries()) {
        console.log(key, value);
    }
    // "F" "no"
    // "T" "yes"
    
    // 等同于使用map.entries()
    for (let [key, value] of map) {
        console.log(key, value);
    }
    // "F" "no"
    // "T" "yes"

Map结构转为数组结构，比较快速的方法是使用拓展运算符(...)

    const map = new Map([
        [1, 'one'],
        [2, 'two'],
        [3, 'three'],
    ]);
    
    [...map.keys()]
    // [1, 2, 3]
    
    [...map.values()]
    // ['one', 'two', 'three']
    
    [...map.entries()]
    // [[1,'one'], [2, 'two'], [3, 'three']]
    
    [...map]
    // [[1,'one'], [2, 'two'], [3, 'three']]