計算一個值在對象數組中出現的次數

Question

假設我有：

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是一個 object ，其鍵是map1 id ，值是包含累積和的對象。 例如：

result[2] = { a: 2, b: 0, c: 3, d: 1 }因為在 map2.map1 中循環每個map2.map1並用鍵2查看值（2 因為我們正在尋找結果 [2]）是 2 次a ， 0 次b ， 3 次c和 1 次d 。

我想我必須使用reduce但如何？ 這對我來說似乎太復雜了..這是我的起點：

const results = map2.reduce((accumulator, current) => {
  // ??  
  return accumulator
}, [])

Answer 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)

Answer 2

您可以首先通過遍歷map2創建一個查找表以快速檢索，以創建一個 object，它由1-a 、 2-b等作為鍵，其中每個值存儲每個鍵的計數/出現次數。 然后，一旦有了查找表，就可以在map1上使用.map()和Object.fromEntries()來使用先前構建的查找表構建生成的 object。

 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);

Answer 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; }

Answer 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
}, {})