用不同标签的对象中的数组汇总数组

Question

我有一个包含对象的数组，其中一些具有相同的“子数组”但具有不同的标签。我需要根据平等来总结一下。

到目前为止，比较两个不同的数组很容易，但我不确定如何在同一个数组中进行比较。 这是我的阵列。

let array = [{
  label: 'sting1',
  subArray: ['A', 'B']
}, {
  label: 'sting2',
  subArray: ['B']
}, {
  label: 'sting3',
  subArray: ['A', 'B']
}]

如您所见，标有String1 和String3 的对象具有相同的数组。所以现在我需要总结一下。我需要的结果是这样的：

let result = [{
  label: ['sting1', 'string3'],
  subArray: ['A', 'B']
}, {
  label: ['sting2'],
  subArray: ['B']
}]

Answer 1

这个问题很可能是一个通用的“分组依据”，尽管它涉及一些问题，主要是：

• 您需要按项目数组进行分组。因为您没有通过引用或值指定威胁的数组是否相同，所以我们需要假设您可能需要单独比较每个值。
• 关于上述内容，我假设您的数组仅由原语组成。
• 标签似乎在某种程度上按出现顺序排列，因此我假设您希望它们按在原始数组中出现的相同顺序进行收集。

也就是说，您可以使用Array.reduce 遍历原始数组，并逐步：

• 检查累加器是否已经具有所需的键（不幸的是，在您的场景中，它无法通过简单的查找来完成。从技术上讲，您可以使用 Wea​​kMap，但这会稍微复杂一些）。在您的情况下，关键是您的子数组。因此，如果累加器中有任何项目具有当前循环的 subArray，您只需将标签推送到现有的。
• 如果没有，您只需推送当前循环的项目，假设您不关心引用。如果您不希望更改原始的 array 值，请先深度复制它们。
• 一切完成后，只需返回累加器并继续操作，直到完成。

下面是一个示例代码专为使用您发布的场景而构建：

let array = [{
  label: 'sting1',
  subArray: ['A', 'B']
}, {
  label: 'sting2',
  subArray: ['B']
}, {
  label: 'sting3',
  subArray: ['A', 'B']
}];

const grouped = array.reduce((acc, next) => {
  const { subArray } = next; // <-- acquire the subArray of the currently looped item.
  const exists = acc.find(({subArray: registeredSubArray}) => registeredSubArray.every(i => subArray.indexOf(i) > -1));
  // ^-- checks whether, in the accumulator, said subarray exists and if every item of the subarray is matched through indexOf against the accumulator looped item.
  if (exists) exists.label.push(next.label); // <-- if the item already exists, simply collect the label.
  else acc.push(Object.assign(next, {label: [next.label]})); // <-- otherwise, create a new object and assign the label as an array of labels instead of a single label.
  return acc; // finally, return the accumulator and continue.
}, []);

console.log(grouped);

Answer 2

假设您的 subArray 仅包含原始类型，因此没有对象、数组或函数，您可以使用 sort 和 join 方法创建键，然后使用 reduce 构建结果。

let array = [{"label":"sting1","subArray":["A","B"]},{"label":"sting2","subArray":["B"]},{"label":"sting3","subArray":["A","B"]}]

const map = array.reduce((r, e) => {
  const key = e.subArray.sort().join('-');
  if (!r.has(key)) r.set(key, { ...e, label: [e.label]});
  else r.get(key).label.push(e.label);
  return r;
}, new Map)

const result = [...map.values()];
console.log(result)

Answer 3

只是为了给你一个没有 map 和 reduce 的选项。在学习 javascript 时，我通常更喜欢总是回到简单的语法来了解发生了什么。

如果有帮助，请告诉我！

let array = [{label: 'sting1', subArray: ['A', 'B']}, {label: 'sting2',subArray: ['B']}, {label: 'sting3', subArray: ['A', 'B']}]

result = [];
checkdups = [];

for (i = 0; i < array.length; i++) {
    data = {
        label: [array[i].label],
        subArray: array[i].subArray
    }

    for (var j = 0; j < array.length; j++) {

        if (String(array[j].subArray) == String(array[i].subArray) && i != j) {
            data.label.push(array[j].label);
        }
    }

    if (checkdups.indexOf(String(array[i].subArray))==-1) {
        checkdups.push(String(array[i].subArray));
        result.push(data);
    }

}

console.log(result);

Answer 4

我们可以使用Array.prototype.reduce 遍历数组中的每个对象，并通过匹配子数组对其进行分组。

我们可以使用Array.prototype.findIndex找到匹配的子数组，如果找到我们添加到现有的标签数组中，否则创建一个新的标签数组并将对象推送到最终数组中：

const array = [{"label":"sting1","subArray":["A","B"]},{"label":"sting2","subArray":["B"]},{"label":"sting3","subArray":["A","B"]}];

const res = array.reduce((acc, obj) => {
  const idx = acc.findIndex(o => (o.subArray.length === obj.subArray.length) 
                      && o.subArray.every(e => obj.subArray.includes(e)));
  if(idx >= 0){
     acc[idx].label.push(obj.label);
  }else{
     obj.label = [obj.label];
     acc.push(obj);
  }
  return acc;
    
}, []);
console.log(res);