Реагировать на JS concate array и преобразовать в новый двумерный массив и отсортировать по сумме данных двумерного массива

Question

Я работаю над собственным приложением реагирования. Скажем, у меня есть список массивов:

let soldList1 = [
    {"itemCode":"X001" , "soldRate":0.0789},
    {"itemCode":"5555" , "soldRate":0.0543},
    {"itemCode":"3141" , "soldRate":0.0112},
    {"itemCode":"Mix-001" , "soldRate":0.01},
    {"itemCode":"7689-L" , "soldRate":0.005},
    {"itemCode":"1111" , "soldRate":0.003}
]

let soldList2 = [
    {"itemCode":"3141" , "soldRate":0.0712},    
    {"itemCode":"7689-L" , "soldRate":0.03},
    {"itemCode":"5555" , "soldRate":0.0234},    
    {"itemCode":"1111" , "soldRate":0.011},
    {"itemCode":"X001" , "soldRate":0.008},
    {"itemCode":"Mix-001" , "soldRate":0.004}
]

let soldList3 = [
    {"itemCode":"5555" , "soldRate":0.0339},   
    {"itemCode":"X001" , "soldRate":0.0221},
    {"itemCode":"3141" , "soldRate":0.0111},  
    {"itemCode":"1111" , "soldRate":0.0089},
    {"itemCode":"Mix-001" , "soldRate":0.0077},  
    {"itemCode":"7689-L" , "soldRate":0.0032}
]

let soldList4 =[
    {"itemCode":"8888" , "soldRate":0.13},   
    {"itemCode":"9999" , "soldRate":0.11},
    {"itemCode":"3141" , "soldRate":0.08},  
    {"itemCode":"1111" , "soldRate":0.07}
]


let soldList5 =[
    {"itemCode":"3141" , "soldRate":0.044},  
    {"itemCode":"1111" , "soldRate":0.011},
    {"itemCode":"8888" , "soldRate":0.0011},   
    {"itemCode":"9999" , "soldRate":0.0001}
]

let soldList6 =[
    {"itemCode":"Mix-001" , "soldRate":0.5678},  
    {"itemCode":"7689-L" , "soldRate":0.546}
    {"itemCode":"8888" , "soldRate":0.323},   
    {"itemCode":"9999" , "soldRate":0.0032},
    {"itemCode":"Mix-001" , "soldRate":0.0022},  
    {"itemCode":"UV-007" , "soldRate":0.0012}
    {"itemCode":"TT-08" , "soldRate":0.0011},  
    {"itemCode":"PP-03" , "soldRate":0.0009}
]

Как вы можете видеть, некоторые списки получили элементы, которых нет в другом списке, и каждый порядок элементов списка равен * 1004.*, и длина каждого list.length также может быть разной.

Таким образом, цель состоит в том, чтобы объединить этот список массивов и обработать их для создания нового списка массивов, как показано ниже:

let finalAllConcateAndSortedByDataSumList = [
    {"itemCode":"Mix-001" , "data": [0.01, 0.004, 0.0077, 0, 0, 0.5678], "dataSum":0.5895},    
    {"itemCode":"7689-L" , "data": [0.005, 0.03, 0.0032, 0, 0, 0.546], "dataSum":0.5842},       
    {"itemCode":"8888" , "data": [0, 0, 0, 0.13, 0.0011, 0.323], "dataSum":0.4541},            
    {"itemCode":"3141" , "data": [0.0112, 0.0712, 0.0111, 0.08, 0.044, 0], "dataSum":0.2175},   
    {"itemCode":"X001" , "data": [0.0789, 0.008, 0.0221, 0, 0, 0.0221], "dataSum":0.1311},   
    {"itemCode":"9999" , "data": [0, 0, 0, 0.11, 0.0001, 0.0032], "dataSum":0.1133},           
    {"itemCode":"5555" , "data": [0.0543, 0.0234, 0.0339, 0, 0, 0], "dataSum":0.1116},         
    {"itemCode":"1111" , "data": [0.003, 0.011, 0.0089, 0.07, 0.011, 0], "dataSum":0.1039},     
    {"itemCode":"UV-007" , "data": [0, 0, 0, 0, 0, 0.0012], "dataSum":0.0012},            
    {"itemCode":"TT-08" , "data": [0, 0, 0, 0, 0, 0.0011], "dataSum":0.0011},                 
    {"itemCode":"PP-03" , "data": [0, 0, 0, 0, 0, 0.0009], "dataSum":0.0009},             
]

Итак, как вы можете видеть, все элементы 'soldRate' из списка 1 2 3 4 5 6, приведенного выше, являются конкатенационными и сгенерированы в новое свойство массива list 'data', положение каждого порядка данных строго такое же, как и в предыдущем списке 1.2 3 4 5 6 .... если значение элемента в позиции не существует ни в одном из первоначального списка, тогда это значение '0'

И, в конце концов, каждый объект в finalAllConcateAndSortedByDataSumList, массив данныхбудет суммироваться в свойство 'dataSum'

Тогда новый список finalAllConcateAndSortedByDataSumList будет desc order by dataSum

Это моя личная попытка заставить его работать, но он не работает ...

let finalAllConcateAndSortedByDataSumList = soldList1.concat(soldList2)
.concat(soldList3)
.concat(soldList4)
.concat(soldList5)
.concat(soldList16).map((item) => {
    let newItem = { itemCode: item.itemCode, data: [item.soldRate], dataSum: Math.sum([item.soldRate])}
    return newItem
}).sort((item) => { return item.dataSum})

Поэтому, если вам нужна помощь, пример кода был бы очень полезен. Спасибо

Answer 1

Вы можете сначала извлечь все уникальные значения itemCode, которые есть в массивах, а затем зациклить их и добавить либо soldRate, либо 0 к результату, если itemCode присутствует в каждом массиве.

