JavaScript-Map对象

# Map对象

# 含义

Map 对象存有键值对，其中的键可以是任何数据类型

它类似于对象，也是键值对的集合

但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键

# 基本用法

创建Map对象
```
const map = new Map()
```
1
将键值对放入map对象
```
map.set('key',value)
```
1
根据key获取map值
```
map.get('key') //value
```
1
删除 Map 元素
```
map.delete('key')
```
1
如果 Map 中存在键
```
map.has('key')
```
1
从 Map 中移除所有元素
```
map.clear()
```
1
返回 Map 中元素的数量
```
map.size
```
1

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"

1
2
3
4
5
6
7
8
9
10

Map构造函数接受数组作为参数，实际上执行的是下面的算法。

const items = [
  ['name', '张三'],
  ['title', 'Author']
];

const map = new Map();

items.forEach(
  ([key, value]) => map.set(key, value)
);

1
2
3
4
5
6
7
8
9
10

变量k1和k2的值是一样的，但是它们在 Map 结构中被视为两个键

Map 的键实际上是跟内存地址绑定的，只要内存地址不一样，就视为两个键。这就解决了同名属性碰撞（clash）的问题，我们扩展别人的库的时候，如果使用对象作为键名，就不用担心自己的属性与原作者的属性同名。
```
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
```
1
2
3
4
5
6
7
8
9
10
11

# 遍历方法

Map.prototype.keys()：返回键名的遍历器。
Map.prototype.values()：返回键值的遍历器。
Map.prototype.entries()：返回所有成员的遍历器。

Map.prototype.forEach()：遍历 Map 的所有成员。

const map = new Map([
  ['F', 'no'],
  ['T',  'yes'],
]);

// Map.prototype.keys()：返回键名的遍历器。
for (let key of map.keys()) {
  console.log(key);
}
// "F"
// "T"


// Map.prototype.values()：返回键值的遍历器。
for (let value of map.values()) {
  console.log(value);
}
// "no"
// "yes"


// Map.prototype.entries()：返回所有成员的遍历器。
for (let item of map.entries()) {
  console.log(item[0], item[1]);
}
// "F" "no"
// "T" "yes"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

结合数组的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'}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 与其他数据结构的互相转换

Map转为数组

const map = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
]);

// 扩展运算符 ...
[...map.keys()]
// [1, 2, 3]

1
2
3
4
5
6
7
8
9

数组转为Map

new Map([
  [true, 7],
  [{foo: 3}, ['abc']]
])
// Map {
//   true => 7,
//   Object {foo: 3} => ['abc']
// }

1
2
3
4
5
6
7
8

Map 转为对象

// 如果有非字符串的键名，那么这个键名会被转成字符串，再作为对象的键名。
function strMapToObj(strMap) {
  let obj = Object.create(null);
  for (let [k,v] of strMap) {
    obj[k] = v;
  }
  return obj;
}

const myMap = new Map()
  .set('yes', true)
  .set('no', false);
strMapToObj(myMap)
// { yes: true, no: false }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

对象转为 Map

let obj = {"a":1, "b":2};
let map = new Map(Object.entries(obj));

1
2

Map 转为 JSON

// 一种情况是，Map 的键名都是字符串
function strMapToJson(strMap) {
  return JSON.stringify(strMapToObj(strMap));
}

let myMap = new Map().set('yes', true).set('no', false);
strMapToJson(myMap)
// '{"yes":true,"no":false}'


// 另一种情况是，Map 的键名有非字符串
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"]]]'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

JSON 转为 Map

// 正常情况下，所有键名都是字符串。
function jsonToStrMap(jsonStr) {
  return objToStrMap(JSON.parse(jsonStr));
}

jsonToStrMap('{"yes": true, "no": false}')
// Map {'yes' => true, 'no' => false}

// 整个 JSON 就是一个数组，且每个数组成员本身，又是一个有两个成员的数组。
function jsonToMap(jsonStr) {
  return new Map(JSON.parse(jsonStr));
}

jsonToMap('[[true,7],[{"foo":3},["abc"]]]')
// Map {true => 7, Object {foo: 3} => ['abc']}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上次更新: 2024/08/14, 04:14:33

← JavaScript-Object对象 JavaScript-Array对象→