JavaScript 中有了Object 为什么还需要 Map 呢

• 一、别把对象当 map
• 2、对象的 key 只能是字符串
• 二、使用 map
• 三、map 和 object 的性能差异

一、别把对象当 map

1、可能通过原型链访问到未定义的属性

假设现有场景，开发一个网站，需要提供日语、汉语、韩语三种语言，我们可以定义一个字典去管理。

const dictionary = {
    'ja': {
        'ninjas for hire': '忍者を雇う',
    },
    'zh': {
        'ninjas for hire': '忍者出租',
    },
    'ko': {
        'ninjas for hire': '고용 닌자',
    }
}

console.log(dictionary.ja['ninjas for hire']) // 忍者を雇う
console.log(dictionary.zh['ninjas for hire']) // 忍者出租
console.log(dictionary.ko['ninjas for hire']) // 고용 닌자

这样我们就把不同语言的字典管理起来了。但是，当我们试图访问 constroctor 属性，问题就出现了。

console.log(dictionary.ko['constructor']) // ƒ object() { [native code] }

对于不存在的属性，我们期望得到 undefined，结果却通过原型链访问到了未定义的属性，原型对象的 constructor 属性，指向构造函数。

此处有一个解决办法是把原型设置为 null

object.setprototypeof(dictionary.ko, null)
console.log(dictionary.ko['constructor']) // undefined

2、对象的 key 只能是字符串

假设需要将对象的 key 映射为 html 节点。我们写如下代码：

/* html部分
<div id="firstelement"></div>
<div id="secondelement"></div>
*/

const firstelement = document.getelementbyid('firstelement')
const secondelement = document.getelementbyid('secondelement')

const map = {}

map[firstelement] = {
    data: 'firstelement'
}
map[secondelement] = {
    data: 'secondelement'
}

console.log(map[firstelement].data)     // secondelement
console.log(map[secondelement].data)    // secondelement

第一个元素的数据被覆盖了，原因是对象中的 key 只能是字符串类型，当我们没有使用字符串类型时，它会隐式调用 tostring() 函数进行转换。于是两个 html 元素都被转为字符串 [object htmldivelement] 。

对象的键也可以为 symbol，不过在 for..in 遍历和 object.keys() 以及用 json.stringify（） 进行序列化的时候，都会忽略为 symbol 的键。

二、使用 map

1、map 常用操作

map 可以使用任何 javascript 数据类型作为键

function people(name) {
    this.name = name
}
const zhangsan = new people('zhangsan')
const xiaoming = new people('xiaoming')
const lihua = new people('lihua')
// 创建 map
const map = new map()
// 创建 map 并进行初始化 将二维键值对数组转换成一个map对象
const map1 = new map([
    ['key1', 'val1'],
    ['key2', 'val2'],
])
// 将 map 转为二维数组
console.log(array.from(map1)) // [ [ 'key1', 'val1' ], [ 'key2', 'val2' ] ]
// 设置键值映射关系
map.set(zhangsan, { region: 'hb' })
map.set(xiaoming, { region: 'hn' })
// 根据 key 获取对应值
console.log(map.get(zhangsan)) // { region: 'hb' }
console.log(map.get(xiaoming)) // { region: 'hn' }
// 获取不存在的 key 得到 undefined
console.log(map.get(lihua))     // undefined
// 通过 has 函数判断指定 key 是否存在
console.log(map.has(lihua))     // false
console.log(map.has(xiaoming))  // true
// map存储映射个数
console.log(map.size)           // 2
// delete 删除 key
map.delete(xiaoming)
console.log(map.has(xiaoming))  // false
console.log(map.size)           // 1
// clear 清空 map
map.clear()
console.log(map.size)           // 0

2、遍历 map

map 可以确保遍历的顺序和插入的顺序一致

const zhangsan = { name: 'zhangsan' }
const xiaoming = { name: 'xiaoming' }
const map = new map()
map.set(zhangsan, { region: 'hb' })
map.set(xiaoming, { region: 'hn' })
// 每个键值对返回的是 [key, value] 的数组
for (let item of map) { // = for (let item of map.entries()) {
    console.log(item)
    // [ { name: 'zhangsan' }, { region: 'hb' } ]
    // [ { name: 'xiaoming' }, { region: 'hn' } ]
}
// 遍历 key
for (let key of map.keys()) {
    console.log(key)
    // { name: 'zhangsan' }
    // { name: 'xiaoming' }
}
// 遍历 value
for (let key of map.values()) {
    console.log(key)
    // { region: 'hb' }
    // { region: 'hn' }
}
// 使用 foreach() 方法迭代 map
map.foreach(function(value, key) {
    console.log(key, value)
    // { name: 'zhangsan' } { region: 'hb' }
    // { name: 'xiaoming' } { region: 'hn' }
})

3、map 中判断 key 相等

map 内部使用 samevaluezero 比较操作。

关于samevalue 和 samevaluezero

samevalue (object.is()) 和严格相等（===）相比，对于 nan 和 +0，-0 的处理不同

object.is(nan, nan) // true
object.is(0, -0) // false

samevaluezero 与 samevalue 的区别主要在于 0 与 -0 是否相等。

map.set(nan, 0)
map.set(0, 0)
console.log(map.has(nan))   // true
console.log(map.has(-0))    // true

4、复制或合并 map

map 能像数组一样被复制

let original = new map([
    [1, {}]
])
let clone = new map(original) // 克隆 map

console.log(clone.get(1)); // {}
console.log(original === clone) // false
console.log(original.get(1) === clone.get(1)) // true

多个 map 合并

let first = new map([
    [1, 'one'],
    [2, 'two'],
    [3, 'three'],
]);
let second = new map([
    [1, 'uno'],
    [2, 'dos']
]);
// 合并两个 map 对象时，如果有重复的键值，则后面的会覆盖前面的。
// 展开运算符本质上是将 map 对象转换成数组。
let merged = new map([...first, ...second]);

console.log(merged.get(1)); // uno
console.log(merged.get(2)); // dos
console.log(merged.get(3)); // three

5、map 序列化

map 无法被序列化，如果试图用 json.stringify 获得 map 的 json 的话，只会得到 "{}"。

由于 map 的键可以是任意数据类型，而 json 仅允许将字符串作为键，所以一般情况下无法将 map 转为 json。

不过可以通过下面的方式去尝试序列化一个 map：

// 初始化 map(1) {"key1" => "val1"}
const originmap = new map([['key1', 'val1']])
// 序列化 "[[\"key1\",\"val1\"]]"
const mapstr = json.stringify(array.from(originmap.entries())) 
// 反序列化 map(1) {"key1" => "val1"}
const clonemap = new map(json.parse(mapstr))

三、map 和 object 的性能差异

内存占用

不同浏览器的情况不同，但给定固定大小的内存，map 大约可以比 object 多存储 50% 的键/值对。

插入性能

map 略快，如果涉及大量操作，建议使用 map。

查找速度

性能差异极小，但如果只包含少量键/值对，则 object 有时候速度更快。object 作为数组使用时浏览器会进行优化。如果涉及大量查找操作，选择 object 会更好一些。

删除性能

如果代码涉及大量的删除操作，建议选择 map。

到此这篇关于javascript 中有了object 为什么还需要 map 呢的文章就介绍到这了,更多相关javascript  map 内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！