【ES6基础】 Map用法总结

·  阅读 9185

本文整理自阮一峰: Map,更改为字典结构,扩展解释。

含义及基本用法

Map数据结构类似于对象,也是键值对的集合,但是键的范围不限于字符串,各种类型的值(包括对象)都可以当做键。

Map结构提供了“值-值”的对应,是更完善的Hash结构实现。Map可以作为构造函数。

如何向Map添加成员

利用set()方法

添加一个对象时,可以用这种方法

const m = new Map();
// o是一个对象
const o = {p: 'Hello world!'};

// 添加成员:对象o是m的一个键,值为'content'
m.set(o, 'content'); // "content"

// get方法读取这个键
m.get(o); // true

m.has(o); // true

// delete方法删除这个键
m.delete(o);  // true
m.has(o); // false
复制代码

利用构造函数的参数新建Map实例时直接指定键(原理仍使用set())

任何具有Iterator接口、且每个成员都是一个双元素的数组的数据结构都可以当做Map构造函数的参数。例如Array Set Map,都可以用来生成新的Map

实例

Array

// Map构造函数接受一个数组作为参数
const map = new Map([
// 指定了两个键 name 和 tile
// 数组的成员是一个个表示键值对的数组
  ['name', '张三'],
  ['title', 'Author']
]);

map.size // 2
map.has('name') // true
map.get('name') // "张三"
map.has('title') // true
map.get('title') // "Author"
复制代码

Set

const set = new Set([
    ['foo', 1],
    ['bar', 2]
]);
const m1 = new Map(set);
m1.get('foo'); // 1
复制代码

Map

// 注意两个方括号,参数是成员是数组的数组
const m2 = new Map([['baz', 3]]);
// m2是Map数据结构,有一个数组成员

// 参数是Map
const m3 = new Map(m2);
m3.get('baz'); // 3
复制代码
原理

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

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

const map = new Map();
items.forEach(
    ([key, value]) => map.set(key, value)
);
复制代码

Map的键

map的键和内存地址绑定

键的覆盖

对同一个键多次赋值,后面的值会覆盖前面的值

const map = new Map();

map
.set(1, 'aaa')
.set(1, 'bbb');

map.get(1) // "bbb"
复制代码

读取未知的键返回undefined

new Map().get('adfawg'); // undefined
复制代码

如何判定同一个键

Map的键实际上是跟内存地址绑定的,只要内存地址不一样,就视为两个键。

只有对同一个对象的引用,Map结构才将其视为同一个键。
const map = new Map();

map.set(['a'], 555);

// 此['a']非上面的['a'],内存地址自然也不一样
map.get(['a']); // undefined
复制代码

上面代码的set和get方法,表面是针对同一个键,但实际上这是两个值,内存地址是不一样的,因此get方法无法读取该键,返回undefined。 如果改写如下就可以返回

const map = new Map();
const arr = ['a'];

// 指针,指向同一个内存地址
map.set(arr, 555);
map.get(arr); // 555
复制代码

同样的值的两个实例,在Map结构中被视为两个键。

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也将其视为一个键

简单类型如(数字、字符串、布尔值),比如0和-0是一个键,布尔值true和字符串true则是两个不同的键。

需要注意:

  • undefinednull是两个不同的键。
  • NaN是同一个键,即使不严格相等于自身。
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
复制代码

实例的属性和操作方法

size属性

返回Map结构的成员总数

const map = new Map();
map.set('foo', true);
map.set('bar', false);

map.size // 2
复制代码

set(key, value)

set方法设置键名key对应的键值为value,然后返回整个 Map 结构。如果key已经有值,则键值会被更新,否则就新生成该键。

const m = new Map();

m.set('edition', 6);
m.set(262, 'standard');
m.set(undefined, 'nah'); // 键是 undefined
复制代码

set方法返回的是当前的Map对象,因此可以采用链式写法

let map = new Map()
  .set(1, 'a')
  .set(2, 'b')
  .set(3, 'c');
复制代码

get(key)

get方法读取key对应的键值,如果找不到key,返回undefined。

const m = new Map();

const hello = function() {
    console.log('hello'); // 键是函数
};
m.set(hello, 'hello ES6!');

m.get(hello); // hello ES6!
复制代码

has(key)

has方法返回一个布尔值,表示某个键是否在当前 Map 对象之中。

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(undefined); // true
复制代码

delete(key)

delete方法删除某个键,返回true。如果删除失败,返回false。

const m = new Map();
m.set(undefined, 'nah');
m.has(undefined); // true

m.delete(undefined); // true
m.has(undefined); // false
复制代码

clear()

clear方法清除所有成员,没有返回值。

let map = new Map();
map.set('foo', true);
map.set('bar', false);

map.size; // 2
map.clear();
map.size; // 0
复制代码

遍历方法

Map 结构原生提供三个遍历器生成函数和一个遍历方法。

  • keys():返回键名的遍历器
  • values():返回键值的遍历器
  • entries():返回所有成员的遍历器
  • forEach():遍历 Map 的所有成员

注意Map的遍历顺序就是插入顺序

简单遍历

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"

// 等同于使用map.entries()
for (let [key, value] of map) {
  console.log(key, value);
}
// "F" "no"
// "T" "yes"
复制代码

遍历和过滤

Map 结构转为数组结构后,结合数组的map方法、filter方法,可以实现Map的遍历和过滤(Map本身没有map和filter方法)。

Map转为数组的快速方法是使用扩展运算符(...)

// 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 实现遍历和过滤
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'}
复制代码
分类:
前端
标签:
收藏成功!
已添加到「」, 点击更改