Entfernen Sie alle in einem anderen Array enthaltenen Elemente

Ich suche nach einer effizienten Möglichkeit, alle Elemente aus einem Javascript-Array zu entfernen, wenn sie in einem anderen Array vorhanden sind.

// If I have this array:
var myArray = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];

// and this one:
var toRemove = ['b', 'c', 'g'];

Ich möchte myArray bearbeiten, um es in diesem Zustand zu belassen: ['a', 'd', 'e', 'f']

Mit jQuery verwende ich grep()und inArray(), was gut funktioniert:

myArray = $.grep(myArray, function(value) {
    return $.inArray(value, toRemove) < 0;
});

Gibt es eine reine Javascript-Möglichkeit, dies ohne Schleifen und Spleißen zu tun?

Verwenden Sie die Array.filter()Methode:

myArray = myArray.filter( function( el ) {
  return toRemove.indexOf( el ) < 0;
} );

Kleine Verbesserung, da die Browserunterstützung für Array.includes()zugenommen hat:

myArray = myArray.filter( function( el ) {
  return !toRemove.includes( el );
} );

Nächste Anpassung mit Pfeilfunktionen :

myArray = myArray.filter( ( el ) => !toRemove.includes( el ) );

Die filterMethode sollte den Trick machen:

const myArray = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
const toRemove = ['b', 'c', 'g'];

// ES5 syntax
const filteredArray = myArray.filter(function(x) { 
  return toRemove.indexOf(x) < 0;
});

Wenn Ihr toRemoveArray groß ist, kann diese Art von Suchmuster ineffizient sein. Es wäre performanter, eine Karte so zu erstellen, dass Lookups O(1)eher als sind O(n).

const toRemoveMap = toRemove.reduce(
  function(memo, item) {
    memo[item] = memo[item] || true;
    return memo;
  },
  {} // initialize an empty object
);

const filteredArray = myArray.filter(function (x) {
  return toRemoveMap[x];
});

// or, if you want to use ES6-style arrow syntax:
const toRemoveMap = toRemove.reduce((memo, item) => ({
  ...memo,
  [item]: true
}), {});

const filteredArray = myArray.filter(x => toRemoveMap[x]);

Wenn Sie ein Array von Objekten verwenden. Dann sollte der folgende Code die Magie ausführen, wobei eine Objekteigenschaft das Kriterium zum Entfernen doppelter Elemente ist.

Im folgenden Beispiel wurden Duplikate entfernt, um den Namen jedes Elements zu vergleichen.

Versuchen Sie dieses Beispiel. http://jsfiddle.net/deepak7641/zLj133rh/

var myArray = [
  {name: 'deepak', place: 'bangalore'}, 
  {name: 'chirag', place: 'bangalore'}, 
  {name: 'alok', place: 'berhampur'}, 
  {name: 'chandan', place: 'mumbai'}
];
var toRemove = [
  {name: 'deepak', place: 'bangalore'},
  {name: 'alok', place: 'berhampur'}
];

for( var i=myArray.length - 1; i>=0; i--){
 	for( var j=0; j<toRemove.length; j++){
 	    if(myArray[i] && (myArray[i].name === toRemove[j].name)){
    		myArray.splice(i, 1);
    	}
    }
}

alert(JSON.stringify(myArray));

Lodash hat auch hierfür eine Utility-Funktion: https://lodash.com/docs#difference

ECMAScript 6-Sätze können zur Berechnung der verschiedenen Elemente von zwei Arrays verwendet werden:

