ES6 学习笔记(十)Map的基本用法

发布于 2021-05-23  1,736 次阅读


1 基本用法

Map类型是键值对的有序列表,而键和值都可以是任意类型。可以看做Python中的字典(Dictionary)类型。

1.1 创建方法

Map本身是一个构造函数,用来生成Map实例,如:

let m1 = new Map()

1.2 初始化

Map构造函数可以接收一个数组作为参数,该数组的成员可以是一组表示键值对的数组。也可以是任何具有 Iterator 接口、且每个成员都是一个双元素的数组的数据结构。如:

let map = new Map([
    ['name', 'zhang'],
    ['title', 'Author']
])

1.3 常见方法

方法 描述
set(key, value) 用于设置(添加)键值对
get(key) 通过key获取对应值
delete(value) 删除值,返回一个布尔值,表示删除是否成功
has(value) 返回一个布尔值,表示该值是否是Set实例的成员
clear() 清除所有成员,没有返回值
size 返回成员个数

相同的key不能添加,现有的value会被替换成新的value值

let m = new Map()
let o = { p: 'Hello World' }
m.set(o, 'content')
console.log(m.size); // 1
console.log(m.get(o)); // content
console.log(m.has(o)); // true
console.log(m.delete(o)); // true
console.log(m.has(o)); // false
console.log(m.clear(o)); // undefind

let m2 = new Map()
let o2 = { p: 'Hello World' }
let o3 = { q: 'JavaScript' }
m2.set(o2, 'content')
m2.set(o3, 'content2')
console.log(m2.size); // 2
let map = new Map([
    ['name', 'zhang'],
    ['title', 'Author']
])
console.log(map.size); // 2
console.log(map.has('name')); // true
console.log(map.get('name')); // zhang
console.log(map.has('title'));// true
console.log(map.get('title'));// Author

1.4 需要注意的地方

1、只有对同一个对象的引用,Map才认为是同一个键。Map的键实际上是和内存地址绑定的,只要内存地址不一样,就是为两个键。

const mm = new Map()
mm.set(['a'], 5)
// 把数组对象的引用传进去了,两者并不相等
// 不要把对象直接传进去,不然拿不到
// ['a'] == ['a'] // false
console.log(mm.get(['a']));  // undefined

const k1 = {}
const k2 = {}
// 为了稳定key值保存的对象的引用保持不变,所以用const
mm.set(k1, 100)
mm.set(k2, 200)
console.log(mm.get(k1), mm.get(k2));// 100 200

2、如果Map的key是一个简单类型的值,如数值,字符串,布尔值。只要两个值严格相等,map就认为是同一个key。

const mm = new Map()
mm.set(-0, 123)
console.log(mm.get(+0)); // 123
console.log(mm.get(-0)); // 123

mm.set(true, 1)
// mm.set(true,111)
mm.set("true", 2)
console.log(mm.get(true)); // 1
console.log(mm.get("true")); // 2

mm.set(undefined, 3)
mm.set(undefined, 333)
mm.set(null, 4)
console.log(mm.get(undefined)); // 333
console.log(mm.get(null)); // 4

mm.set(NaN, 111)
console.log(mm.get(NaN)); // 111

2 其它方法

2.1 遍历方法

Map的遍历与Set类似,前三个是三个遍历器的生成函数,后面那个是遍历方法。

方法 描述
keys() 返回键名的遍历器
values() 返回键值的遍历器
entries() 返回键值对的遍历器
forEach() 使用回调函数遍历每个成员,没有返回值

Map 结构的默认遍历器接口(Symbol.iterator属性),就是entries方法

let m1 = new Map()
m1.set("a", 100).set("b", 200).set("c", 300)
console.log(m1);
console.log(m1.keys());
console.log(m1.values());
console.log(m1.entries());
console.log(Object.keys(m1));

输出结果:
Map(3) { 'a' => 100, 'b' => 200, 'c' => 300 }
[Map Iterator] { 'a', 'b', 'c' }
[Map Iterator] { 100, 200, 300 }
[Map Entries] { [ 'a', 100 ], [ 'b', 200 ], [ 'c', 300 ] }
[]

2.2 Map的map( )、filter( )的使用

与Set类似,Map也可以利用扩展运算符转换为数组,从而利用map( ),filter( )等方法,如:

const map0 = new Map().set(1, 'a').set(2, 'b').set(3, 'c')
console.log(map0);
const map1 = new Map([...map0].filter(([k, v]) => k < 3))
console.log(map1);
const map2 = new Map([...map0].map(([k, v]) => [k * 2, "_" + v]))
console.log(map2);

运行结果:
Map(3) { 1 => 'a', 2 => 'b', 3 => 'c' }
Map(2) { 1 => 'a', 2 => 'b' }
Map(3) { 2 => '_a', 4 => '_b', 6 => '_c' }

2.3 Map和其它数据结构的相互转换

2.3.1 Map转换为数组

function mapToArr(mymap) {
    const arr = [...mymap]
    return arr
}
const m1 = new Map().set('a', 1).set('b', 2).set('c', 3)
let arr = mapToArr(m1)
console.log(arr);

输出结果:
[ [ 'a', 1 ], [ 'b', 2 ], [ 'c', 3 ] ]

2.3.2 数组转换为Map

function arrToMap(arr) {
    const mymap= new Map(arr)
    return mymap
}
const arr = [["a", 1], ["b", 2], ["c", 3]]
const m1 = arrToMap(arr)
console.log(m1);

输出结果:
Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }

2.3.3 Map转换为对象

function mapToObj(mymap) {
    let obj = Object.create(null) // 创建一个没有原型对象的顶级对象
    for (let [k, v] of mymap) {
        obj[k] = v
    }
    return obj
}
const m1 = new Map()
m1.set('a', 1).set('b', 2).set('c', 3)
let obj = mapToObj(m1)
console.log(obj);

输出结果:
{ a: 1, b: 2, c: 3 }

如果Map的所有键都是字符串,才可以转换为对象

2.3.4 对象转换为Map

function objToMap(obj) {
    let mymap = new Map();
    for (let k of Object.keys(obj)) {
        mymap.set(k, obj[k]);
    }
    return mymap;
}
let m1 = objToMap({ a: 1, b: 2, c: 3 });
console.log(m1);

输出结果:
Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }

2.3.5 Map转换为JSON

Map的键名都是字符串,可以选择转换为对象JSON

function mapToStrJSON(mymap) {
    //先将Map转换为对象,在通过对象生成JSON。
    return JSON.stringify(mapToObj(mymap));
}
let m1 = new Map().set("a", 1).set("b", 2).set("c", 3);
let json1 = mapToStrJSON(m1);
console.log(json1);

输出结果:
{"a":1,"b":2,"c":3}

Map的键名有非字符串,可以转换为数组JSON

function mapToArrayJSON(mymap) {
    return JSON.stringify([...mymap]);
}
let m1 = new Map().set(true, 1).set({ foo: 2 }, ["abcdef"]);
let json2 = mapToArrayJSON(m1);
console.log(json2);

输出结果:
[[true,1],[{"foo":2},["abcdef"]]]

2.3.6 JSON转换为Map

function jsonToMap(jsonStr) {
    return objToMap(JSON.parse(jsonStr));
}
let m1 = jsonToMap('{ "a": 1, "b": 2, "c": 3 }');
console.log(m1);

输出结果:
Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }


活的像诗一样