Ich habe ein Array von Zahlen und verwende die Methode .push(), um Elemente hinzuzufügen.

Gibt es eine einfache Möglichkeit, ein bestimmtes Element aus einem Array zu entfernen?

Das Äquivalent von so etwas wie -

array.remove(number);

Ich muss core JavaScript verwenden - Frameworks sind nicht erlaubt.

10193
Walker 24 Apr. 2011 im 02:17

29 Antworten

Beste Antwort

Suchen Sie das index des Array-Elements, das Sie entfernen möchten, mit indexOf und entfernen Sie diesen Index mit splice.

Die splice () -Methode ändert den Inhalt eines Arrays, indem vorhandene Elemente entfernt und / oder neue Elemente hinzugefügt werden.

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

Der zweite Parameter von splice ist die Anzahl der zu entfernenden Elemente. Beachten Sie, dass splice das vorhandene Array ändert und ein neues Array zurückgibt, das die entfernten Elemente enthält.

11527
laurent 29 Dez. 2019 im 19:33

Performance

Heute (09.12.2019) führe ich Leistungstests unter macOS 10.13.6 (High Sierra) für ausgewählte Lösungen durch. Ich zeige delete (A), aber ich verwende es nicht im Vergleich zu anderen Methoden, weil es leeren Raum im Array gelassen hat.

Die Schlussfolgerungen

  • Die schnellste Lösung ist array.splice (C) (außer Safari für kleine Arrays, bei denen es das zweite Mal gibt).
  • Für große Arrays ist array.slice+splice (H) die schnellste unveränderliche Lösung für Firefox und Safari. Array.from (B) ist in Chrome am schnellsten
  • veränderbare Lösungen sind normalerweise 1,5x-6x schneller als unveränderlich
  • Bei kleinen Tabellen auf Safari ist die veränderliche Lösung (C) überraschenderweise langsamer als die unveränderliche Lösung (G).

Einzelheiten

In Tests entferne ich das mittlere Element auf verschiedene Weise aus dem Array. Die A, C -Lösungen sind vorhanden. Die Lösungen B, D, E, F, G, H sind unveränderlich.

Ergebnisse für Array mit 10 Elementen

Enter image description here

In Chrome ist array.splice (C) die schnellste direkte Lösung. Das array.filter (D) ist die schnellste unveränderliche Lösung. Das langsamste ist array.slice (F). Sie können den Test auf Ihrem Computer hier durchführen.

Ergebnisse für ein Array mit 1.000.000 Elementen

Enter image description here

In Chrome ist array.splice (C) die schnellste In-Place-Lösung (delete (C) ist ähnlich schnell - es wurde jedoch ein leerer Steckplatz im Array gelassen (sodass keine vollständige Lösung ausgeführt wird) entfernen')). Das array.slice-splice (H) ist die schnellste unveränderliche Lösung. Das langsamste ist array.filter (D und E). Sie können den Test auf Ihrem Computer hier durchführen.

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);
This snippet only presents code used in performance tests - it does not perform tests itself.

Vergleich für Browser: Chrome v78.0.0, Safari v13.0.4 und Firefox v71.0.0

Enter image description here

20
Peter Mortensen 8 März 2020 im 17:33

Basierend auf all den Antworten, die hauptsächlich richtig waren und die vorgeschlagenen Best Practices berücksichtigten (insbesondere, wenn Array.prototype nicht direkt verwendet wurde), kam ich zu dem folgenden Code:

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

  for (var i = arrCopy.length - 1; i >= 0; i--) {
    if (excludedValues.indexOf(arrCopy[i]) > -1) {
      arrCopy.splice(i, 1);
    }
  }

  return arrCopy;
}

Als ich die obige Funktion überprüfte, stellte ich fest, dass es einige Leistungsverbesserungen geben könnte, obwohl sie einwandfrei funktioniert. Auch die Verwendung von ES6 anstelle von ES5 ist ein viel besserer Ansatz. Zu diesem Zweck ist dies der verbesserte Code:

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

Wie benutzt man:

const arr = [1,2,3,4,5,"name", false];

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

