Javascript 计算值在对象数组中出现的次数

假设我有：

const map1=[
{id:1，res:{a:`1-a`，b:`1-b`}，
{id:2，res:{a:`2-a`，b:`2-b`，c:`2-c`，d:`2-d`}，
{id:3，res:{a:`3-a`，b:`3-b`，c:`3-c`}
]
常量映射2=[
{map1:{1:a'，2:c'，3:b'}，
{map1:{1:b'，2:c'，3:a'}，
{map1:{1:a'，2:a'}，
{map1:{1:a'，2:a'，3:b'}，
{map1:{2:d'，3:a'}，
{map1:{1:a'，2:c'，3:c'}，
{map1:{1:b'，2:d'，3:c'}，
{map1:{1:b'，3:a'}
]

这是我想要得到的结果：

const result={
1:{a:4，b:3}，
2:{a:2，b:0，c:3，d:1}，
3:{a:3，b:2，c:2}
}

result

是一个对象，其键是

map1

id

s，值是包含累积和的对象。 例如：

result[2]={a:2，b:0，c:3，d:1}

因为在

map2.map1

中循环每个对象，并用键

2

查看值（2因为我们正在查找结果[2]）。有2次

a

，0次

b

，3次

c

和1次

d

我想我必须使用

reduce

但是如何使用呢？这对我来说太复杂了。。 以下是我的出发点：

const results=map2.reduce（（累加器，电流）=>{
// ??  
回流蓄能器
}, [])

您可以计算

map2

的所有键/值对，并从

map1

生成所需的结果

这种方法对于每个给定的数组只需要一个循环

const
map1=[{id:1，res:{a:`1-a`，b:`1-b`}，{id:2，res:{a:`2-a`，b:`2-b`，c:`2-c`，d:`2-d`}，{id:3，res:{a:`3-a`，b:`3-b`，c:`3-c`}]，
map2=[{map1:{1:a'，2:c'，3:b'}}，{map1:{1:b'，2:c'，3:a'}，{map1:{1:a'，2:a'}，{map1:{1:a'，2:a'，3:b'}，{map1:{2:d'，3:a'}，{map1:{1:a'，2:c'，3:c'}，{map1:{，
temp=map2.reduce（（r，{map1}）=>{
Object.entries（map1.forEach（e=>（k=>r[k]=（r[k]| | 0）+1）（e.join（'-'））；
返回r；
}, {}),
result=map1.reduce（（r，{id，res}）=>{
r[id]？？={}；
Object.entries（res.forEach）（[k，v]）=>r[id][k]=temp[v]|0）；
返回r；
}, {});
控制台日志（结果）
.as console wrapper{max height:100%！important；top:0；}
您可以将
reduce
、
map
和
filter
方法结合使用


const-map1=[{“id”：1，res:{“a”：“1-a”，“b”：“1-b”}，{“id”：2，res:{“a”：“2-a”，“b”：“2-b”，“c”：“2-c”，“d”：“2-d”}，{“id”：3，res:{“a”：“3-a”，“b”：“3-b”，“c”：“3-c”}]
3.3.3.3.3.3“““““““““，”3“““，”3““““，”3“““，”1，”1“，1”1““，2”2“““，”2““，2”2““，2”2““，2”2““，2”2“，，，2”3“““，，”1，”1，，，，，，，，，，，，1““1，”1，”2““，，，3“，，”1，”1““““，，，，”1，”1，”1““，，，，”1，”1“““，，，，，”1“，，，，，，，”1“““，，，，，”1，”1，”1“，，，，，，，，，，，，，”1“，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，{“1”：“b”，“3”：“a”}]
const result=map1.reduce（（r，{id}）=>{
r[id]=map2
.map（（{map1}）=>map1[id]）
.filter（布尔值）
.减少（（a，e）=>{
如果（！a[e]）a[e]=0；
a[e]+=1
归还
}, {})
返回r
}, {})
console.log（result）
您可以首先创建一个查找表，通过循环
map2
来快速检索，以创建一个对象，该对象由
1-a
、
2-b
等设置关键帧，其中每个值存储每个关键帧的计数/出现次数。然后，一旦有了查找表，就可以在
map1
上使用and来使用先前生成的查找表生成结果对象


const map1=[
{id:1，res:{a:`1-a`，b:`1-b`}，
{id:2，res:{a:`2-a`，b:`2-b`，c:`2-c`，d:`2-d`}，
{id:3，res:{a:`3-a`，b:`3-b`，c:`3-c`}
]
常量映射2=[
{map1:{1:a'，2:c'，3:b'}，
{map1:{1:b'，2:c'，3:a'}，
{map1:{1:a'，2:a'}，
{map1:{1:a'，2:a'，3:b'}，
{map1:{2:d'，3:a'}，
{map1:{1:a'，2:c'，3:c'}，
{map1:{1:b'，2:d'，3:c'}，
{map1:{1:b'，3:a'}
];
const summated=map2.reduce（（acc，{map1}）=>{
Object.entries（map1.forEach）（[key，val]）=>{
acc[`key}-${val}`]=（acc[`key}-${val}`]|124; 0）+1；
});
返回acc；
}, {});
const result=Object.fromEntries（map1.map（{id，res}）=>[
身份证件
Object.fromEntries（Object.entries（res.map）（[key，val]）=>[key，summated[val]| | 0]））
]));
控制台日志（结果）我是这样解决的：

const result=map1.reduce（（计数器acc，m1）=>{
常数{id，res}=m1
const resIds=对象键（res）
const res2Ids=map2.map（（{map1}）=>map1[id]）
const res2IdsWithoutUndefined=res2Ids.filter（布尔值）
counterAcc[id]=resIds.reduce（（累加器，resId）=>{
累加器[resId]=0
const counterBy=res2idswithout undefined.reduce（（resAcc，ansId）=>{
常量answerText={text:res[ansId]}
如果（！resAcc[ansId]）{
resAcc[ansId]=1
}否则{
resAcc[ansId]+=1
}
返回resAcc；
}, {})
返回{…累加器，…计数器}
}, {})
返回计数器ACC
}, {})
不清楚您在数什么。语句
result[2]是{a:2，b:0，c:3，d:1}，因为循环map2并用键2查看每个对象（在map1内部），有2次a，0次b，3次c和1次d。
无法识别-是什么使键===2？@mplungjan Thak，请回答。解释起来有点复杂，但我试图在主消息中做得更好在结果中，您想要计数为
0
的那些吗？这个例子没有说明这一点。为什么
result[1]
中没有
c:0，d:0
，而
result[2]
中有
b:0
？@whitecircle应该
d:1
是