web-dev-qa-db-fra.com

JavaScript obtient des éléments d'un tableau d'objets qui ne sont pas dans un autre

Je suis nouveau dans la programmation JavaScript et j'ai deux tableaux d'objets qui ont la structure suivante:

myFirstObjArray = [{foo: 1, bar: 1}, {foo: 3, bar: 3}, {foo: 4, bar: 5}];
mySecondObjArray = [{foo: 2}, {foo: 4}, {foo: 5}];

J'ai besoin de deux tableaux distincts contenant les valeurs de la clé foo, le premier contenant ceux qui figurent dans le premier tableau mais pas dans le second, en fonction de la valeur de la clé foo, et le second dans mySecondObjArray mais pas dans myFirstObjArray .

Y at-il un moyen de faire cela sans

for(i=0;i<myFirstObjArray.length;i++)
   for(j=0;j<mySecondObjArray .length;j++)
      {...build first array here}

for(i=0;i<mySecondObjArray .length;i++)
   for(j=0;j<myFirstObjArray.length;j++)
      {...build second array here}

? Peut-être que ma question est une copie de celle que je n’ai pas trouvée, alors veuillez être douce.

Production attendue:

firstArray = [{foo: 1}, {foo: 3}];
secondArray = [{foo: 2}, {foo: 5}];
javascriptarraysjavascript-objects
17
Dana

Vous pouvez simplement filtrer les éléments d'un tableau en définissant la condition en fonction d'éléments de l'autre tableau, comme.

var myFirstObjArray = [{foo: 1, bar: 1}, {foo: 3, bar: 3}, {foo: 4, bar: 5}],
    mySecondObjArray = [{foo: 2}, {foo: 4}, {foo: 5}],
    
    firstArray  = myFirstObjArray.filter(o=> !mySecondObjArray.some(i=> i.foo === o.foo));
    
    secondArray  = mySecondObjArray.filter(o=> !myFirstObjArray.some(i=> i.foo === o.foo));
    
    console.log(firstArray.map(o=> {return {'foo' :  o.foo}}))
    console.log(secondArray.map(o=> {return {'foo' :  o.foo}}))

Ps: 

La méthode some() teste si au moins un élément du tableau réussit le test mis en oeuvre par la fonction fournie. Et j'ai ajouté une fonction qui vérifie simplement si la propriété foo existe dans l'autre tableau avec la même valeur pour pouvoir filtrer à partir du premier tableau.

À la fin, vous pouvez utiliser .map pour filtrer les paires de valeurs de clé souhaitées.

J'espère que ça a du sens

En savoir plus sur .some et filter

10
George Bailey

Voici une petite solution avec seulement filter et une map avec l'attribut foo.

const myFirstObjArray = [{foo: 1, bar: 1}, {foo: 3, bar: 3}, {foo: 4, bar: 5}];
const mySecondObjArray = [{foo: 2}, {foo: 4}, {foo: 5}];

const exclude = (arr1, arr2) => arr1.filter(o1 => arr2.map(o2 => o2.foo).indexOf(o1.foo) === -1);

console.log(exclude(myFirstObjArray, mySecondObjArray));
console.log(exclude(mySecondObjArray, myFirstObjArray));

7
sjahan

Vous pouvez filtrer en levant les yeux.

const unique = a => o => !a.some(({ foo }) => o.foo === foo);

var first = [{foo: 1, bar: 1}, {foo: 3, bar: 3}, {foo: 4, bar: 5}],
    second = [{foo: 2}, {foo: 4}, {foo: 5}],
    uniqueFirst = first.filter(unique(second)),
    uniqueSecond = second.filter(unique(first));
    
console.log(uniqueFirst);
console.log(uniqueSecond);
.as-console-wrapper { max-height: 100% !important; top: 0; }

1
Nina Scholz

Vous pouvez créer une fonction réutilisable pour empêcher la duplication de code. Il suffit de basculer sur le paramètre de fonction. Notez également que la boucle interne est une boucle for simple afin que nous puissions utiliser break et éviter les vérifications inutiles.

var firstArray = [];
var secondArray = [];
var myFirstObjArray = [{foo: 1, bar: 1}, {foo: 3, bar: 3}, {foo: 4, bar: 5}];
var mySecondObjArray = [{foo: 2}, {foo: 4}, {foo: 5}];

function difference(myFirstObjArray, mySecondObjArray){
  var firstArray = [];
  myFirstObjArray.forEach((obj)=>{
   var match = false;
   for(var i=0; i<mySecondObjArray.length; i++){
     var secondObj = mySecondObjArray[i];
     if(obj.foo === secondObj.foo){
       match = true;
       break;
     }
   }
   if(!match){
     firstArray.Push({'foo': obj.foo});
   }
  });
  return firstArray;
}


console.log(difference(myFirstObjArray, mySecondObjArray));

console.log(difference(mySecondObjArray, myFirstObjArray));

1
Ankit Agarwal

ES5 sans utiliser de grosse flèche,

var myFirstObjArray = [{foo: 1, bar: 1}, {foo: 3, bar: 3}, {foo: 4, bar: 5}],
    mySecondObjArray = [{foo: 2}, {foo: 4}, {foo: 5}],
    
    firstArray  = myFirstObjArray.filter(function(o) { return !mySecondObjArray.some(function(i) { return i.foo === o.foo})});
     
    secondArray  = mySecondObjArray.filter(function(o) { return !myFirstObjArray.some(function(i) { return i.foo === o.foo})});
    
    console.log(firstArray)
    console.log(secondArray)

1
Antguider