JavaScript一种新的数据结构类型Map

什么是map

它类似于目标，是键值对的集合，
但键的范围不限制在于字符串。各种类型的值（包括目标）都能够作为键。
假如同一个键被多次赋值，后面的值将会掩盖其那面的值。
假如读取一个不知道的键，回来的是undefined.
具有极快的查找速度,它的查找的方法比遍历的方法更加的块。
创立map的时候需求：1.初始化Map需求一个二维数 2.或者直接初始化一个空Map。
经过map能够快速获取某个键的值【场景运用】
它的常见办法 set()增加  get()获取值 delete()删去值
has()判别是否有某个值 clear()办法铲除一切成员，没有回来值。

场景描绘 [项目中能够运用]

假如咱们咱们想要获取某个人的成果, 必需求经过遍历的方法去获取成果。
并且Array越长，耗时越长。
可是假如运用map就不需求了。只需求一个“姓名”-“成果”的对照表，
let arr = [{
    name: '张三',
    grade: 100
}, {
    name: '李四',
    grade: 100
}, {
    name: '王五',
    grade: 100
}]
//这个是map
var m = new Map([
    ['张三', 100],
    ['李四', 97],
    ['王五', 85]
]);
let chengjizs = m.get('张三');
console.log('成果是', chengjizs)

如何快速获取后端回来来的某值

//假设后端回来来了许多数据，咱们需求获取某一个值。
//能够先将数据转为map类型的数据结构 [[key:value]] 一个二维数组
//然后经过 数据源.get(key) 的方法获取值
let backArr = [{
    name: '张三',
    grade: 100
}, {
    name: '李四',
    grade: 100
}, {
    name: '王五',
    grade: 100
}]
let newArr = []
backArr.forEach(item => {
    newArr.push([item.name, item.grade])
})
// Map的参数格局是[[key:value],[key:value]]这样才能够经过get办法来获取对应的value
let arrMap = new Map(newArr)
console.log(arrMap.get('张三'))

创立Map以及Map的常见办法

// 初始化Map需求一个二维数组， 或者直接初始化一个空Map。
var m = new Map(); // 这个是一个空Map
console.log(m.set('Aa', 67)); // 增加新的key-value
console.log(m.has('Aa')); // 是否存在key 'Aa'输出的值是：true
console.log(m.get('Aa')); // 获取Aa的67
console.log(m.delete('Aa')); // 删去key 'Aa'
console.log(m.get('Adam')); // 读取不知道的值 undefined
console.log(m.clear()); //铲除一切值
set()增加  get()获取值 delete()删去值 has()判别是否有某个值

获取map目标中一切的key值，并且把它转为为一个数组

var m = new Map([
    ['张三', 100],
    ['李四', 97],
    ['王五', 85]
]);
let keysName = m.keys(); //回来的一切key值，但却不是一个数组
console.log(Array.from(keysName)) //转为为一个数组

Map 结构原生提供三个遍历器生成函数和一个遍历办法。

Map.prototype.keys()：回来map的一切键名。
Map.prototype.values()：回来map的一切键值。
Map.prototype.entries()：回来map的一切成员。
Map.prototype.forEach()：遍历Map的一切成员。

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

 const map = new Map([    [1, 'one'],
    [2, 'two'],
    [3, 'three'],
]);
let keyArr = [...map.keys()]
console.log(keyArr) //[1, 2, 3]
let contArr = [...map.values()]
console.log(contArr) //['one', 'two', 'three']
let arr1 = [...map.entries()]
console.log(arr1)
// [[1,'one'], [2, 'two'], [3, 'three']]
let arr2 = [...map]
console.log(arr2)
// [[1,'one'], [2, 'two'], [3, 'three']]

Map 转为目标

假如一切 Map 的键都是字符串，它能够无损地转为目标。
function strMapToObj(strMap) {
    let obj = Object.create(null);
    for (let [k, v] of strMap) {
        obj[k] = v;
    }
    return obj;
}
const myMap = new Map([
    ['grade1', 100],
    ['grade2', 97],
    ['grade3', 85]
])
console.log(strMapToObj(myMap)) 

目标转为 Map 能够经过Object.entries()

let obj = {
    "age": 12,
    "name": '张三'
};
let map = new Map(Object.entries(obj));
console.log('map', map)
或者 咱们自己写一个办法
function objToStrMap(obj) {
    let strMap = new Map();
    for (let k of Object.keys(obj)) {
        strMap.set(k, obj[k]);
    }
    return strMap;
}
let newMap=objToStrMap({
    yes: true,
    no: false
})
console.log(newMap)

经过forEach循环map中的每一个值，以及key值

var m = new Map([
    ['张三', 100],
    ['李四', 97],
    ['王五', 85]
]);
m.forEach(function(value,index) {　　
    console.log("value", value,index); //100 张三 这种
})

map.values() 遍历map的values

let map = new Map([
    [1, '张三'],
    [2, "李四"],
    [3, "王五"]
])
let values = map.values();
for (i = 0; i < map.size; i++) {
    value = values.next().value;
    console.log(value); //  张三 李四 王五
}