J'essaye de comparer deux tableaux différents ensemble, un précédent et un courant. Le jeu de données précédent contient:
Items_Curr.map(e => { e.member_name });
Le nouvel ensemble contient:
Items_Curr.filter(function(item) { return !Items_Prev.includes(item); });
Donc, comme vous pouvez le voir ici, Test1 a obtenu un nouvel élément . J'ai essayé de comparer ces deux tableaux ensemble de plusieurs façons, mais en vain.
Les méthodes que j'ai essayées:
Celui-ci renvoie simplement l'ensemble du tableau. Pas d'éléments individuels.
[
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"},
{"member_name":"Test1","item":"Shield"}
]
Cette méthode ne renvoie que 3 éléments non définis.
[
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"}
]
J'ai cherché un moyen de le faire, mais d'autres articles expliquent simplement les méthodes pour déterminer le changement dans des tableaux plus simples.
EG [a, b] - [a, b, c]
Mise à jour:
Le but final est que j'aimerais créer un nouveau tableau «NewItems» qui contiendrait un tableau de tous les noms et éléments nouvellement ajoutés. Donc, s'il y a un changement, j'aimerais qu'il soit diffusé, s'il n'y a pas de changement, alors ignorez jusqu'à ce que la fonction ait été exécutée à nouveau.
4 Réponses :
Si vous savez que vos propriétés seront toujours dans le même ordre , vous pouvez utiliser JSON.stringify pour sérialiser les objets et comparer les résultats:
p >
const Items_Prev = [
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"}
]
const Items_Curr = [
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"},
{"member_name":"Test1","item":"Shield"}
]
const serialized_Items_Prev = Items_Prev.map(i => JSON.stringify(i));
const NewItems = Items_Curr.filter(i => !serialized_Items_Prev.includes(JSON.stringify(i)));
console.log(NewItems);
Je pense que vous devez faire quelque chose de ce genre si les clés des objets ne changent pas et que de nouveaux éléments ne sont ajoutés qu'en dernier lieu.
const array1 = [
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"}
];
const array2 = [
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"},
{"member_name":"Test1","item":"Shield"}
];
const compare = (array1, array2) => {
if (array1.length !== array2.length) {
return false;
}
for (let i = 0; i < array1.length; i += 1) {
if (array1[i].member_name !== array2[i].member_name) {
return false;
}
if (array1[i].item !== array2[i].item) {
return false;
}
}
return true;
};
console.log(compare(array1, array2));
Si l'ordre des objets change, vous devez écrire un algorithme de tri pour le tableau, puis comparer.
qu'est-ce que les éléments du tableau ne sont pas dans l'ordre?
Je pense que c'est une excellente réponse, mais pour des tableaux plus grands, cela créerait une charge assez importante, n'est-ce pas?
J'aime aussi votre comparaison des longueurs de tableaux, cela contribue à l'impact sur les performances!
@ T3rr11 il le fera. Mais la première réponse consiste uniquement à comparer des chaînes. Si les commandes changent, cela causera des problèmes.
@ T3rr11 filtre essentiellement et certains utilisent également des boucles à l'intérieur. Donc, ma réponse est d'utiliser uniquement une boucle unique et la boucle se brise également dès qu'elle obtient le diff. cette fonction a l'air grosse mais je pense qu'elle est plus efficace.
Ahh assez bien, oui, j'ai eu le sentiment que certains filtres font de même, mais c'est juste beaucoup plus propre de les utiliser. Rien de mal avec votre réponse, cela devrait fonctionner exactement de la même manière par l'apparence des choses: D
De manière réaliste, vous voulez faire quelque chose comme:
const arr1 = [
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"}
];
const arr2 = [
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"},
{"member_name":"Test1","item":"Shield"}
];
const res = arr2.filter(({member_name:a, item:x}) => !arr1.some(({member_name:b, item:y}) => a === b && x === y));
console.log(res); Ce qui vous donnerait c . Vous pouvez y parvenir en utilisant .some , qui vous permet de "personnaliser" la fonctionnalité d'inclusion.
Voir l'exemple ci-dessous:
[a, b, c] - [a, b]
Cela fonctionne aussi comme un charme, je ne savais pas que vous pouviez ajouter des éléments {} dans un filtre ou une ligne.
@ T3rr11 pas de soucis, c'est ce qu'on appelle affectation de déstructuration < / a>
Vous pouvez y parvenir en utilisant les méthodes de tableau filter () et findIndex ()
Filtrer le tableau actuel sans la fonction findIndex () sur le tableau précédent
var prevItems = [
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"}
]
var currItems = [
{"member_name":"Test1","item":"Sword"},
{"member_name":"Test2","item":"Sword"},
{"member_name":"Test1","item":"Shield"},
{"member_name":"Test2","item":"Shield"}
]
var newItems = currItems.filter(function(currItem ){
return prevItems.findIndex(function(prevItem){
return prevItem.member_name == currItem.member_name &&
prevItem.item == currItem.item
}) == -1
})
console.log(newItems)
Vous devez écrire votre propre méthode de comparaison.
Je pense que votre question manque d'informations. Quelle est la sortie souhaitée? À quoi voulez-vous qu'il ressemble. Par exemple, voulez-vous savoir les nouveautés ou supprimer les doublons?
Comme @Shubham l'a dit, vous allez devoir comparer chaque paire clé / valeur dans chaque élément, puis pousser les éléments uniques dans un nouveau tableau.
J'ai mis à jour le post @Sinaesthetic également assez juste, comment comparer chaque valeur de clé, serait-ce via une boucle for pour chaque élément? Mon tableau principal contient 270 éléments. Cela signifie-t-il qu'il doit scanner les 230 éléments 231 fois s'il y a un nouvel élément? Cela semble très gourmand en charge.
Il n'y a pas de tableau JSON. JSON est toujours une chaîne. Vous disposez d'un tableau d'objets.
Aussi, qu'est-ce que «unique»? Techniquement, les 3 objets des deux tableaux sont une combinaison unique.
Balise
jsonsupprimée. JavaScript Object Notation est une représentation sous forme de chaîne d'objets JavaScript. Les objets JavaScript sont des objets JavaScript, pas JSON.