Ich schreibe gerade einen Blog-Beitrag, in dem ich mehrere Lösungen für Array ohne Probleme verglichen und die Ausführungszeit verglichen habe. Ich werde diese Antwort mit dem Link aktualisieren, sobald ich diesen Beitrag beendet habe. Um Sie wissen zu lassen, habe ich das Obige mit dem von lodash ohne verglichen und falls der Browser Map unterstützt, schlägt er lodash! Beachten Sie, dass ich nicht Array.prototype.indexOf oder Array.prototype.includes verwende, um die exlcudeValues in Map oder Object zu verpacken, was das Abfragen beschleunigt!

18
Ardi 19 Nov. 2018 im 23:02

Ich weiß, dass es bereits viele Antworten gibt, aber viele davon scheinen das Problem zu komplizieren. Hier ist eine einfache, rekursive Methode zum Entfernen aller Instanzen eines Schlüssels - ruft self auf, bis der Index nicht gefunden wird. Ja, es funktioniert nur in Browsern mit indexOf, aber es ist einfach und kann leicht mehrfach ausgefüllt werden.

Eigenständige Funktion

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

Prototypmethode

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}
18
wharding28 19 Feb. 2014 im 22:20

Sie haben 1 bis 9 im Array und möchten 5 entfernen. Verwenden Sie den folgenden Code:

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);

Wenn Sie mehrere Werte verwenden möchten. Beispiel: - 1,7,8

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 1,7 and 8 removed", newNumberArray);

Wenn Sie einen Array-Wert in einem Array entfernen möchten. Beispiel: [3,4,5]

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

Der unterstützte Browser ist der Link.

20
Thilina Sampath 2 Sept. 2019 im 04:01

Ein modernerer ECMAScript 2015 -Ansatz (früher bekannt als Harmony oder ES 6). Gegeben:

const items = [1, 2, 3, 4];
const index = 2;

Dann:

items.filter((x, i) => i !== index);

Nachgeben:

[1, 2, 4]

Sie können Babel und einen Polyfill-Service um sicherzustellen, dass dies in allen Browsern gut unterstützt wird.

22
Peter Mortensen 25 Juni 2016 im 13:01

Ich möchte basierend auf ECMAScript 6 antworten. Angenommen, Sie haben ein Array wie das folgende:

let arr = [1,2,3,4];

Wenn Sie an einem speziellen Index wie 2 löschen möchten, schreiben Sie den folgenden Code:

arr.splice(2, 1); //=> arr became [1,2,4]

Wenn Sie jedoch ein spezielles Element wie 3 löschen möchten und dessen Index nicht kennen, gehen Sie wie folgt vor:

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

Hinweis : Verwenden Sie eine Pfeilfunktion für den Filterrückruf, es sei denn, Sie erhalten ein leeres Array.

26
Peter Mortensen 1 Sept. 2019 im 22:59

Update: Diese Methode wird nur empfohlen, wenn Sie ECMAScript 2015 (früher bekannt als ES6) nicht verwenden können. Wenn Sie es verwenden können, bieten andere Antworten hier viel übersichtlichere Implementierungen.


Dieser Kern hier löst Ihr Problem und löscht auch alle Vorkommen des Arguments anstelle von nur 1 ( oder ein bestimmter Wert).

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

Verwendung:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]
25
zykadelic 1 Sept. 2017 im 22:41

Wenn Sie komplexe Objekte im Array haben, können Sie Filter verwenden? In Situationen, in denen $ .inArray oder array.splice nicht so einfach zu verwenden sind. Besonders wenn die Objekte im Array vielleicht flach sind.

Z.B. Wenn Sie ein Objekt mit einem ID-Feld haben und möchten, dass das Objekt aus einem Array entfernt wird:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
27
Anik Islam Abhi 10 Nov. 2015 im 04:20

Ich bin ziemlich neu in JavaScript und brauchte diese Funktionalität. Ich habe nur folgendes geschrieben:

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

Dann, wenn ich es benutzen möchte:

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

Ausgabe - Wie erwartet. ["item1", "item1"]

Möglicherweise haben Sie andere Anforderungen als ich, sodass Sie sie leicht an sie anpassen können. Ich hoffe das hilft jemandem.

29
yckart 30 Dez. 2014 im 16:17

Das Entfernen eines bestimmten Elements / Strings aus einem Array kann in einem Einzeiler erfolgen:

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

Wo:

theArray : Das Array, aus dem Sie etwas Bestimmtes entfernen möchten

