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

ES6中的Map数据结构

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

常用方法
  1. set(key, value)
    添加或更新键值对。

    const map = new Map();
    map.set('name', 'Alice');  // Map {'name' => 'Alice'}
    
  2. get(key)
    获取与键对应的值,如果不存在则返回 undefined

    map.get('name');  // 'Alice'
    
  3. has(key)
    判断 Map 是否包含某个键,返回布尔值。

    map.has('name');  // true
    
  4. delete(key)
    删除指定键对应的键值对,返回布尔值表示是否成功删除。

    map.delete('name');  // true
    
  5. clear()
    清空整个 Map

    map.clear();  // Map {}
    
  6. size
    返回 Map 中键值对的数量。

    map.size;  // 0
    
  7. forEach(callback)
    遍历 Map 中的所有键值对,执行提供的回调函数。

    map.set('age', 25);
    map.forEach((value, key) => console.log(key, value));  // 'age', 25
    
  8. 迭代器方法

    • 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']
使用场景
  1. 对象键为非字符串类型
    Map 允许使用对象、数组等复杂类型作为键。

    const objKey = {
          
           id: 1 };
    const map = new Map();
    map.set(objKey, 'Object Key');
    console.log(map.get(objKey));  // 'Object Key'
    
  2. 频繁增删操作
    相比于对象,Map 在大量添加、删除键值对时效率更高,且键的顺序保留。

    扫描二维码关注公众号,回复: 17430378 查看本文章
  3. 键值对存储与遍历
    需要在存储数据时按插入顺序进行遍历或以其他复杂类型作为键时,Map 提供了高效支持。

Map与数组(Array)的区别
  1. 存储类型

    • 数组:数组是一种有序的集合,用于存储一系列元素,每个元素都有一个索引(非负整数)。数组中的元素可以是任何类型,包括对象。
    • Map:Map 是一个键值对集合,其中键可以是任何类型的值(包括对象),而值也可以是任何类型。
  2. 访问方式

    • 数组:通过索引访问元素,如 arr[0]
    • Map:通过键来访问值,如 map.get(key)
  3. 迭代

    • 数组:可以使用 for, forEach, map, filter 等方法进行迭代。
    • Map:同样可以使用 for...of 循环来迭代键值对,或者通过 entries(), keys(), values() 方法获取迭代器。
  4. 大小

    • 数组:数组的长度是一个非常重要的属性,可以使用 length 属性来获取数组的长度。
    • Map:没有类似 length 的属性,而是使用 size 属性来获取键值对的数量。
Map与对象(Object)的区别
  1. 键的类型

    • 对象:对象的键必须是字符串或符号(Symbol)。
    • Map:Map 的键可以是任意类型的值,包括函数、对象、数组等。
  2. 存储顺序

    • 对象:ES6 之前,对象的键是没有顺序的;ES6 引入了 letconst 后,对象的键按插入顺序排序(对于字符串键)。
    • Map:总是保持键/值对的原始插入顺序。
  3. 迭代

    • 对象:通常使用 for...in 循环来迭代对象的可枚举属性,但 for...in 也会枚举原型链上的属性。
    • Map:直接迭代键值对,不会受到原型链的影响。
  4. 删除项

    • 对象:使用 delete obj[key] 删除某个键。
    • Map:使用 map.delete(key) 删除某个键。
  5. 查找项

    • 对象:使用 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 提供了更为灵活的键值对存储机制,可以更好地处理非字符串类型的键,并且保持插入顺序不变。相比之下,数组更适合存储有序的数据集合,而对象则主要用于键值对存储,其键通常为字符串。选择哪种数据结构取决于具体的使用场景和个人偏好。

猜你喜欢

转载自blog.csdn.net/misstianyun/article/details/143216045