计算一个值在对象数组中出现的次数答案

【问题标题】：Count how many times a value occurs in a array of objects计算一个值在对象数组中出现的次数
【发布时间】：2020-12-03 15:45:26
【问题描述】：

假设我有：

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` } }
]
const 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: { 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 ids，值是包含累积和的对象。例如：

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((accumulator, current) => {
  // ??  
  return accumulator
}, [])

【问题讨论】：

不清楚你在数什么。声明 result[2] is { a: 2, b: 0, c: 3, d: 1 } because looping map2 and looking at each object (inside map1) with key 2 there are 2 times a, 0 times b, 3 times c and 1 time d. 无法识别 - 是什么让 key===2？
@mplungjan 谢谢你的回答。解释起来有点复杂，但我试图在主要信息中做得更好
在结果中，您是否想要计数为0 的那些？这个例子没有说明这一点。为什么result[1] 中没有c: 0, d: 0 而result[2] 中有b: 0？
@whitecircle 应该 d: 1 是 d: 2，因为 2: 'd' 出现在两个对象中？
@JimNilsson 因为map1 中的第一个对象只有a 和b，没有c 或d

标签： javascript mapreduce

【解决方案1】：

您可以结合使用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"}}]
const 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":{"1":"b","2":"d","3":"c"}},{"map1":{"1":"b","3":"a"}}]

const result = map1.reduce((r, { id }) => {
  r[id] = map2
    .map(({ map1 }) => map1[id])
    .filter(Boolean)
    .reduce((a, e) => {
      if (!a[e]) a[e] = 0;
      a[e] += 1
      return a
    }, {})

  return r
}, {})

console.log(result)

【讨论】：

我喜欢你的解决方案！只有一件事：在result[2] 中缺少b: 0..
@whitecircle 此解决方案不使用来自map1 的res 数据，因此不会有值为0 的属性。

【解决方案2】：

您可以首先通过循环map2 创建一个查找表以便快速检索，以创建一个以1-a、2-b 等为键的对象，其中每个值存储每个键的计数/出现次数。然后，一旦有了查找表，您就可以在 map1 上使用 .map() 和 Object.fromEntries() 来使用之前构建的查找表来构建结果对象。

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` } }
]
const 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: { 1: 'b', 2: 'd', 3: 'c' } },
  { map1: { 1: 'b',         3: 'a' } }
];


const summed = map2.reduce((acc, {map1}) => {
  Object.entries(map1).forEach(([key, val]) => {
    acc[`${key}-${val}`] = (acc[`${key}-${val}`] || 0) +1;
  });
  return acc;
}, {});

const result = Object.fromEntries(map1.map(({id, res}) => [
  id,
  Object.fromEntries(Object.entries(res).map(([key, val]) => [key, summed[val] || 0]))
]));

console.log(result);

【讨论】：

【解决方案3】：

您可以计算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: { 1: 'b', 2: 'd', 3: 'c' } }, { map1: { 1: 'b', 3: 'a' } }],
    temp = map2.reduce((r, { map1 }) => {
        Object.entries(map1).forEach(e => (k => r[k] = (r[k] || 0) + 1)(e.join('-')));
        return r;
    }, {}),
    result = map1.reduce((r, { id, res }) => {
        r[id] ??= {};
        Object.entries(res).forEach(([k, v]) => r[id][k] = temp[v] || 0);
        return r;
    }, {});

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

【讨论】：

【解决方案4】：

我是这样解决的：

const result = map1.reduce((counterAcc, m1) => {
  const { id, res } = m1
  const resIds = Object.keys(res)
  const res2Ids = map2.map(({ map1 }) => map1[id])
  const res2IdsWithoutUndefined = res2Ids.filter(Boolean)
  
  counterAcc[id] = resIds.reduce((accumulator, resId) => {    
    accumulator[resId] = 0
    const counterBy = res2IdsWithoutUndefined.reduce((resAcc, ansId) => {
      const answerText = { text: res[ansId] }
      if (!resAcc[ansId]) {
        resAcc[ansId] = 1
      } else {
        resAcc[ansId] += 1
      }
      return resAcc;
    }, {})
    
    return { ...accumulator, ...counterBy }
  }, {})
  return counterAcc
}, {})

【讨论】：