stringToRemoveFromArray : Die Zeichenfolge, die entfernt werden soll, und 1 ist die Anzahl der Elemente, die Sie entfernen möchten.

HINWEIS : Wenn sich "stringToRemoveFromArray" nicht in Ihrem Array befindet, wird das letzte Element des Arrays entfernt.

Es ist immer empfehlenswert, zuerst zu überprüfen, ob das Element in Ihrem Array vorhanden ist, bevor Sie es entfernen.

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

Wenn Sie auf den Computern Ihres Clients Zugriff auf neuere Ecmascript-Versionen haben (WARNUNG, funktioniert möglicherweise nicht auf älteren Stationen):

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');

Dabei ist '3' der Wert, den Sie aus dem Array entfernen möchten. Das Array würde dann werden: ['1','2','4','5','6']

30
Max Alexander Hanna 3 Apr. 2020 im 01:58

Hier sind einige Möglichkeiten, um ein Element mithilfe von JavaScript aus einem Array zu entfernen.

Alle beschriebenen Methoden mutieren nicht das ursprüngliche Array , sondern erstellen stattdessen ein neues.

Wenn Sie den Index eines Elements kennen

Angenommen, Sie haben ein Array und möchten ein Element an Position i entfernen.

Eine Methode ist die Verwendung von slice():

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

console.log(filteredItems)

slice() erstellt ein neues Array mit den empfangenen Indizes. Wir erstellen einfach ein neues Array vom Anfang bis zum Index, den wir entfernen möchten, und verketten ein anderes Array von der ersten Position nach der Position, die wir entfernt haben, bis zum Ende des Arrays.

Wenn Sie den Wert kennen

In diesem Fall besteht eine gute Option darin, filter() zu verwenden, das einen deklarativeren Ansatz bietet:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)

console.log(filteredItems)

Dies verwendet die ES6-Pfeilfunktionen. Sie können die herkömmlichen Funktionen verwenden, um ältere Browser zu unterstützen:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

Oder Sie können Babel verwenden und den ES6-Code zurück in ES5 transpilieren, um ihn für alte Browser besser verdaulich zu machen, und dennoch modernes JavaScript in Ihren Code schreiben.

Mehrere Elemente entfernen

Was ist, wenn Sie anstelle eines einzelnen Elements viele Elemente entfernen möchten?

Lassen Sie uns die einfachste Lösung finden.

Nach Index

Sie können einfach eine Funktion erstellen und Elemente in Serie entfernen:

const items = ['a', 'b', 'c', 'd', 'e', 'f']

const removeItem = (items, i) =>
  items.slice(0, i-1).concat(items.slice(i, items.length))

let filteredItems = removeItem(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

Nach Wert

Sie können nach der Aufnahme in die Rückruffunktion suchen:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

Vermeiden Sie die Mutation des ursprünglichen Arrays

splice() (nicht zu verwechseln mit slice()) mutiert das ursprüngliche Array und sollte vermieden werden.

(ursprünglich veröffentlicht unter https://flaviocopes.com/how-to-remove- item-from-array /)

34
Flavio Copes 14 Apr. 2019 im 16:39

ES6 & ohne Mutation: (Oktober 2016)

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)
34
Dipen 10 Feb. 2020 im 07:37

OK, Sie haben beispielsweise das folgende Array:

var num = [1, 2, 3, 4, 5];

Und wir möchten Nummer 4 löschen. Sie können einfach den folgenden Code verwenden:

num.splice(num.indexOf(4), 1); // num will be [1, 2, 3, 5];

Wenn Sie diese Funktion wiederverwenden, schreiben Sie eine wiederverwendbare Funktion, die wie folgt an die Array-Funktion native angehängt wird:

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1)
      return;
  this.splice(i, 1); // num.remove(5) === [1, 2, 3];
}

Aber wie wäre es, wenn Sie stattdessen das folgende Array mit ein paar [5] s im Array haben?

var num = [5, 6, 5, 4, 5, 1, 5];

Wir brauchen eine Schleife, um sie alle zu überprüfen, aber eine einfachere und effizientere Möglichkeit ist die Verwendung integrierter JavaScript-Funktionen. Deshalb schreiben wir eine Funktion, die stattdessen einen Filter wie den folgenden verwendet:

const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]

