将相同的键值聚合到数组中，避免未定义

编程问答 2022-06-13

问题描述

我正在尝试将相同的键值按值聚合到一个数组中。

例如，我有一个对象数组，像这样

const data = [{foo: true},{foo: false},{bar: true},{buzz: false}]

当它们聚合时，数组转换为

[
foo: {true: [{foo: true}],false: [{foo: false}]},bar: {true: [{bar: true}]},buzz: {false: [{buzz: false}]}
]

数组项是原始对象。

现在我知道要分组的密钥了。 它们是foo，bar，嗡嗡声和嘶嘶声。

但是fizz不是原始数组的一部分，所以返回值是不确定的，就像这样

[
foo: {true:[{foo: true}],buzz: {false: A[{buzz: false}]}
fizz: {undefined: [{foo: true},{buzz: false}]}
],

如何在不包含未定义的fizz值的情况下缩小原始数组？

此处的代码：

 let v = [];
let types = ['foo','bar','buzz','fizz' ]
    for (let x = 0; x < types.length; x++) {
        let data = data.reduce((acc,i) => {
            if (!acc[i[types[x]]]) {
                acc[i[types[x]]] = [i]
            }
            else if (Array.isArray(acc[i[types[x]]])) {
                acc[i[types[x]]].push(i);
            }
            else if (typeof acc[i[types[x]]] === 'object') {
                acc[i[types[x]]] = [acc[i[types[x]]]]
                acc[i[types[x]]].push(i)
            }
            return acc;
        },{})
        v.push({ [types[x]]: data });
    }

    return v;

解决方法

看看Array.prototype.reduce的工作方式。这可能是建立您的方法的正确方法。

解决OP问题的一种通用方法是迭代提供的data数组。对于每个项目，将提取其键和值。如果该项目的密钥在另一个提供的types数组中列出（包括），则将继续创建新的数据结构并在后者中收集当前处理的项目。

一个人不想迭代types数组，因为每次处理data项时，都会导致对type项的不必要的复杂查找。

因此，一种通用的（更好的代码重用）reduce方法可能是解决OP问题的最佳解决方案... 

const sampleDataList = [
  { foo: true },{ foo: false },{ bar: true },{ baz: false },{ buzz: false },{ bar: true }
];

// foo: {true: [{foo: true}],false: [{foo: false}]},// bar: {true: [{bar: true}]},// buzz: {false: [{buzz: false}]}

function collectItemIntoInclusiveKeyValueGroup(collector,item) {
  const { inclusiveKeyList,index } = collector;
  const firstItemEntry = Object.entries(item)[0];

  const key = firstItemEntry[0];
  const isProceedCollecting = (       // proceed with collecting ...
                                      //
    !Array.isArray(inclusiveKeyList)  // - either for no given list
    || inclusiveKeyList.includes(key) // - or if item key is listed.
  );
  if (isProceedCollecting) {

    let keyGroup = index[key];        // access the group identified
    if (!keyGroup) {                  // by an item's key,... or ...
                                      // ...create it in case ...
      keyGroup = index[key] = {};     // ...it did not yet exist.
    }
    const valueLabel = String(firstItemEntry[1]); // item value as key.

    let valueGroupList = keyGroup[valueLabel];    // acces the group list
    if (!valueGroupList) {                        // identified by an item's
                                                  // value,...or create it in
      valueGroupList = keyGroup[valueLabel] = []; // case it did not yet exist.
    }
    // push original reference into a grouped
    // key value list,as required by the OP.
    valueGroupList.push(item);
  }
  return collector;
}

console.log(
  "'foo','bar','buzz' and 'fizz' only :",sampleDataList.reduce(collectItemIntoInclusiveKeyValueGroup,{

    inclusiveKeyList: ['foo','buzz','fizz'],index: {}

  }).index
);
console.log(
  "'foo','bar' and 'baz' only :",'baz'],index: {}

  }).index
);
console.log(
  "all available keys :",{

    index: {}

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

,

您已经很接近了，您只需要在添加之前检查所添加的属性是否未定义即可。您还可以在将简化对象添加到结果对象之前检查其是否具有任何属性。

请注意，这可能不是最有效的方法，但是有时理解代码比拥有高效代码要好。

const data = [{
  foo: true
},{
  foo: false
},{
  bar: true
},{
  buzz: false
}];
let v = [];
let types = ['foo','fizz']
for (let x = 0; x < types.length; x++) {
  let reduced = data.reduce((acc,i) => {
    //                        /* Added this type check            */
    if (!acc[i[types[x]]] && typeof i[types[x]] !== 'undefined') {
      acc[i[types[x]]] = [i]
    } else if (Array.isArray(acc[i[types[x]]])) {
      acc[i[types[x]]].push(i);
    } else if (typeof acc[i[types[x]]] === 'object') {
      acc[i[types[x]]] = [acc[i[types[x]]]]
      acc[i[types[x]]].push(i)
    }
    return acc;
  },{});
  // Doesn't add a property for the type if there are no data
  if (Object.keys(reduced).length) {
    v.push({
      [types[x]]: reduced
    });
  }
}

console.log(v);

,

尝试类似的东西：

    const data = [{foo: true},{foo: false},{bar: true},{buzz: false}];
    let v = [];
    let types = ['foo','fizz' ];
        for (let x = 0; x < types.length; x++) {
          let filteredlist = data.filter(function (d) {
            return Object.keys(d)[0] == types[x];
          });
          let isTrue = 0;
          let isFalse = 0;
          if (filteredlist.length > 0) {
            for (let i = 0; i < filteredlist.length; i++) {
              let trueOrfalse = eval("filteredlist[i]." + types[x]);
              if (trueOrfalse) {
                isTrue++;
              } else {
                isFalse++;
              }
            }
            v.push(types[x],{true: isTrue,false: isFalse});
          }
        }
    console.log(v);

,

假设您只想计算每个键的数量（例如true或false），则可以使用以下代码。

我将其编写为名为“ aggregate”的函数，以便可以使用不同的参数多次调用它。

const initialData = [{foo: true},{foo: true},{buzz: false}];
const types = ['foo','fizz'];

const aggregate = (data,types) => {
  const result = {};

  data.forEach(item => {
    // Extract key & value from object
    // Note: use index 0 because each object in your example only has a single key
    const [key,value] = Object.entries(item)[0];
    // Check if result already contains this key
    if (result[key]) {
      if (result[key][value]) {
        // If value already exists,append one
        result[key][value]++;
      } else {
        // Create new key and instantiate with value 1
        result[key][value] = 1;
      }
    } else {
      // If result doesn't contain key,instantiate with value 1
      result[key] = { [value]: 1 };
    }
  });
  
  return result;
};

console.log(aggregate(initialData,types));

这将输出以下内容（请注意，我在您的initialData数组中添加了另一个{foo: true}以进行测试）。

输出也应该是一个对象（不是数组），以便每个键都直接与其对应的值相关，而不是Array，后者会将值简单地放置为Array中的下一项（无需显式链接两者） 

{
  foo: { true: 2,false: 1 },bar: { true: 1 },buzz: { false: 1 }
}
arraysarraysarraysdata-structuresjavascriptreducereduce