JavaScript 标准之Map对象的用法
定义
Map 对象保存键值对,并且能够记住键的原始插入顺序。任何值(对象或者原始值) 都可以作为一个键或一个值。
构造函数
new Map([iterable])
iterable
Iterable 可以是一个数组或者其他 iterable 对象,其元素为键值对(两个元素的数组,例如: [[ 1, ‘one’ ],[ 2, ‘two’ ]])。 每个键值对都会添加到新的 Map。null 会被当做 undefined。
let myMap = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three'],
])
属性
*Map.length
属性 length 的值为 0 。
想要计算一个Map 中的条目数量, 使用 Map.prototype.size.
get Map[@@species]
本构造函数用于创建派生对象。
Map.prototype
表示 Map 构造器的原型。 允许添加属性从而应用于所有的 Map 对象。
与object对象相比
Objects 和 Maps 类似的是,它们都允许你按键存取一个值、删除键、检测一个键是否绑定了值。因此(并且也没有其他内建的替代方式了)过去我们一直都把对象当成 Maps 使用。不过 Maps 和 Objects 有一些重要的区别,在下列情况里使用 Map 会是更好的选择:
· | Map | Object |
---|---|---|
键的类型 | 一个 Map的键可以是任意值,包括函数、对象或任意基本类型。 | 一个Object 的键必须是一个 String 或是Symbol。 |
键的顺序 | Map 中的 key 是有序的。因此,当迭代的时候,一个 Map 对象以插入的顺序返回键值。 | 一个 Object 的键是无序的 |
Size | Map 的键值对个数可以轻易地通过size 属性获取 | Object 的键值对个数只能手动计算 |
迭代 | Map 是 iterable 的,所以可以直接被迭代。 | 迭代一个Object需要以某种方式获取它的键然后才能迭代。 |
性能 | 在频繁增删键值对的场景下表现更好。 | 在频繁添加和删除键值对的场景下未作出优化。 |
方法
map.clear()
clear()方法会移除Map对象中的所有元素。
const map1 = new Map();
map1.set('bar', 'baz');
map1.set(1, 'foo');
console.log(map1.size);
// expected output: 2
map1.clear();
console.log(map1.size);
// expected output: 0
Map.delete(key)
delete() 方法用于移除 Map 对象中指定的元素。
const map1 = new Map();
map1.set('bar', 'foo');
console.log(map1.delete('bar'));
// expected result: true
// (true indicates successful removal)
console.log(map1.has('bar'));
// expected result: false
Map.has (key)
方法has() 返回一个bool值,用来表明map 中是否存在指定元素
var myMap = new Map();
myMap.set("bar", "foo");
myMap.has("bar"); // returns true
myMap.has("baz"); // returns false
Map.entries()
entries() 方法返回一个新的包含 [key, value] 对的 Iterator 对象,返回的迭代器的迭代顺序与 Map 对象的插入顺序相同。
const map1 = new Map();
map1.set('0', 'foo');
map1.set(1, 'bar');
const iterator1 = map1.entries();
console.log(iterator1.next().value);
// expected output: ["0", "foo"]
console.log(iterator1.next().value);
// expected output: [1, "bar"]
Map.set(key, value)
set() 方法为 Map 对象添加或更新一个指定了键(key)和值(value)的(新)键值对。
const map1 = new Map();
map1.set('bar', 'foo');
console.log(map1.get('bar'));
// expected output: "foo"
console.log(map1.get('baz'));
// expected output: undefined
Map.get(key)
get() 方法返回某个 Map 对象中的一个指定元素。
这里需要注意的是,如果查找时键名为引用类型,如对象、数组,需要来自同一个内存地址,也就是说如果查找一个对象为键名的键值对,直接get({a:1})这样看起来一样的键名,实则是不同的引用地址,会报错。
例:如果需要查找某一个键是一个对象的值时,可以考虑用forEach进行循环,将对象字符化,就可以查找到。我是这样做的:
statusMap.forEach((value,key)=>{
if(JSON.stringify(key) == JSON.stringify({a:1})){
return value //
此时就可以找到这个键值对了
}
const map1 = new Map();
map1.set('bar', 'foo');
console.log(map1.get('bar'));
// expected output: "foo"
console.log(map1.get('baz'));
// expected output: undefined
Map.keys()
keys() 返回一个引用的 Iterator 对象。它包含按照顺序插入 Map 对象中每个元素的key值
const map1 = new Map();
map1.set('0', 'foo');
map1.set(1, 'bar');
const iterator1 = map1.keys();
console.log(iterator1.next().value);
// expected output: "0"
console.log(iterator1.next().value);
// expected output: 1
Map.values()
values()方法返回一个新的Iterator对象。它包含按顺序插入Map对象中每个元素的value值。
var myMap = new Map();
myMap.set("0", "foo");
myMap.set(1, "bar");
myMap.set({}, "baz");
var mapIter = myMap.values();
console.log(mapIter.next().value); // "foo"
console.log(mapIter.next().value); // "bar"
console.log(mapIter.next().value); // "baz"
Map.forEach()
forEach() 方法按照插入顺序依次对 Map 中每个键/值对执行一次给定的函数
参数
value 可选 每个迭代的值。
key 可选 每个迭代的键。
map 可选 被迭代的map(上文语法框中的 myMap)。
thisArg 可选 在 callback 执行中使用的 this 的值。
function logMapElements(value, key, map) {
console.log(`m[${key}] = ${value}`);
}
new Map([['foo', 3], ['bar', {}], ['baz', undefined]])
.forEach(logMapElements);
// expected output: "m[foo] = 3"
// expected output: "m[bar] = [object Object]"
// expected output: "m[baz] = undefined"
Map[@@iterator]()
返回一个新的Iterator对象,它按插入顺序包含了Map对象中每个元素的 [key, value] 数组。
const map1 = new Map();
map1.set('0', 'foo');
map1.set(1, 'bar');
const iterator1 = map1[Symbol.iterator]();
for (const item of iterator1) {
console.log(item);
}
// expected output: Array ["0", "foo"]
// expected output: Array [1, "bar"]
使用for…of迭代Map对象
let myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (let [key, value] of myMap) {
console.log(key + " = " + value);
}
// 将会显示两个log。一个是"0 = zero"另一个是"1 = one"
for (let key of myMap.keys()) {
console.log(key);
}
// 将会显示两个log。 一个是 "0" 另一个是 "1"
for (let value of myMap.values()) {
console.log(value);
}
// 将会显示两个log。 一个是 "zero" 另一个是 "one"
for (let [key, value] of myMap.entries()) {
console.log(key + " = " + value);
}
// 将会显示两个log。 一个是 "0 = zero" 另一个是 "1 = one"
Map 与数组的关系
1、使用常规的Map构造函数可以将一个二维键值对数组转换成一个Map对象
let kvArray = [["key1", "value1"], ["key2", "value2"]];
let myMap = new Map(kvArray);
2、使用Array.from函数可以将一个Map对象转换成一个二维键值对数组
console.log(Array.from(myMap));
更简洁的方法是用扩展运算符
console.log([...myMap]);
3、在key()或者value()上使用Array.from
console.log(Array.from(myMap.keys())); // 输出 ["key1", "key2"]
复制、合并Map对象
复制
复制后不是同一个引用地址
let myMap2 = new Map([[1, 'one']])
console.log(clone.get(1)); // one
console.log(original === clone); // false. 浅比较 不为同一个对象的引用
合并
Map对象间可以进行合并,但是会保持键的唯一性。
let first = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three'],
]);
let second = new Map([
[1, 'uno'],
[2, 'dos']
]);
// 合并两个Map对象时,如果有重复的键值,则后面的会覆盖前面的。
// 展开运算符本质上是将Map对象转换成数组。
let merged = new Map([...first, ...second]);
console.log(merged.get(1)); // uno
console.log(merged.get(2)); // dos
console.log(merged.get(3)); // three
Map对象也能与数组合并:
let first = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three'],
]);
let second = new Map([
[1, 'uno'],
[2, 'dos']
]);
// Map对象同数组进行合并时,如果有重复的键值,则后面的会覆盖前面的。
let merged = new Map([...first, ...second, [1, 'eins']]);
console.log(merged.get(1)); // eins
console.log(merged.get(2)); // dos
console.log(merged.get(3)); // three
小结
Map对象实际上并不常用,对于我来说最特殊的地方就是能够以对象、数组等数据类型作为键名,相比于对象作为对象容器,提供了更多的多样性,所有掌握这个对象的基本用法还是有帮助的。