ES6中Map数据结构的常用方法与使用场景

ES6中的Map数据结构

Map是一种新的数据结构，是 ES6 引入的一种键值对集合，键可以是任意类型（包括对象）。它与对象类似，但提供了更灵活的键选择和高效的迭代机制。

常用方法

set(key, value)
添加或更新键值对。
```
const map = new Map();
map.set('name', 'Alice');  // Map {'name' => 'Alice'}
```
get(key)
获取与键对应的值，如果不存在则返回 undefined。
```
map.get('name');  // 'Alice'
```
has(key)
判断 Map 是否包含某个键，返回布尔值。
```
map.has('name');  // true
```
delete(key)
删除指定键对应的键值对，返回布尔值表示是否成功删除。
```
map.delete('name');  // true
```
clear()
清空整个 Map。
```
map.clear();  // Map {}
```
size
返回 Map 中键值对的数量。
```
map.size;  // 0
```

forEach(callback)
遍历 Map 中的所有键值对，执行提供的回调函数。

map.set('age', 25);
map.forEach((value, key) => console.log(key, value));  // 'age', 25

迭代器方法
- keys(): 返回所有键的迭代器。
- values(): 返回所有值的迭代器。
- entries(): 返回所有键值对的迭代器。
- for...of: 遍历键值对。

const myMap = new Map([
  ['name', 'Alice'],
  ['age', 30],
  ['city', 'New York']
]);

// 获取值的迭代器
const valuesIterator = myMap.values();

// 手动迭代
console.log(valuesIterator.next().value); // 输出: Alice
console.log(valuesIterator.next().value); // 输出: 30
console.log(valuesIterator.next().value); // 输出: New York

// 使用 for...of 循环
for (const value of myMap.values()) {
    
    
  console.log(value);
}
// 输出:
// Alice
// 30
// New York

// 获取键的迭代器
const keysIterator = myMap.keys();

// 手动迭代
console.log(keysIterator.next().value); // 输出: name
console.log(keysIterator.next().value); // 输出: age
console.log(keysIterator.next().value); // 输出: city

// 使用 for...of 循环
for (const key of myMap.keys()) {
    
    
  console.log(key);
}
// 输出:
// name
// age
// city

// 获取键值对的迭代器
const entriesIterator = myMap.entries();

// 手动迭代
console.log(entriesIterator.next().value); // 输出: ['name', 'Alice']
console.log(entriesIterator.next().value); // 输出: ['age', 30]
console.log(entriesIterator.next().value); // 输出: ['city', 'New York']

// 使用 for...of 循环
for (const entry of myMap.entries()) {
    
    
  console.log(entry);
}
// 输出:
// ['name', 'Alice']
// ['age', 30]
// ['city', 'New York']

使用场景

对象键为非字符串类型
Map 允许使用对象、数组等复杂类型作为键。

const objKey = {
      
       id: 1 };
const map = new Map();
map.set(objKey, 'Object Key');
console.log(map.get(objKey));  // 'Object Key'

频繁增删操作
相比于对象，Map 在大量添加、删除键值对时效率更高，且键的顺序保留。
键值对存储与遍历
需要在存储数据时按插入顺序进行遍历或以其他复杂类型作为键时，Map 提供了高效支持。

Map与数组（Array）的区别

存储类型：
- 数组：数组是一种有序的集合，用于存储一系列元素，每个元素都有一个索引（非负整数）。数组中的元素可以是任何类型，包括对象。
- Map：Map 是一个键值对集合，其中键可以是任何类型的值（包括对象），而值也可以是任何类型。
访问方式：
- 数组：通过索引访问元素，如 arr[0]。
- Map：通过键来访问值，如 map.get(key)。
迭代：
- 数组：可以使用 for, forEach, map, filter 等方法进行迭代。
- Map：同样可以使用 for...of 循环来迭代键值对，或者通过 entries(), keys(), values() 方法获取迭代器。
大小：
- 数组：数组的长度是一个非常重要的属性，可以使用 length 属性来获取数组的长度。
- Map：没有类似 length 的属性，而是使用 size 属性来获取键值对的数量。

Map与对象（Object）的区别

键的类型：
- 对象：对象的键必须是字符串或符号（Symbol）。
- Map：Map 的键可以是任意类型的值，包括函数、对象、数组等。
存储顺序：
- 对象：ES6 之前，对象的键是没有顺序的；ES6 引入了 let 和 const 后，对象的键按插入顺序排序（对于字符串键）。
- Map：总是保持键/值对的原始插入顺序。
迭代：
- 对象：通常使用 for...in 循环来迭代对象的可枚举属性，但 for...in 也会枚举原型链上的属性。
- Map：直接迭代键值对，不会受到原型链的影响。
删除项：
- 对象：使用 delete obj[key] 删除某个键。
- Map：使用 map.delete(key) 删除某个键。

查找项：

对象：使用 obj[key] 或 obj.hasOwnProperty(key) 来检查键是否存在。
Map：使用 map.has(key) 来检查键是否存在。

// 创建 Map
const map = new Map();
map.set('key1', 'value1');
map.set(2, 'another value');

// 访问 Map
console.log(map.get('key1')); // 输出: value1
console.log(map.size); // 输出: 2

// 迭代 Map
for (const [key, value] of map) {
      
      
  console.log(`${
        
        key}: ${
        
        value}`);
}

// 创建 Array
const arr = ['value1', 'another value'];

// 访问 Array
console.log(arr[0]); // 输出: value1
console.log(arr.length); // 输出: 2

// 迭代 Array
arr.forEach((value, index) => {
      
      
  console.log(`Index ${
        
        index}: ${
        
        value}`);
});

总结

Map 是对象的更强大替代方案，适用于存储复杂键值对、提升性能以及需要顺序保留的场景。Map 提供了更为灵活的键值对存储机制，可以更好地处理非字符串类型的键，并且保持插入顺序不变。相比之下，数组更适合存储有序的数据集合，而对象则主要用于键值对存储，其键通常为字符串。选择哪种数据结构取决于具体的使用场景和个人偏好。