TypeScript Map类型 详解

Objects 和 maps 的比较：

　　Object的键只能是字符串或者 Symbols，但 Map 的键可以是任意值，包括函数、对象、基本类 型。

　　Map 中的键值是有序的，而添加到 Object 对象中的键则不是。因此，当对它进行遍历时，Map 对象是按插入的顺序返回键值。

　　可以通过 size 属性直接获取一个 Map 的键值对个数，而 Object 的键值对个数只能手动计算。

　　Map 可直接进行迭代，而 Object 的迭代需要先获取它的键数组，然后再进行迭代。

　　Map 在涉及频繁增删键值对的场景下会有些性能优势。

Map 类型实例化语法：

new Map([iterable])
let map = new Map([['key1', 'value1'], ['key2', 'value2']]);

Map 类型实例属性与方法：

Map.prototype.size                              // 元素数量
Map.prototype.clear()                           // 移除Map对象的所有键/值对 。
Map.prototype.delete(key)                       // 如果 Map 对象中存在该元素，则移除它并返回 true；否则如果该元素不存在则返回 false
Map.prototype.entries()                         // 返回一个新的 Iterator 对象，它按插入顺序包含了Map对象中每个元素的[key, value] 数组。
Map.prototype.forEach(callbackFn[, thisArg])    // 按插入顺序，为 Map对象里的每一键值对调用一次callbackFn函数。
Map.prototype.get(key)                          // 返回键对应的值，如果不存在，则返回undefined。
Map.prototype.has(key)                          // 返回一个布尔值，表示Map实例是否包含键对应的值。
Map.prototype.keys()                            // 返回一个新的 Iterator对象， 它按插入顺序包含了Map对象中每个元素的键 。
Map.prototype.set(key, value)                   // 设置Map对象中键的值。返回该Map对象。
Map.prototype.values()                          // 返回一个新的Iterator对象，它按插入顺序包含了Map对象中每个元素的值 。

Map 实例：

let myMap = new Map();
let keyObj = {},
    keyFunc = function () { },
    keyString = "a string";
 
    // 添加键
myMap.set(keyString, "和键'a string'关联的值");
myMap.set(keyObj, "和键keyObj关联的值");
myMap.set(keyFunc, "和键keyFunc关联的值");
console.log(myMap.size);    // => 3
 
// 读取值
myMap.get(keyString);       // "和键'a string'关联的值"
myMap.get(keyObj);          // "和键keyObj关联的值"
myMap.get(keyFunc);         // "和键keyFunc关联的值"
myMap.get("a string");      // "和键'a string'关联的值",因为keyString === 'a string'
myMap.get({});              // undefined, 因为keyObj !== {}
myMap.get(function () { })  // undefined, 因为keyFunc !== function () {}

Map 类型迭代，举例：

let myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
 
// 将会输出两个log，一个是"0 = zero", 另一个是"1 = one"
for (let [key, value] of myMap) {
    console.log(key + " = " + value);
}
 
// 将会输出两个log， 一个是 "0" 另一个是 "1"
for (let key of myMap.keys()) {
    console.log(key);
}
 
// 将会输出两个log， 一个是 "zero" 另一个是 "one"
for (let value of myMap.values()) {
    console.log(value);
}
 
// 将会输出两个log, 一个是 "0 = zero" 另一个是 "1 = one"
for (let [key, value] of myMap.entries()) {
    console.log(key + " = " + value);
}
 
// 将会输出两个logs, 一个是 "0 = zero" 另一个是 "1 = one"
myMap.forEach(function (value, key) {
    console.log(key + " = " + value);
})

Map 类型与数组类型互转，举例：

var kvArray = [["key1", "value1"], ["key2", "value2"]];
// 使用常规的Map构造函数可以将一个二维键值对数组转换成一个Map对象
var myMap = new Map(kvArray);
console.log(myMap.get("key1"));             // => value1
 
// 使用Array.from函数可以将一个Map对象转换成一个二维键值对数组
console.log(Array.from(myMap));             // 输出和kvArray相同的数组
 
// 在键或者值的迭代器上使用Array.from，进而得到只含有键或者值的数组
console.log(Array.from(myMap.keys()));      // 输出 ["key1", "key2"]
console.log(Array.from(myMap.values()));    // 输出 ["value1", "value2"]

Map 对象间可以合并，有重复键值时，后面的会覆盖前面的；

var first = new Map([
    [1, 'one'],
    [2, 'two'],
    [3, 'three'],
]);
var second = new Map([
    [1, 'uno'],
    [2, 'dos']
]);
// 合并两个Map对象时，如果有重复的键值，则后面的会覆盖前面的。
// 展开运算符本质上是将Map对象转换成数组。
var merged = new Map([...first, ...second]);
console.log(merged.get(1)); // => uno
console.log(merged.get(2)); // => dos
console.log(merged.get(3)); // => three

 

转载至：https://www.cnblogs.com/JosephWong/p/13677699.html