1.Object 结构提供了“字符串—值”的对应,Map 结构提供了“值—值”的对应
const m = new Map();
const o = {p: 'hello'};
m.set(o,'content');
m.get(o); //"content"
m.has(o); //true
m.delete(o); //true(表示删除成功)
m.has(o); //false
2.作为构造函数,Map 可以接受一个数组作为参数。该数组的成员是一个个表示键值对的数组。
不仅仅是数组,任何具有 Iterator 接口、且每个成员都是一个双元素的数组的数据结构都可以当作Map
构造函数的参数。
const map = new Map([
['name', '张三'],
['title', 'Author']
]);
map.size // 2
map.has('name') // true
map.get('name') // "张三"
map.has('title') // true
map.get('title') // "Author"
Map
构造函数接受数组作为参数,实际上执行的是下面的算法
const items = [
['name', '张三'],
['title', 'Author']
];
const map = new Map();
items.forEach(
([key, value]) => map.set(key, value)
);
下面分别使用 Set 对象和 Map 对象,当作Map
构造函数的参数,结果都生成了新的 Map 对象。
const set = new Set([
['foo', 1],
['bar', 2]
]);
const m1 = new Map(set);
m1.get('foo') // 1
const m2 = new Map([
['baz', 3]
]);
const m3 = new Map(m2);
m3.get('baz') // 3
对同一个键多次赋值,后面的值将覆盖前面的值。
const map = new Map();
map
.set(1, 'aaa')
.set(1, 'bbb');
map.get(1) // "bbb"
读取一个未知的键,则返回undefined
。
new Map().get('asfddfsasadf'); // undefined
只有对同一个对象的引用,Map 结构才将其视为同一个键。
const map = new Map();
map.set(['a'], 555);
map.get(['a']) // undefined
//表面是针对同一个键,但实际上这是两个值,内存地址是不一样的,
//因此get方法无法读取该键,返回undefined
const map = new Map();
const k1 = ['a'];
const k2 = ['a'];
map
.set(k1, 111);
.set(k2, 222);
map.get(k1) // 111
map.get(k2) // 222
小结:Map 的键实际上是跟内存地址绑定的,只要内存地址不一样,就视为两个键。
Map 的键是一个简单类型的值(数字、字符串、布尔值),则只要两个值严格相等,Map 将其视为一个键。
0
和-0
就是一个键,
布尔值true
和字符串true
则是两个不同的键。
undefined
和null
也是两个不同的键。
虽然NaN
不严格相等于自身,但 Map 将其视为同一个键。
let map = new Map();
map.set(-0, 123);
map.get(+0) // 123
map.set(true, 1);
map.set('true', 2);
map.get(true) // 1
map.set(undefined, 3);
map.set(null, 4);
map.get(undefined) // 3
map.set(NaN, 123);
map.get(NaN) // 123
3.属性、方法
size:返回 Map 结构的成员总数
set(key, value):设置键名key
对应的键值为value
,然后返回整个 Map 结构
get(key):读取key
对应的键值,如果找不到key
,返回undefined
has(key) : 返回一个布尔值,表示某个键是否在当前 Map 对象之中
delete(key) : 删除某个键,返回true
。如果删除失败,返回false
clear():清除所有成员,没有返回值
keys():返回键名的遍历器
values():返回键值的遍历器
entries():返回所有成员的遍历器
forEach():遍历 Map 的所有成员
例1:size 属性
const map = new Map();
map.set('foo', true);
map.set('bar', false);
map.size // 2
例2:set(key, value),返回的是当前的Map
对象,因此也可以采用链式写法
const m = new Map();
m.set('edition', 6) // 键是字符串
.set(262, 'standard') // 键是数值
.set(undefined, 'nah') // 键是 undefined
例3:get(key)
const m = new Map();
const hello = function() {console.log('hello');};
m.set(hello, 'Hello ES6!') // 键是函数
m.get(hello) // Hello ES6!
例4:has(key)
const m = new Map();
m.set('edition', 6);
m.set(262, 'standard');
m.set(undefined, 'nah');
m.has('edition') // true
m.has('years') // false
m.has(262) // true
m.has(undefined) // true
例5:delete(key)
const m = new Map();
m.set(undefined, 'nah');
m.has(undefined) // true
m.delete(undefined)
m.has(undefined) // false
例6:clear()
let map = new Map();
map.set('foo', true);
map.set('bar', false);
map.size // 2
map.clear()
map.size // 0
例7:遍历。
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"
for (let [key, value] of map) {
console.log(key, value);
}
// "F" "no"
// "T" "yes"
最后的例子,表示 Map 结构的默认遍历器接口(Symbol.iterator
属性),就是entries
方法。
map[Symbol.iterator] === map.entries
// true
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']]
结合数组的map
方法、filter
方法,可以实现 Map 的遍历和过滤
const map0 = new Map()
.set(1, 'a')
.set(2, 'b')
.set(3, 'c');
const map1 = new Map(
[...map0].filter(([k, v]) => k < 3)
);
// Map 结构 {1 => 'a', 2 => 'b'}
const map2 = new Map(
[...map0].map(([k, v]) => [k * 2, '_' + v])
);
// Map 结构 {2 => '_a', 4 => '_b', 6 => '_c'}
Map 还有一个forEach
方法,与数组的forEach
方法类似,也可以实现遍历
map.forEach(function(value, key, map) {
console.log("Key: %s, Value: %s", key, value);
});
forEach
方法还可以接受第二个参数,用来绑定this
const reporter = {
report: function(key, value) {
console.log("Key: %s, Value: %s", key, value);
}
};
map.forEach(function(value, key, map) {
this.report(key, value);
}, reporter);
4.Map与其它数据结构转换
例1:Map 转换数组
const map = new Map()
.set(true,7)
.set({foo:3},['abc']);
console.log([...map])
// [ [ true, 7 ], [ { foo: 3 }, [ 'abc' ] ] ]
例2:数组转换Map
new Map([
[true, 7],
[{foo: 3}, ['abc']]
])
//Map(2) {true => 7, {…} => Array(1)}
例3:Map 转换对象
function mapToObj(map) {
let obj = Object.create(null);
for (let [k,v] of map) {
obj[k] = v;
}
return obj;
}
const myMap = new Map()
.set('yes', true)
.set('no', false);
mapToObj(myMap)
// { yes: true, no: false }
例4: 对象转换Map
function objToMap(obj) {
let map = new Map();
for (let k of Object.keys(obj)) {
map.set(k, obj[k]);
}
return map;
}
objToMap({yes: true, no: false})
// Map {"yes" => true, "no" => false}
例5:Map 转换json
//1.键名都是字符串
function mapToObj(map) {
let obj = Object.create(null);
for (let [k,v] of map) {
obj[k] = v;
}
return obj;
}
function mapToJson(map) {
return JSON.stringify(mapToObj(map));
}
let myMap = new Map().set('yes', true).set('no', false);
mapToJson(myMap)
// '{"yes":true,"no":false}'
//2.键名有非字符串
function mapToArrayJson(map) {
return JSON.stringify([...map]);
}
let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
mapToArrayJson(myMap)
// '[[true,7],[{"foo":3},["abc"]]]'
例6:json转换Map
//1.键名都是字符串
function jsonToMap(jsonStr) {
return objToMap(JSON.parse(jsonStr));
}
jsonToMap('{"yes": true, "no": false}')
// Map {'yes' => true, 'no' => false}
//2.JSON 就是一个数组,且每个数组成员本身,又是一个有两个成员的数组
function jsonToMap(jsonStr) {
return new Map(JSON.parse(jsonStr));
}
jsonToMap('[[true,7],[{"foo":3},["abc"]]]')
// Map {true => 7, Object {foo: 3} => ['abc']}