Es gibt auch Bibliotheken von Drittanbietern, die Ihnen dabei helfen, wie Lodash oder Underscore. Weitere Informationen finden Sie unter lodash _.pull, _.pullAt oder _.without.

34
Peter Mortensen 1 Sept. 2019 im 22:33

Sie können lodash _.pull (mutiertes Array) verwenden, _. pullAt (mutiertes Array) oder _.without (mutiert kein Array),

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']
41
Chun Yang 25 Aug. 2015 im 21:19

Überprüfen Sie diesen Code. Es funktioniert in jedem großen Browser .

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

Rufen Sie diese Funktion auf

remove_item(array,value);
43
Ekramul Hoque 24 Mai 2014 im 07:02

Wenn Sie ein neues Array mit entfernten gelöschten Positionen wünschen, können Sie jederzeit das bestimmte Element löschen und das Array herausfiltern. Für Browser, die die Filtermethode nicht implementieren, ist möglicherweise eine Erweiterung des Array-Objekts erforderlich , aber auf lange Sicht ist es einfacher, da Sie nur Folgendes tun:

var my_array = [1, 2, 3, 4, 5, 6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));

Es sollte [1, 2, 3, 4, 6] anzeigen.

52
Peter Mortensen 1 Sept. 2019 im 20:30

Sie können ES6 verwenden. Zum Beispiel, um den Wert '3' in diesem Fall zu löschen:

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');
console.log(newArray);

Ausgabe :

["1", "2", "4", "5", "6"]
62
darmis 1 Okt. 2019 im 22:13

Underscore.js kann verwendet werden, um Probleme mit mehreren Browsern zu lösen. Falls vorhanden, werden eingebaute Browsermethoden verwendet. Wenn sie nicht vorhanden sind, wie bei älteren Internet Explorer-Versionen, werden eigene benutzerdefinierte Methoden verwendet.

Ein einfaches Beispiel zum Entfernen von Elementen aus dem Array (von der Website):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
63
Peter Mortensen 21 Mai 2017 im 11:29

John Resig hat eine gute Implementierung veröffentlicht:

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

Wenn Sie ein globales Objekt nicht erweitern möchten, können Sie stattdessen Folgendes tun:

// Array Remove - By John Resig (MIT Licensed)
Array.remove = function(array, from, to) {
    var rest = array.slice((to || from) + 1 || array.length);
    array.length = from < 0 ? array.length + from : from;
    return array.push.apply(array, rest);
};

Der Hauptgrund, warum ich dies veröffentliche, besteht darin, Benutzer vor der alternativen Implementierung zu warnen, die in den Kommentaren auf dieser Seite (14. Dezember 2007) vorgeschlagen wurde:

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

Zunächst scheint es gut zu funktionieren, aber durch einen schmerzhaften Prozess habe ich festgestellt, dass es fehlschlägt, wenn versucht wird, das vorletzte Element in einem Array zu entfernen. Wenn Sie beispielsweise ein Array mit 10 Elementen haben und versuchen, das 9. Element damit zu entfernen:

myArray.remove(8);

Sie erhalten ein Array mit 8 Elementen. Ich weiß nicht warum, aber ich habe bestätigt, dass Johns ursprüngliche Implementierung dieses Problem nicht hat.

64
magiccrafter 16 Feb. 2015 im 12:51

Sie können dies problemlos mit dem Filter Methode:

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log(remove([1, 2, 1, 0, 3, 1, 4], 1));

Dies entfernt alle Elemente aus dem Array und arbeitet auch schneller als eine Kombination aus slice und indexOf.

66
Peter Mortensen 1 Sept. 2019 im 22:16

Dies liefert ein Prädikat anstelle eines Wertes.

HINWEIS: aktualisiert das angegebene Array und gibt die betroffenen Zeilen zurück.

Verwendung

var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

Definition

var helper = {

    // Remove and return the first occurrence

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences

    remove: function(array, predicate) {
        var removed = [];

        for (var i = 0; i < array.length;) {

            if (predicate(array[i])) {
                removed.push(array.splice(i, 1));
                continue;
            }
            i++;
        }
        return removed;
    }
};
71
Peter Mortensen 1 Sept. 2019 im 22:18

Es ist nicht erforderlich, indexOf oder splice zu verwenden. Es funktioniert jedoch besser, wenn Sie nur ein Vorkommen eines Elements entfernen möchten.

