如何在JavaScript中检查两个映射是否设置了相同的键

假设有两个对象，如何检查它们的关键点集是否相同

例如：

const A = new Map();
A.set('x', 123);
A.set('y', 345);

const B = new Map();
B.set('y', 567);
B.set('x', 789);

const C = new Map();
C.set('x', 121);
C.set('y', 232);
C.set('z', 434);

---

在这种情况下，

A

和

B

地图都有相同的键集（即

['x'，'y']

），而

C

的键集不同，因为它有额外的键

z
检查每个地图的
大小是否相同，然后迭代一个映射的
键
，并检查另一个中是否也存在该键。利用
Array.prototype.every.call
意味着不需要创建中间数组：


const A=newmap（）；
A.set（'x'，123）；
A.set（'y'，345）；
常数B=新映射（）；
B.set（'y'，567）；
B.集合（'x'，789）；
常数C=新映射（）；
C.set（'x'，121）；
C.set（'y'，232）；
C.set（'z'，434）；
常数sameKeySet=（m1，m2）=>(
m1.尺寸===m2.尺寸
&&Array.prototype.every.call（m1.keys（），key=>m2.has（key））
);
日志（sameKeySet（A，B））；
console.log（sameKeySet（A，C））您可以检查大小，然后迭代一个贴图的键，并检查另一个贴图是否也有键


const A=newmap（）；
A.set（'x'，123）；
A.set（'y'，345）；
常数B=新映射（）；
B.set（'y'，567）；
B.集合（'x'，789）；
常数C=新映射（）；
C.set（'x'，121）；
C.set（'y'，232）；
C.set（'z'，434）；
功能sameKeys（a、b）{
如果（a.尺寸！=b.尺寸）{
返回false；
}
for（让输入a.keys（））{
如果（！b.has（键））{
返回false；
}
}
返回true；
}
控制台日志（sameKeys（A，B））；
控制台日志（sameKeys（A，C））
通过扩展
keys（）
方法返回的迭代器，可以将映射的键转换为数组：

const aKeys = [...A.keys()];

然后，您只需比较所有键数组。对于出现的情况，您可以简单地执行以下操作：


const A=newmap（）；
A.set（'x'，123）；
A.set（'y'，345）；
常数B=新映射（）；
B.set（'y'，567）；
B.集合（'x'，789）；
常数C=新映射（）；
C.set（'x'，121）；
C.set（'y'，232）；
C.set（'z'，434）；
常数aKeys=[…A.keys（）]；
常量bKeys=[…B.keys（）]；
常数cKeys=[…C.keys（）]；
log（aKeys.sort（）.toString（）==bKeys.sort（）.toString（））；
console.log（aKeys.sort（）.toString（）==cKeys.sort（）.toString（））；
console.log（bKeys.sort（）.toString（）==cKeys.sort（）.toString（））基本上，您需要检查两件事：

如果两个贴图的大小不相等，则返回false
如果大小与相同，则检查map1的所有键是否都存在于map2中，如果大于，则返回true，否则返回false

const A=newmap（）；
A.set（'x'，123）；
A.set（'y'，345）；
常数B=新映射（）；
B.set（'y'，567）；
B.集合（'x'，789）；
常数C=新映射（）；
C.set（'x'，121）；
C.set（'y'，232）；
C.set（'z'，434）；
const D=新映射（）；
C.set（'x'，121）；
C.set（'z'，232）；
函数名（a，b）{
如果（a.尺寸！=b.尺寸）
返回false；
for（a.entries（）的常量[键，值]）{
如果（！b.has（键））
返回false；
}
返回true；
}
console.log（isSame（A，B））；
console.log（isSame（A，C））；
console.log（isSame（A，D））
您可以检查大小，并将
的原型has
和第二个映射作为
thisArg
检查所有键

这适用于任何类型，因为它不会改变键的类型


const
比较=（a，b）=>a.size===b.size&&[…a.keys（）]一些（Map.prototype.has，b），
a=新地图（['x'，123]，'y'，345]）；
b=新地图（[[y'，567]，[x'，789]]；
c=新地图（['x'，121]，'y'，232]，'z'，434]]；
log（比较（a，b））；
log（比较（a，c））
您可以使用这两个条目构建一个新的
映射
，然后比较大小。无论如何，你需要检查它们的大小，如果是相同的，那么只有你应该继续这样做

map1.size.size
=
map2.size&

newmap（[…map1，…map2]））.size
==
map1.size
//或map2.size

让我们创建一个工作示例：


const A=newmap（）；
A.set（'x'，123）；
A.set（'y'，345）；
常数B=新映射（）；
B.set（'y'，567）；
B.集合（'x'，789）；
常数C=新映射（）；
C.set（'x'，121）；
C.set（'y'，232）；
C.set（'z'，434）；
让比较映射=（m1，m2）=>(
m1.尺寸===m2.尺寸&&
（新地图（[…m1，…m2]）。大小===m1.size
)
log（'Compare A&B:'，compareMap（A，B））；
log（'Compare A&C:'，compareMap（A，C））；
log（'Compare B&C:'，compareMap（B，C））
你是说？你不能在地图上调用
.keys（）.size（）
object@SuperDJ具体到
Map
我不认为这个问题是一样的，主要的回答方式是different@FrancescoBorzì我可以问一下，为什么你接受了我冗长而笨拙的回答，而不是那些看起来更短/更干净的回答？（我唯一能想到的是答案的复杂性，我的答案看起来更像是自我解释的伪代码）因为这是最自我解释的答案：驻留，看起来肯定比我的更干净。是否有理由使用
Array.prototype
而不是
[]
。另外，您不能在条件周围去掉
（…&&&&&…）
括号吗？利用
Array.prototype.each.call
意味着不需要创建中间数组，而像
[…m1.keys（）]
这样的东西将不必要地从迭代器创建新数组。是的，删除括号在语法上是有效的，但因为它是一个多行表达式，我认为括号使代码更清晰易读。啊，好吧，我在考虑
[].every.call
希望空数组不会有那么大的问题，也不会像
数组.prototype
=）那样“吓人”）[事实上，我只想把它打到两行]如果你不知道：代码片段有一个内置自动格式化按钮：感谢对齐编辑。但是，人们应该关注内容（至少当它是两行的时候），但是是的，