const myArray = new Set(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
const toRemove = new Set(['b', 'c', 'g']);

const difference = new Set([...myArray].filter((x) => !toRemove.has(x)));

console.log(Array.from(difference)); // ["a", "d", "e", "f"]

Ich habe gerade implementiert als:

Array.prototype.exclude = function(list){
        return this.filter(function(el){return list.indexOf(el)<0;})
}

Benutzen als:

myArray.exclude(toRemove);

Wenn Sie kein neues ES5-Material verwenden können, filterstecken Sie wahrscheinlich in zwei Schleifen:

for( var i =myArray.length - 1; i>=0; i--){
  for( var j=0; j<toRemove.length; j++){
    if(myArray[i] === toRemove[j]){
      myArray.splice(i, 1);
    }
  }
}

var myArray = [
  {name: 'deepak', place: 'bangalore'}, 
  {name: 'chirag', place: 'bangalore'}, 
  {name: 'alok', place: 'berhampur'}, 
  {name: 'chandan', place: 'mumbai'}
];
var toRemove = [
  {name: 'deepak', place: 'bangalore'},
  {name: 'alok', place: 'berhampur'}
];



myArray = myArray.filter(ar => !toRemove.find(rm => (rm.name === ar.name && ar.place === rm.place) ))

Jetzt im Einzeiler-Geschmack:

console.log(['a', 'b', 'c', 'd', 'e', 'f', 'g'].filter(x => !~['b', 'c', 'g'].indexOf(x)))

Funktioniert möglicherweise nicht mit alten Browsern.

Sie können _.differenceBy von lodash verwenden

const myArray = [
  {name: 'deepak', place: 'bangalore'}, 
  {name: 'chirag', place: 'bangalore'}, 
  {name: 'alok', place: 'berhampur'}, 
  {name: 'chandan', place: 'mumbai'}
];
const toRemove = [
  {name: 'deepak', place: 'bangalore'},
  {name: 'alok', place: 'berhampur'}
];
const sorted = _.differenceBy(myArray, toRemove, 'name');

Beispielcode hier: CodePen

Wie wäre es mit dem einfachsten:

var myArray = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
var toRemove = ['b', 'c', 'g'];

var myArray = myArray.filter((item) => !toRemove.includes(item));
console.log(myArray)

Der richtige Weg, um alle in einem anderen Array enthaltenen Elemente zu entfernen, besteht darin, das Quellarray zum gleichen Objekt zu machen, indem nur Elemente entfernt werden:

Array.prototype.removeContained = function(array) {
  var i, results;
  i = this.length;
  results = [];
  while (i--) {
    if (array.indexOf(this[i]) !== -1) {
      results.push(this.splice(i, 1));
    }
  }
  return results;
};

Oder CoffeeScript-Äquivalent:

Array.prototype.removeContained = (array) ->
  i = @length
  @splice i, 1 while i-- when array.indexOf(@[i]) isnt -1

Testen in Chrome Dev Tools:

19: 33: 04.447 a = 1
19: 33: 06.354 b = 2
19: 33: 07.615 c = 3
19: 33: 09.981 arr = [a, b, c]
19: 33: 16.460 arr1 = arr

19: 33: 20.317 arr1 === arr
19: 33: 20.331 wahr

19: 33: 43.592 arr.removeContained ([a, c])
19: 33: 52.433 arr === arr1
19: 33: 52.438 true

Die Verwendung des Angular-Frameworks ist der beste Weg, um den Zeiger auf das Quellobjekt zu behalten, wenn Sie Sammlungen ohne große Anzahl von Beobachtern aktualisieren und neu laden.

Ich erstelle die Logik ohne integrierte Methoden. Bitte teilen Sie mir Optimierungen oder Änderungen mit. Ich habe im JS-Editor getestet, dass es gut funktioniert.

var myArray = [
            {name: 'deepak', place: 'bangalore'},
            {name: 'alok', place: 'berhampur'},
            {name: 'chirag', place: 'bangalore'},
            {name: 'chandan', place: 'mumbai'},

        ];
        var toRemove = [

            {name: 'chirag', place: 'bangalore'},
            {name: 'deepak', place: 'bangalore'},
            /*{name: 'chandan', place: 'mumbai'},*/
            /*{name: 'alok', place: 'berhampur'},*/


        ];
        var tempArr = [];
        for( var i=0 ; i < myArray.length; i++){
            for( var j=0; j<toRemove.length; j++){
                var toRemoveObj = toRemove[j];
                if(myArray[i] && (myArray[i].name === toRemove[j].name)) {
                    break;
                }else if(myArray[i] && (myArray[i].name !== toRemove[j].name)){
                        var fnd = isExists(tempArr,myArray[i]);
                        if(!fnd){
                            var idx = getIdex(toRemove,myArray[i])
                            if (idx === -1){
                                tempArr.push(myArray[i]);
                            }

                        }

                    }

                }
        }
        function isExists(source,item){
            var isFound = false;
            for( var i=0 ; i < source.length; i++){
                var obj = source[i];
                if(item && obj && obj.name === item.name){
                    isFound = true;
                    break;
                }
            }
            return isFound;
        }
        function getIdex(toRemove,item){
            var idex = -1;
            for( var i=0 ; i < toRemove.length; i++){
                var rObj =toRemove[i];
                if(rObj && item && rObj.name === item.name){
                    idex=i;
                    break;
                }
            }
            return idex;
        }