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

Question

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

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

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、buzz 和 fizz。

但是 fizz 不是原始数组的一部分，所以 return 是未定义的，就像这样

[
foo: {true:[{foo: true}], false: [{foo: false}]},
bar: {true: [{bar: true}]},
buzz: {false: A[{buzz: false}]}
fizz: {undefined: [{foo: true},{foo: false},{bar: 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;

Answer 1

试试这样的：

    const data = [{foo: true},{foo: false},{bar: true},{buzz: false}];
    let v = [];
    let types = ['foo', 'bar', 'buzz', '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);

Answer 2

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

我把它写成一个名为 'aggregate' 的函数，这样它就可以用不同的参数多次调用。

const initialData = [{foo: true},{foo: true},{foo: false},{bar: true},{buzz: false}];
const types = ['foo', 'bar', 'buzz', '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));

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

输出也应该是一个对象（而不是数组），这样每个键都直接与其对应的值相关，而不是数组，它只是将值作为数组中的下一个项目（没有显式链接两个）。

{
  foo: { true: 2, false: 1 },
  bar: { true: 1 },
  buzz: { false: 1 }
}

Answer 3

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

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

人们不想迭代 types 数组，因为它会导致对 data 项进行不必要的复杂查找，每次要处理 type 项。

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

const sampleDataList = [
  { foo: true },
  { foo: false },
  { bar: true },
  { baz: false },
  { buzz: false },
  { baz: 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', 'bar', 'buzz', 'fizz'],
    index: {}

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

    inclusiveKeyList: ['foo', 'bar', 'baz'],
    index: {}

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

    index: {}

  }).index
);

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

Answer 4

你很接近，你只需要在添加之前检查你添加的属性是否未定义。您还可以在添加到结果对象之前检查缩减对象是否具有任何属性。

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

const data = [{
  foo: true
}, {
  foo: false
}, {
  bar: true
}, {
  buzz: false
}];
let v = [];
let types = ['foo', 'bar', 'buzz', '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);

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

Aggregate same key values into an array and avoid undefined

javascript

arrays

reduce

data-structures