eliminar - JavaScript obtiene elementos de una matriz de objetos que no están en otra

eliminar un elemento de un array javascript

Question

Soy nuevo en la programación de JavaScript y tengo dos matrices de objetos que tienen la siguiente estructura:

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

Necesito obtener dos arreglos separados que contengan los valores de key foo , el primero que contenga los que están en el primer array pero no en el segundo, según el valor de key foo , y el segundo en mySecondObjArray pero no en myFirstObjArray .

¿Hay una manera de hacer esto sin

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}

? Tal vez mi pregunta sea un duplicado que no encontré, así que por favor sea amable.

Rendimiento esperado:

firstArray = [{foo: 1}, {foo: 3}];
secondArray = [{foo: 2}, {foo: 5}];

Answer 1

Aquí hay una pequeña solución con solo un filter y un map con el atributo 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));

Answer 2

ES5 sin usar la flecha de grasa,

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)

Answer 3

Podrías filtrar por mirar hacia arriba.

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; }

Answer 4

Puede crear una función reutilizable para evitar la duplicación de código. Simplemente cambie al parámetro de función. También tenga en cuenta que el bucle interno es simple for bucle, for lo que podemos usar break y evitar comprobaciones innecesarias.

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));

Answer 5

Puede simplemente filtrar los elementos de una matriz configurando la condición en función de los elementos de otra matriz, como.

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}}))

PD:

El método some() comprueba si al menos un elemento de la matriz pasa la prueba implementada por la función proporcionada. Y he agregado una función que solo comprueba si la propiedad foo existe en la otra matriz con el mismo valor para poder filtrar desde la primera matriz.

Al final, puede usar .map para filtrar los pares de valores de clave deseados

Espero que tenga sentido

Leer más sobre .some y filter