Метод слияния / объединения двух или более массивов объектов по ключу javascript

Question

Я пытаюсь объединить два или более массивов, но они не работают так, как я хотел.

У меня есть два массива arrCustomer и arrCustomerDetails. Оба массива имеют CustomerID в качестве ключа, но мне нужны все значения из arrCustomerDetails с объединенными свойствами из массива arrCustomer. Я попытался использовать _merge, но он дал мне только счет arrCustomer.

Пример:

const arrCustomer = [
    { id: 1, name: "a" },
    { id: 2, name: "b" },
    { id: 3, name: "c" }
];

const arrCustomerDetail = [
    { id: 1, location: "jupiter", group: "C" },
    { id: 1, location: "venus", group: "G" },
    { id: 2, location: "mars", group: "D" }
];

const expecteResult = [
    { id: 1, name: "a", location: "jupiter", group: "C" },
    { id: 1, name: "a", location: "venus", group: "G" },
    { id: 2, name: "b", location: "mars", group: "D" },
    { id: 3, name: "c"  location: "", group: "" }
]

Это работает, но медленно:

 let combinedData = [];
      arrCustomerDetail.map((element) => {
        combinedData.push({
          ...element,
          ...arrCustomer.find(
            (customer) => customer.id=== element.id
          ),
        });
      });

      arrCustomer.map((customer) => {
        if (
          combinedData.findIndex(
            (detail) => detail.id=== customer.id
          ) === -1
        )
          combinedData.push({
            ...customer,
          });
      });

Всем спасибо

Answer 1

Loda sh на самом деле не поддерживает объединение списков вместе и отключение для этого свойства объекта. Я бы сделал что-то вроде этого и выбрал бы свою собственную функцию merge().

[Примечание: эта merge() функция работает за линейное время - O (n).]

const _ = require('lodash');

function merge(selectKey, keyComparer, ...lists) {
  const map = new Map();

  for (const list of lists) {
    for (const item of list) {

      const key = selectKey(item);
      let value = map.get(key);

      if (value === undefined) {
        map.set(key, [item]);
      }
      else {
        value.push(item);
      }
    }
  }

  const merged = Array.from(map.keys())
    .sort(keyComparer)
    .map( k => _.merge( {}, ...map.get(k) ) );
  return merged;
}

где * selectKey - это функция, которая передает объекту и возвращает его ключ, а * keyComparer - это функция, которая принимает два ключа, x и y и возвращает числовое указание, меньше ли x чем, равно или больше чем `y '. По соглашению возвращаемые значения

• <0 указывают, что <code>x меньше y
• возвращаемые значения 0 указывают, что x и y равны
• возвращаемые значения> 0 означают, что x больше, чем y

Как только вы это получите, это легко:

const arr1 = [
  { id: 1, name: 'a' },
  { id: 2, name: 'b' },
  { id: 3, name: 'c' },
];
const arr2 = [
  { id: 1, location: 'jupiter', group: 'C' },
  { id: 4, location: 'venus', group: 'E' },
  { id: 2, location: 'mars', group: 'D' },
];

const idComparer = (x, y) => Math.sign(x - y);
const selectKey = o => o.id;

const merged = merge(selectKey, idComparer, arr1, arr2 );

Возвращаемое значение здесь

[
  { id: 1 , name: "a" , location: "jupiter" , group: "C" } ,
  { id: 2 , name: "b" , location: "mars"    , group: "D" } ,
  { id: 3 , name: "c"                                    } ,
  { id: 4 ,             location: "venus"   , group: "E" } ,
]

Answer 2

(Объединить / Объединить / Объединить) несколько массивов объектов, объединенных ключом.

Обновить , также можно сделать это объединение во время выполнения для более одного массива. вам просто нужно определить первичную матрицу и создать фильтр на матрице матриц, следуйте этому примеру в.

Я надеюсь, что этот пример поможет, он отлично сработал, для приведенных вами примеров просто отредактируйте пример ниже и вы увидите результат, я даже пошутил, выполняя слияние всего, и это сработало правильно. Помня, что он всегда будет рассматривать первичную матрицу как основу.

"use strict";
const arrCustomer1 = [
    { id: 1, name: "a" },
    { id: 2, name: "b" }
];
const arrCustomerDetail1 = [
    { id: 1, location: "jupiter", group: "C" },
    { id: 2, location: "mars", group: "D" }
];
const wantedArray1 = [
    { id: 1, name: "a", location: "jupiter", group: "C" },
    { id: 2, name: "b", location: "mars", group: "D" }
];
const arrCustomer2 = [
    { id: 1, name: "a" },
    { id: 2, name: "b" },
    { id: 3, name: "c" }
];
const arrCustomerDetail2 = [
    { id: 1, location: "jupiter", group: "C" },
    { id: 2, location: "mars", group: "D" }
];
const wantedArray2 = [
    { id: 1, name: "a", location: "jupiter", group: "C" },
    { id: 2, name: "b", location: "mars", group: "D" },
    { id: 3, name: "c" } //or blanks for the other fields location group
];
const arrCustomer3 = [
    { id: 1, name: "a" },
    { id: 2, name: "b" },
    { id: 3, name: "c" }
];
const arrCustomerDetail3 = [
    { id: 1, location: "jupiter", group: "C" },
    { id: 1, location: "venus", group: "G" },
    { id: 2, location: "mars", group: "D" }
];
const wantedArray3 = [
    { id: 1, name: "a", location: "jupiter", group: "C" },
    { id: 1, name: "a", location: "venus", group: "G" },
    { id: 2, name: "b", location: "mars", group: "D" },
    { id: 3, name: "c" } //or blanks for the other fields location group
];

const combinedArrays = [arrCustomerDetail1,
    wantedArray1,
    arrCustomer2,
    arrCustomerDetail2,
    wantedArray2,
    arrCustomer3,
    arrCustomerDetail3,
    wantedArray3];

function joinArrByKey(primaryArr, combinedArrays, key) {
    return primaryArr.map((eArr1) => {
        const filter = new Array().concat.apply([], combinedArrays).filter((eArr2) => eArr2.id === eArr1[key]);
        return filter.length ? Object.assign({}, eArr1, ...filter) : eArr1;
    });
}

console.log(joinArrByKey(arrCustomer1, combinedArrays, 'id'));

console.log(joinArrByKey(arrCustomer2, combinedArrays, 'id'));

console.log(joinArrByKey(arrCustomer3, combinedArrays, 'id'));

(Объединить / Объединить / Объединить) Только для двух массивов по идентификатору ключа, быстрее.

вы можете создать свою собственную функцию вот так и поделитесь им со всеми приложениями вместо _loda sh.

"use strict";
const arr1 = [
    { id: 1, name: "a" },
    { id: 2, name: "b" },
];
const arr2 = [
    { id: 1, price: 10 },
    { id: 2, price: 20 },
];
function joinArrById(primaryArr, secondArray) {
    return primaryArr.map((eArr1) => {
        const find = secondArray.find((eArr2) => eArr2.id === eArr1.id);
        return find ? Object.assign(Object.assign({}, eArr1), find) : eArr1;
    });
}
console.log(joinArrById(arr1, arr2));

Если вышеприведенное решение вам не подходит, используйте _loda sh.

import * as _ from "lodash";

const arr1 = [
  { id: 1, name: "a" },
  { id: 2, name: "b" },
];
const arr2 = [
  { id: 1, price: 10 },
  { id: 2, price: 20 },
];

var arrJoin = _.map(arr1, (obj: { id: number }) => {
  return _.assign(
    obj,
    _.find(arr2, {
      id: obj.id,
    })
  );
});

console.log(arrJoin);