Suchen und verschieben (verschieben):

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

Verwenden Sie indexOf und splice (indexof):

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

Verwenden Sie nur splice (Spleiß):

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

Laufzeiten auf Knotenjs für ein Array mit 1000 Elementen (durchschnittlich über 10000 Läufe):

indexof ist ungefähr 10x langsamer als move . Selbst wenn es durch Entfernen des Aufrufs von indexOf in splice verbessert wird, ist die Leistung viel schlechter als bei move .

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms
103
slosd 11 Sept. 2015 im 12:47
Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);
Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)
141
Anthony 25 Sept. 2017 im 04:56

Es gibt zwei Hauptansätze:

  1. splice () : anArray.splice(index, 1);

  2. löschen : delete anArray[index];

Seien Sie vorsichtig, wenn Sie delete für ein Array verwenden. Es ist gut zum Löschen von Attributen von Objekten, aber nicht so gut für Arrays. Es ist besser, splice für Arrays zu verwenden.

Beachten Sie, dass bei Verwendung von delete für ein Array möglicherweise falsche Ergebnisse für anArray.length erzielt werden. Mit anderen Worten, delete würde das Element entfernen, aber den Wert der Eigenschaft length nicht aktualisieren.

Sie können auch erwarten, Löcher in Indexnummern zu haben, nachdem Sie delete verwendet haben, z. Möglicherweise haben Sie die Indizes 1, 3, 4, 8, 9 und 11 und die Länge wie vor der Verwendung von delete. In diesem Fall würden alle indizierten for - Schleifen abstürzen, da die Indizes nicht mehr sequentiell sind.

Wenn Sie aus irgendeinem Grund gezwungen sind, delete zu verwenden, sollten Sie

Peter Mortensen 1 Sept. 2019 im 21:51

Ein Freund hatte Probleme mit Internet Explorer 8 und zeigte mir, was er tat. Ich sagte ihm, dass es falsch sei, und er sagte mir, dass er hier die Antwort bekommen habe. Die aktuelle Top-Antwort funktioniert nicht in allen Browsern (z. B. Internet Explorer 8) und entfernt nur das erste Vorkommen des Elements.

Entfernen Sie ALLE Instanzen aus einem Array

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

Es durchläuft das Array rückwärts (da sich Indizes und Länge ändern, wenn Elemente entfernt werden) und entfernt das Element, wenn es gefunden wird. Es funktioniert in allen Browsern.

268
Peter Mortensen 1 Sept. 2019 im 21:54

Es hängt davon ab, ob Sie einen leeren Platz behalten möchten oder nicht.

Wenn Sie einen leeren Steckplatz möchten, ist Löschen in Ordnung:

delete array[index];

Wenn Sie dies nicht tun, sollten Sie die Spleißmethode verwenden:

array.splice(index, 1);

Und wenn Sie den Wert dieses Elements benötigen, können Sie einfach das Element des zurückgegebenen Arrays speichern:

var value = array.splice(index, 1)[0];

Wenn Sie dies in einer bestimmten Reihenfolge tun möchten, können Sie array.pop() für den letzten oder array.shift() für den ersten verwenden (und beide geben auch den Wert des Elements zurück).

Und wenn Sie den Index des Elements nicht kennen, können Sie ihn mit array.indexOf(item) abrufen (in einem if(), um einen Artikel abzurufen, oder in einem while(), um alle zu erhalten). . array.indexOf(item) gibt entweder den Index oder -1 zurück, wenn er nicht gefunden wird.

440
Peter Mortensen 1 Sept. 2019 im 20:29

Ich weiß nicht, wie Sie erwarten, dass sich array.remove(int) verhält. Ich kann mir drei Möglichkeiten vorstellen, die Sie sich wünschen könnten.

So entfernen Sie ein Element eines Arrays an einem Index i:

array.splice(i, 1);

Wenn Sie jedes Element mit dem Wert number aus dem Array entfernen möchten:

for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
        array.splice(i, 1);
    }
}

Wenn Sie nur möchten, dass das Element am Index i nicht mehr vorhanden ist, die Indizes der anderen Elemente jedoch nicht geändert werden sollen:

delete array[i];
1218
Peter Mortensen 8 März 2020 im 17:09