donné deux tableaux:
combinedAndFiltered = [
{id: "valueA", other: 54, prop: 123},
{id: "valueB", other: 98, prop: 456}
]
8 Réponses :
inputOne.map((a, i) => ({...a, ...(inputTwo.filter(x => x.id === a.id)[0])}))
Cette solution suppose que les deux tableaux auront toujours exactement le même index.
Pas d'inquiétude! 🙌
Et si l'un des objets de la première série n'existe pas dans la seconde?
Les choses deviennent désordonnées, mais il y a une solution facile pour cela, aussi, bien sûr ... INTOPTONE.MAP ((A, I) => ({... A, ... (INPUTTWO.FILTER (x => x.id === a.id) [0] || {})}))
Mais autant que je puisse dire en fonction de la question posée, seuls les éléments existants dans les deux ensembles doivent être émis. Cette solution émettrait toujours l'élément si elle n'existe pas dans le deuxième ensemble, elle ne la fusionnera tout simplement pas.
Solution simple en utilisant pour :
Pourquoi continuer itération INPUTTWO une fois qu'un match a été trouvé?
Vous pouvez utiliser la carte et filtrer pour résoudre ce problème. Si je ne me trompe pas sur ce que vous voulez, cela pourrait être utile
Convertissez le 1er tableau en un carte A> Utiliser array.reduce ( ) code> , puis réduisez la 2e matrice et si l'objet est trouvé sur la carte, obtenez l'objet de la carte, combinez les objets et ajoutez à l'accumulateur:
p>
const combine = (arr1, arr2) => {
const arr1Map = arr1.reduce((m, o) => m.set(o.id, o), new Map)
return arr2.reduce((r, o) => arr1Map.has(o.id) ?
[...r, { ...o, ...arr1Map.get(o.id) }] : r
, [])
}
const inputOne = [{id: "valueA", prop: 123},{id: "valueB", prop: 456}]
const inputTwo = [{id: "valueA", other: 54},{id: "valueB", other: 98},{id: "valueC", other: 11}]
const result = combine(inputOne, inputTwo)
console.log(result)Pourquoi créer un nouveau tableau à chaque fois au lieu de pousser sur l'accumulateur existant?
Programmation fonctionnelle Immantiabilité - L'accumulateur doit être remplacé par une nouvelle valeur non mutée. Si vous mutez l'accumulateur, vous utilisez la réduction de la boucle. Cependant, comme vous l'avez mentionné, c'est un peu gaspillé. Selon le cas, vous voudrez peut-être réutiliser l'accumulateur (de très grandes matrices par exemple).
Je pense que c'est un peu d'étirement. Avez-vous des références pour soutenir cette déclaration? Pourquoi la mutation de l'accumulateur serait-elle une mauvaise chose?
Cela devrait faire l'astuce (en supposant que le p> Inputone code> agit comme une source);
const inputOne = [
{id: "valueA", prop: 123},
{id: "valueB", prop: 456}
]
const inputTwo = [
{id: "valueA", other: 54},
{id: "valueB", other: 98},
{id: "valueC", other: 11}
]
const mergeArrays = (first, second) => {
return first.map((firstItem) => {
const obj = second.find((secondItem) => secondItem.id === firstItem.id);
return {...firstItem, ...obj};
});
};
const combinedArrays = mergeArrays(inputOne, inputTwo);
console.log(combinedArrays);
Et si l'un des objets de la première série n'existe pas dans la seconde?
Eh bien, vous pouvez d'abord construire un objet et l'utiliser pour obtenir les autres valeurs tout en itérant sur l'autre matrice avec un p> .map code>
const inputOne = [
{id: "valueA", prop: 123},
{id: "valueB", prop: 456}
],
inputTwo = [
{id: "valueA", other: 54},
{id: "valueB", other: 98},
{id: "valueC", other: 11}
],
ids = {};
inputTwo.forEach(function (o) {
ids[o.id] = o;
});
var res = inputOne.map(function (o) {
return {
other: ids[o.id].other,
prop: o.prop,
id: o.id
};
});
console.log(res)
Et si l'un des objets de la première série n'existe pas dans la seconde?
Je pense que toutes les solutions seront à peu près toutes les solutions seront une variété de double itération, que ce soit par boucle, carte ou filtre. L'autre sens différent de ceux énumérés ci-dessus consiste à utiliser une bibliothèque comme Lodash. Cette réponse donne déjà un très bon exemple du Unionby fonction .
Cette solution suppose qu'il n'y aura que deux ensembles, et la propriété Vous pouvez créer une intersection de deux ensembles d'objets fusionnés basés sur une propriété commune ( Cette méthode renvoie un nouvel ensemble contenant des objets fusionnés que l'on trouve dans les deux ensembles. Si un objet est manquant à partir de l'un ou l'autre définir, il ne sera pas inclus dans la sortie. P> p> ID code> est unique dans chaque ensemble. ID code>) par: p>
const inputOne = [ {id: "valueA", prop: 123}, {id: "valueB", prop: 456}, {id: "valueD", prop: 789} ]
const inputTwo = [ {id: "valueA", other: 54}, {id: "valueB", other: 98}, {id: "valueC", other: 11} ]
function intersectAndMerge(a, b) {
return a.reduce((accumulator, { id, ...props }) => {
const match = b.find(e => e.id === id)
if(match !== undefined) {
accumulator.push({ ...match, ...props })
}
return accumulator
}, [])
}
console.log(intersectAndMerge(inputOne, inputTwo))