let soldList1 = [
  { itemCode: "X001", soldRate: 0.0789 },
  { itemCode: "5555", soldRate: 0.0543 },
  { itemCode: "3141", soldRate: 0.0112 },
  { itemCode: "Mix-001", soldRate: 0.01 },
  { itemCode: "7689-L", soldRate: 0.005 },
  { itemCode: "1111", soldRate: 0.003 }
];

let soldList2 = [
  { itemCode: "3141", soldRate: 0.0712 },
  { itemCode: "7689-L", soldRate: 0.03 },
  { itemCode: "5555", soldRate: 0.0234 },
  { itemCode: "1111", soldRate: 0.011 },
  { itemCode: "X001", soldRate: 0.008 },
  { itemCode: "Mix-001", soldRate: 0.004 }
];

let soldList3 = [
  { itemCode: "5555", soldRate: 0.0339 },
  { itemCode: "X001", soldRate: 0.0221 },
  { itemCode: "3141", soldRate: 0.0111 },
  { itemCode: "1111", soldRate: 0.0089 },
  { itemCode: "Mix-001", soldRate: 0.0077 },
  { itemCode: "7689-L", soldRate: 0.0032 }
];

let soldList4 = [
  { itemCode: "8888", soldRate: 0.13 },
  { itemCode: "9999", soldRate: 0.11 },
  { itemCode: "3141", soldRate: 0.08 },
  { itemCode: "1111", soldRate: 0.07 }
];

let soldList5 = [
  { itemCode: "3141", soldRate: 0.044 },
  { itemCode: "1111", soldRate: 0.011 },
  { itemCode: "8888", soldRate: 0.0011 },
  { itemCode: "9999", soldRate: 0.0001 }
];

let soldList6 = [
  { itemCode: "Mix-001", soldRate: 0.5678 },
  { itemCode: "7689-L", soldRate: 0.546 },
  { itemCode: "8888", soldRate: 0.323 },
  { itemCode: "9999", soldRate: 0.0032 },
  { itemCode: "Mix-001", soldRate: 0.0022 },
  { itemCode: "UV-007", soldRate: 0.0012 },
  { itemCode: "TT-08", soldRate: 0.0011 },
  { itemCode: "PP-03", soldRate: 0.0009 }
];

function sumSoldRates(...arrs) {
  let itemCodes = [].concat(...arrs).reduce((acc, obj) => {
    if (!acc.includes(obj.itemCode)) {
      acc.push(obj.itemCode);
    }
    return acc;
  }, []);

  let result = itemCodes.map(code => {
    let obj = { itemCode: code, data: [], dataSum: 0 };

    arrs.forEach(arr => {
      let item = arr.find(el => el.itemCode === code);

      if (item) {
        obj.data.push(item.soldRate);
        obj.dataSum += item.soldRate;
      } else {
        obj.data.push(0);
      }
    });

    return obj;
  });

  result.sort((a, b) => b.dataSum - a.dataSum);

  return result;
}

let result = sumSoldRates(
  soldList1,
  soldList2,
  soldList3,
  soldList4,
  soldList5,
  soldList6
);
console.log(result);

Answer 2

Я разбил ваш процесс на несколько этапов, так как это проясняет, что вы делаете (и легче отлаживаете).Код может быть не таким компактным или «элегантным», как другие ответы, но я полагаю, что так легче понять.

Вот песочница с кодом , которая показывает это в действии (см.консольный вывод).

const getItemCodes = (list) => {
  return list.map(item => item.itemCode)
}

const getDataValue = (list, itemCode) => {
  let index = list.findIndex(item => item.itemCode === itemCode)
  return (index === -1 ? 0 : list[index].soldRate)
}

const sumArray = (array) => {
  const sum = array.reduce((prev, curr) => {
    return (parseFloat(prev) + parseFloat(curr))
  })
  return sum.toFixed(4)
}

const sortByDataSum = (array) => {
  array.sort((a, b) => {
    if (a.dataSum > b.dataSum) {
      return -1
    } else if (a.dataSum < b.dataSum) {
      return 1
    } else {
      return 0
    }
  })
  return array
}

// concat all item codes together, which will result in duplicates
let allItemCodes = [...getItemCodes(soldList1),
                    ...getItemCodes(soldList2),
                    ...getItemCodes(soldList3),
                    ...getItemCodes(soldList4),
                    ...getItemCodes(soldList5),
                    ...getItemCodes(soldList6)]

// remove duplicate codes
allItemCodes = [...new Set(allItemCodes)] 

let finalList = []

allItemCodes.forEach((code) => {
  let item = {
    'itemCode': code,
    'data': [getDataValue(soldList1, code),
             getDataValue(soldList2, code),
             getDataValue(soldList3, code),
             getDataValue(soldList4, code),
             getDataValue(soldList5, code),
             getDataValue(soldList6, code)]
  }
  item.dataSum = sumArray(item.data)
  finalList.push(item)
})

sortByDataSum(finalList)
console.log(finalList)

Answer 3

Я бы использовал комбинацию массивов в dicts:

let result = {} 
soldList1.concat(soldList2)
.concat(soldList3)
.concat(soldList4)
.concat(soldList5)
.concat(soldList6)
.forEach(item => {
  if(result[item.itemCode]) {
    result[item.itemCode].data.push(item.soldRate);
    result[item.itemCode].dataSum += item.soldRate;
  } else {
    result[item.itemCode] = {data: [item.soldRate], itemCode: item.itemCode, dataSum: item.soldRate};
  }
});
let finalAllConcateAndSortedByDataSumList = Object.values(result).sort((item) => { return item.dataSum})

console.log(finalAllConcateAndSortedByDataSumList);