在数组中过滤复杂的数据并返回新数据

Question

我有一个类似的数组：

const arr = [
              { name: 'A', accounts: [{id: 0, data: {}}, {id: 1, data: {}}, {id: 0, data: {}}]},
              { name: 'B', accounts: [{id: 0, data: {}}, {id: 1, data: {}}]},
              { name: 'C', accounts: [{id: 2, data: {}}, {id: 2, data: {}}, {id: 2, data: {}}]},
];

我想像这样修改此数组：

const arr = [
              { name: 'A', accounts: {joint: [{id: 0, data: {}}, {id: 0, data: {}}], individual: [{id: 1, data: {}}]}},
              { name: 'B', accounts: {joint: [], individual: [{id: 0, data: {}}, {id: 1, data: {}}]}},
              { name: 'C', accounts: {joint: [{id: 2, data: {}}, {id: 2, data: {}}, {id: 2, data: {}}], individual: []}},
];

这意味着，将相同的帐户ID放在一个单独的联合和非重复ID对象中。

这就是我尝试的方式：

              for (let i = 0; i < arr.length - 1; i++) {
                const compareValue = test[standard].id;
                if (compareValue === test[i].id) {
                   joint.push(test[i]);
                }
                standard++;
            }
            if (joint.length > 0) {
                if (joint.filter(account => account.id === test[standard].id).length > 0) {
                    joint.push(test[standard]);
                } else {
                    individual.push(test[standard]);
                }
            }
            if (joint.length === 1) {
                const item = joint[0];
                individual.push(item);
                joint.pop();
            }
        } else {
            individual.push(test[0]);
        }

您能帮我弄清楚我错过了什么吗？谢谢。

Answer 1

假设您的输出accounts属性是一个对象：

我会首先将问题分成块。如果您可以找到一种将单个accounts数组转换为所需的输出结构的方法，那么您就是其中的大部分方式(其余的只是一个简单的.map(。因此，我们只需要转弯

[{id: 0, data: {}}, {id: 1, data: {}}, {id: 0, data: {}}]

进入

{joint: [{id: 0, data: {}}, {id: 0, data: {}}], individual: [{id: 1, data: {}}]}

一个选项是迭代输入对象，只需计算每个ID的出现数量即可。然后，一旦您有计数，只需再次迭代输入对象，查找每个对象的数量。如果计数为1，请将其推到individual数组，否则将其推到joint数组：

const arr = [
  { name: 'A', accounts: [{id: 0, data: {}}, {id: 1, data: {}}, {id: 0, data: {}}]},
  { name: 'B', accounts: [{id: 0, data: {}}, {id: 1, data: {}}]},
  { name: 'C', accounts: [{id: 2, data: {}}, {id: 2, data: {}}, {id: 2, data: {}}]},
];
const transformAccounts = (inputAccounts) => {
  const occurrencesOfId = inputAccounts.reduce((a, { id }) => {
    a[id] = (a[id] || 0) + 1;
    return a;
  }, {});
  const joint = [];
  const individual = [];
  inputAccounts.forEach((obj) => {
    if (occurrencesOfId[obj.id] > 1) {
      joint.push(obj);
    } else {
      individual.push(obj);
    }
  });
  return { joint, individual };
};
const output = arr.map(({ name, accounts }) => ({
  name,
  accounts: transformAccounts(accounts)
}));
console.log(output);

Answer 2

使用与上述答案非常相似的逻辑，只有代码几乎没有什么不同，它可能会帮助您更好地了解如何使用数据。

因此，第一步是您必须创建某种出现表。然后基于此类关节和个人之间的帐户。您没有指定是否要合并数据或它们只是重复。

const arr = [
    { name: 'A', accounts: [{id: 0, data: {}}, {id: 1, data: {}}, {id: 0, data: {}}]},
    { name: 'B', accounts: [{id: 0, data: {}}, {id: 1, data: {}}]},
    { name: 'C', accounts: [{id: 2, data: {}}, {id: 2, data: {}}, {id: 2, data: {}}]},
];
let newArray = arr.map( value => {
    let accounts = {
        joint: [],
        individual: [],
    };
    let table = {};
    
    for ( let acc of value.accounts ) {
        if ( table.hasOwnProperty(acc.id) ) {
            table[acc.id] += 1;
        } else {
            table[acc.id] = 1;
        }
    }
    let finder = id => a => a.id === Number(id);
    for ( let id in table ) {
        let f = finder(id);
        let account = value.accounts.find( f );
        if (table[id] === 1) {
            accounts.individual.push( account );
        } else {
            accounts.joint.push( account );
        }
    }
    return {
        ...value,
        accounts
    }
})

Answer 3

我尝试了一下，它起作用了：

const arr = [
    { name: 'A', accounts: [{id: 0, data: {}}, {id: 1, data: {}}, {id: 0, data: {}}]},
    { name: 'B', accounts: [{id: 0, data: {}}, {id: 1, data: {}}]},
    { name: 'C', accounts: [{id: 2, data: {}}, {id: 2, data: {}}, {id: 2, data: {}}]},
];

let newArr = [];
for(let i = 0;i < arr.length;i++){
    let join = [];
    let individual = [];
    for(let j = 0;j<arr[i].accounts.length;j++){
        console.log(idInArrayCount(arr[i].accounts,arr[i].accounts[j].id));
        if(idInArrayCount(arr[i].accounts,arr[i].accounts[j].id) > 1){
            join.push(arr[i].accounts[j]);
        }else{
            individual.push(arr[i].accounts[j]);
        }
    }
    newArr.push({
        "name" : arr[i].name,
        accounts : {
            "join" : join,
            "individual" : individual
        }
    });
    function idInArrayCount(array,ID){
        let count = 0;
        for(let i = 0;i < array.length;i++){
            if(array[i].id === ID){
                count++;
            }
        }
        return count;
    }
}
console.log(newArr);

变量newArr包含通缉值。