Wie entferne ich ein bestimmtes Element aus einem Array in JavaScript?

Ich weiß nicht, wie Sie sich von array.remove(int) erwarten. Es gibt drei Möglichkeiten, an die ich denken kann, die Ihnen vielleicht fehlen.

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 möchten, dass das Element unter dem Index i nicht mehr vorhanden ist, die Indizes der anderen Elemente jedoch nicht geändert werden sollen:

delete array[i];

Bearbeitet am Oktober 2016

• Mach es einfach, intuitiv und explizit ( https://de.wikipedia.org/wiki/Occam%27s_razor )
• Tun Sie es unveränderlich (Originalarray bleibt unverändert)
• Machen Sie es mit Standard-JS-Funktionen, wenn Ihr Browser sie nicht unterstützt - polyfill verwenden

In diesem Codebeispiel verwende ich die Funktion "array.filter (...)", um unerwünschte Elemente aus einem Array zu entfernen. Diese Funktion ändert das ursprüngliche Array nicht und erstellt ein neues. Wenn Ihr Browser diese Funktion nicht unterstützt (z. B. IE vor Version 9 oder Firefox vor Version 1.5), sollten Sie die Verwendung von des Filters polyfill von Mozilla in Betracht ziehen.

Artikel entfernen (ECMA-262 Edition 5-Code aka oldstyle JS)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) { 
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

Artikel entfernen (ES2015-Code)

let value = 3

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

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

IMPORTANT ES2015 "() => {}" Die Pfeilfunktionssyntax wird in IE überhaupt nicht unterstützt, Chrome vor der Version 45, Firefox vor der Version 22, Safari vor Version 10. Um die ES2015-Syntax in alten Browsern zu verwenden, können Sie BabelJS verwenden.

Mehrere Elemente entfernen (ES2016-Code)

Ein zusätzlicher Vorteil dieser Methode ist, dass Sie mehrere Elemente entfernen können

let forDeletion = [2, 3, 5]

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

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

IMPORTANT Die Funktion "array.includes (...)" wird in IE überhaupt nicht unterstützt, Chrome vor Version 47, Firefox vor Version 43, Safari vor Version 9 und Edge vor Version 14 hier ist Polyfill von Mozilla

Mehrere Elemente entfernen (Experimentelles JavaScript ES2018?)

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

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

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

Probiere es selbst in BabelJS :)

Referenz

• Array.prototype.includes
• Dieser verbindliche Syntaxvorschlag
• Funktionelle Zusammensetzung

Kommt drauf an, ob Sie eine freie Stelle behalten wollen oder nicht.

Wenn Sie einen leeren Steckplatz wünschen, ist das Löschen in Ordnung:

delete array[ index ];

Wenn Sie dies nicht tun, sollten Sie die Methode splice verwenden:

array.splice( index, 1 );

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 die letzte oder array.shift() für die erste verwenden (und beide geben auch den Wert des Elements zurück).

Und wenn Sie den Index des Elements nicht kennen, können Sie array.indexOf( item ) verwenden, um ihn zu erhalten (in if(), um ein Element oder in while() alle zu erhalten). array.indexOf( item ) gibt entweder den Index zurück oder -1, falls nicht gefunden.

Ein Freund hatte Probleme mit Internet Explorer 8 und zeigte mir, was er getan hat. Ich sagte ihm, dass es falsch war, und er sagte mir, dass er die Antwort hier bekam. 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);
        }
    }
}

Er 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.

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.

Denken Sie daran, dass Sie bei Verwendung von delete für ein Array falsche Ergebnisse für anArray.length erhalten können. Mit anderen Worten, delete würde das Element entfernen, aber den Wert der length-Eigenschaft nicht aktualisieren.

Sie können auch erwarten, dass die Indexnummern nach der Verwendung von delete Lücken aufweisen, z. Am Ende haben Sie die Indizes 1,3,4,8,9,11 und die Länge, wie sie vor der Verwendung von delete verwendet wurde. In diesem Fall würden alle indizierten for-Schleifen abstürzen, da Indizes nicht mehr sequenziell sind.

Wenn Sie aus irgendeinem Grund delete verwenden müssen, sollten Sie for each loops verwenden, wenn Sie Arrays durchlaufen müssen. Vermeiden Sie nach Möglichkeit immer die Verwendung von indexierten for-Schleifen. Auf diese Weise wäre der Code robuster und weniger anfällig für Indexprobleme.

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)

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

Suchen und Bewegen (Bewegen):

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 nodejs für ein Array mit 1000 Elementen (Durchschnitt über 10000 Läufe):

indexof ist ca. 10x langsamer als move. Selbst wenn es durch das Entfernen des Aufrufs von indexOf in splice verbessert wird, ist es wesentlich schlechter als 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

Zu alt um zu antworten, aber es kann jemandem helfen, indem er statt eines Wertes ein Prädikat liefert.

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

Verwendungszweck

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

John Resig veröffentlichte eine gute Implementierung :

// 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 poste, ist, Benutzer vor der alternativen Implementierung zu warnen, die in den Kommentaren auf dieser Seite (14. Dezember 2007) vorgeschlagen wird:

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

Es scheint anfangs 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 folgendermaßen zu entfernen:

myArray.remove(8);

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

Underscore.js kann verwendet werden, um Probleme mit mehreren Browsern zu lösen. Es verwendet eingebaute Browsermethoden, sofern vorhanden. 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]

Mit der Methode filter ist das problemlos möglich:

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 funktioniert auch schneller als die Kombination von Slice und IndexOf

Wenn Sie ein neues Array mit den gelöschten Positionen entfernen möchten, können Sie das betreffende Element jederzeit löschen und das Array herausfiltern. Es kann eine Erweiterung des array object für Browser erforderlich sein, die die Filtermethode nicht implementieren, aber auf lange Sicht ist dies 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';}));

Sollte [1, 2, 3, 4, 6] anzeigen

Sie können ES6 verwenden. 

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

Ausgabe : 

["1", "2", "4", "5", "6"]

Überprüfen Sie diesen Code. Es funktioniert in jedem Hauptbrowser .

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

Sie können lodash _.pull (mutate array), _.pullAt (mutate array) oder _.without (nicht mutate array) verwenden. 

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']

OK, zum Beispiel haben Sie 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 eingeben:

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 native Array-Funktion 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 das Array unten mit wenigen [5] s im Array haben?

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

Wir benötigen eine Schleife, um sie alle zu überprüfen, aber auf einfachere und effizientere Weise verwenden wir integrierte JavaScript-Funktionen. Deshalb schreiben wir eine Funktion, die stattdessen einen Filter wie folgt 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.

Ich bin relativ 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 verwenden 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 Bedürfnisse als ich, sodass Sie sie leicht an Ihre Bedürfnisse anpassen können. Ich hoffe das hilft jemandem.

ES6 & ohne Mutation: (Oktober 2016)

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

Dann : 

removeByIndex([33,22,11,44],1) //=> [33,11,44]

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

Diese Gist hier löst Ihr Problem und löscht auch alle Vorkommen des Arguments anstelle von nur 1 (oder einem angegebenen 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;
}

Verwendungszweck:

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]

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 ist. Besonders, wenn die Objekte im Array möglicherweise flach sind.

Z.B. Wenn Sie ein Objekt mit einem Id-Feld haben und das Objekt aus einem Array entfernen möchten:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});

Ein Element mit JavaScript aus einem Array entfernen.

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

Wenn Sie den Index eines Artikels 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-1).concat(items.slice(i, items.length))

console.log(filteredItems)

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

Wenn Sie den Wert kennen

In diesem Fall ist eine gute Option die Verwendung von filter(), die einen deklarativen - 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)

sie können auch Babel verwenden und den ES6-Code auf ES5 zurücksetzen, um ihn für alte Browser leichter 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?

Finden wir die einfachste Lösung.

Nach Index

Sie können einfach eine Funktion erstellen und Elemente in Serien 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 der 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, das ursprüngliche Array zu mutieren

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

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

Sie sollten Ihr Array niemals zu einem Array mutieren. Da dies gegen das funktionale Programmiermuster ist. Sie können ein neues Array erstellen, ohne auf das Array zu verweisen, dessen Daten Sie ändern möchten, indem Sie die es6-Methode verwenden. filter;

var myArray = [1,2,3,4,5,6];

Angenommen, Sie möchten 5 aus dem Array entfernen, so können Sie dies einfach tun.

myArray = myArray.filter(value => value !== 5);

Dadurch erhalten Sie ein neues Array ohne den Wert, den Sie entfernen möchten. Das Ergebnis wird also sein

 [1,2,3,4,6]; // 5 has been removed from this array

Weitere Informationen finden Sie in der MDN-Dokumentation unter Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter .

Ein modernerer, ECMAScript 2015 (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);

Ertrag: 

[1, 2, 4]

Sie können Babel und einen Polyfill-Dienst verwenden, um sicherzustellen, dass dies von Browsern gut unterstützt wird.

Ich weiß, dass es bereits viele Antworten gibt, aber viele von ihnen scheinen das Problem zu komplizieren. Hier ist eine einfache, rekursive Methode, um alle Instanzen eines Schlüssels zu entfernen - ruft selbst auf, bis der Index nicht gefunden wird. Ja, es funktioniert nur in Browsern mit indexOf, aber es ist einfach und kann leicht gefüllt werden.

Stand-Alone-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);
}

Ich habe eine andere gute Lösung zum Entfernen aus einem Array:

var words = ['spray', 'limit', 'Elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(Word => Word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Sie können eine Rückwärtsschleife ausführen, um sicherzustellen, dass Sie die Indizes nicht verstellen, wenn das Element mehrere Instanzen enthält.

var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
    if (myArray[i] == myElement) myArray.splice(i, 1);
}

Live Demo

Basierend auf all den Antworten, die hauptsächlich richtig waren und unter Berücksichtigung der empfohlenen Vorgehensweisen (vor allem, wenn Array.prototype nicht direkt verwendet wird), kam der folgende 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;
}

Bei der Überprüfung der obigen Funktion stellte ich fest, dass die Leistung verbessert werden kann, 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-Post, in dem ich mehrere Lösungen für Array ohne Probleme getestet und die Laufzeit verglichen habe. Ich werde diese Antwort mit dem Link aktualisieren, sobald ich diesen Beitrag fertiggestellt habe. Um Sie wissen zu lassen, habe ich das obige mit lodash verglichen, und falls der Browser Map unterstützt, schlägt es lodash! Beachten Sie, dass ich nicht Array.prototype.indexOf oder Array.prototype.includes verwende, da die ExlcudeValues ​​in eine Map oder Object eingebunden werden, was das Abfragen schneller macht!

Sie haben ein Array von 1 bis 9, und Sie möchten den folgenden Code entfernen.

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 den Wert ex multiplizieren möchten: - 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, 5 removed", newNumberArray);

Wenn Sie den Array-Wert in Array ex entfernen möchten: - [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);

beinhaltet unterstützten Browser ist link

  Array.prototype.removeItem = function(a) {
            for (i = 0; i < this.length; i++) {
                if (this[i] == a) {
                    for (i2 = i; i2 < this.length - 1; i2++) {
                        this[i2] = this[i2 + 1];
                    }
                    this.length = this.length - 1
                    return;
                }
            }
        }

    var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
    recentMovies.removeItem('Superman');

Nach Index entfernen

Funktion, die eine Kopie des Arrays ohne das Element at index zurückgibt.

/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
    return array.filter(function(elem, _index){
        return index != _index;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));

$> [ 1, 4, 5, 6, 7 ]

Nach Wert entfernen

Funktion, die eine Kopie des Arrays ohne den Wert zurückgibt.

/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
    return array.filter(function(elem, _index){
        return value != elem;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));

$> [ 1, 3, 4, 6, 7]

Ich möchte antworten basierend aufES6. Angenommen, Sie haben ein Array wie folgt:

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

Wenn Sie einen speziellen Index wie 2 löschen möchten, geben Sie den folgenden Code ein:

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

Wenn Sie jedoch ein spezielles Element wie 3 löschen möchten und nicht wissen, wie der Index aussieht, tun Sie es wie folgt:

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

Hinweis : Bitte verwenden Sie eine Pfeilfunktion für den Filter-Callback, es sei denn, Sie erhalten ein leeres Array.

Neues Array erstellen:

var my_array = new Array();

Elemente zu diesem Array hinzufügen:

my_array.Push("element1");

Die Funktion indexOf (Gibt den Index zurück oder -1 wenn nicht gefunden):

var indexOf = function(needle) 
{
    if(typeof Array.prototype.indexOf === 'function') // newer browsers
    {
        indexOf = Array.prototype.indexOf;
    } 
    else // older browsers
    {
        indexOf = function(needle) 
        {
            var index = -1;

            for(var i = 0; i < this.length; i++) 
            {
                if(this[i] === needle) 
                {
                    index = i;
                    break;
                }
            }
            return index;
        };
    }

    return indexOf.call(this, needle);
};

Überprüfe den Index dieses Elements (getestet mit Firefox und IE8 +):

var index = indexOf.call(my_array, "element1");

1 Element am Index aus dem Array entfernen

my_array.splice(index, 1);

Ich lief auch in der Situation, in der ich ein Element aus Array entfernen musste. .indexOf hat nicht in IE* gearbeitet, so dass meine funktionierende jQuery.inArray()-Lösung freigegeben wurde.

var index = jQuery.inArray(val,arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}

2017-05-08

Die meisten Antworten geben einen strengen Vergleich vor, was bedeutet, dass beide Objekte auf dasselbe Objekt im Speicher verweisen (oder primitive Typen sind). Oft möchten Sie jedoch ein nicht-primitives Objekt aus einem Array mit einem bestimmten Wert entfernen. Wenn Sie beispielsweise einen Server anrufen und ein abgerufenes Objekt mit einem lokalen Objekt vergleichen möchten.

const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a            // Non-primitive object that reference the same object as "a"

assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)

//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
   return  JSON.stringify(x) === JSON.stringify(y)
}


//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
    return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}

const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);

//resultArray = [{'field':90}]

Es gibt alternative/schnellere Implementierungen für valuesAreEqual, was jedoch die Aufgabe erfüllt. Sie können auch einen benutzerdefinierten Vergleicher verwenden, wenn Sie ein bestimmtes Feld zur Prüfung haben (z. B. einige abgerufene UUID im Vergleich zu einer lokalen UUID).

Beachten Sie auch, dass dies eine funktionale Operation ist, dh das ursprüngliche Array wird nicht mutiert.

Ich denke, dass viele der JavaScript-Anweisungen für die funktionale Programmierung nicht gut durchdacht sind. Splice gibt das gelöschte Element zurück, wo Sie meistens das reduzierte Array benötigen. Das ist schlecht.

Stellen Sie sich vor, Sie führen einen rekursiven Aufruf durch und müssen ein Array mit einem weniger Element übergeben, wahrscheinlich ohne das aktuell indizierte Element. Oder stellen Sie sich vor, Sie führen einen anderen rekursiven Aufruf durch und müssen ein Array mit einem geschobenen Element übergeben.

In keinem dieser Fälle können Sie myRecursiveFunction(myArr.Push(c)) oder myRecursiveFunction(myArr.splice(i,1)) ausführen. Der erste Idiot wird tatsächlich die Länge des Arrays übergeben, und der zweite Idiot wird das gelöschte Element als Parameter übergeben.

Also was mache ich eigentlich ... Um ein Array-Element zu löschen und das Ergebnis gleichzeitig an eine Funktion als Parameter zu übergeben, mache ich folgendes

myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

Wenn es um Push geht, ist das mehr dumm ... Ich mag es,

myRecursiveFunction((myArr.Push(c),myArr))

Ich glaube, in einer richtigen Funktionssprache muss eine Methode, die das Objekt, zu dem es aufgerufen wird, mutiert, als Ergebnis einen Verweis auf das Objekt zurückgeben.

In CoffeeScript :

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value

Verwenden Sie das InArray von jQuery:

A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`   

Hinweis: InArray gibt -1 zurück, wenn das Element nicht gefunden wurde.

Vanilla JavaScript (ES5.1) - vorhanden Edition

Browserunterstützung: Internet Explorer 9 oder höher ( detaillierte Browserunterstützung )

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array “in place”, i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

Vanilla JavaScript (ES5.1) - unveränderlich Edition

Browserunterstützung: Wie Vanilla JavaScript in der Place Edition

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 - unveränderlich Edition

Browserunterstützung: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( detaillierte Browserunterstützung )

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}

Entfernen Sie das Element am Index i, ohne das ursprüngliche Array zu mutieren:

/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
   return Array.from(array).splice(index, 1);
}

// Another way is
function removeElement(array, index) {
   return array.slice(0).splice(index, 1);
}

Ich mag diese Version von Spleiß, indem ich ein Element anhand seines Werts mit $.inArray entferne:

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});

Sie können jedes array- Element und splice iterieren, wenn es in Ihrer array vorhanden ist.

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}

Ich habe gerade einen Polyfill auf dem Array.prototype über Object.defineProperty erstellt, um ein gewünschtes Element in einem Array zu entfernen, ohne zu Fehlern zu führen, wenn es später über for .. in .. durchlaufen wird.

if (!Array.prototype.remove) {
  // Object.definedProperty is used here to avoid problems when iterating with "for .. in .." in Arrays
  // https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
  Object.defineProperty(Array.prototype, 'remove', {
    value: function () {
      if (this == null) {
        throw new TypeError('Array.prototype.remove called on null or undefined')
      }

      for (var i = 0; i < arguments.length; i++) {
        if (typeof arguments[i] === 'object') {
          if (Object.keys(arguments[i]).length > 1) {
            throw new Error('This method does not support more than one key:value pair per object on the arguments')
          }
          var keyToCompare = Object.keys(arguments[i])[0]

          for (var j = 0; j < this.length; j++) {
            if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
              this.splice(j, 1)
              break
            }
          }
        } else {
          var index = this.indexOf(arguments[i])
          if (index !== -1) {
            this.splice(index, 1)
          }
        }
      }
      return this
    }
  })
} else {
  var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
  errorMessage += 'This may lead to unwanted results when remove() is executed.'
  console.log(errorMessage)
}

Einen ganzzahligen Wert entfernen

var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]

Einen Stringwert entfernen

var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']

Einen booleschen Wert entfernen

var a = [true, false, true]
a.remove(false)
a // Output => [true, true]

Es ist auch möglich, ein Objekt im Array über diese Array.prototype.remove-Methode zu entfernen. Sie müssen lediglich den key => value der Object angeben, die Sie entfernen möchten.

Objektwert entfernen

var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
a.remove({a: 1})
a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]

Ich habe eine ziemlich effiziente Erweiterung für das Basis-JavaScript-Array vorgenommen:

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};

Mit meiner Lösung können Sie dank reinem JavaScript ein oder mehrere Elemente in einem Array entfernen. Es ist keine weitere JavaScript-Bibliothek erforderlich.

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]

Entfernen Sie einen Wert mit lockerem Vergleich, ohne das ursprüngliche Array ES6 zu verändern

/**
 * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
 * 
 * @param {Array} array Array to remove value from
 * @param {*} value Value to remove
 * @returns {Array} Array with `value` removed
 */
export function arrayRemove(array, value) {
    for(let i=0; i<array.length; ++i) {
        if(array[i] == value) {
            let copy = [...array];
            copy.splice(i, 1);
            return copy;
        }
    }
    return array;
}

Während die meisten der obigen Antworten die Frage beantworten, ist nicht klar genug, warum die slice()-Methode nicht verwendet wurde. Ja, filter() erfüllt die Unveränderlichkeitskriterien, aber wie wäre es mit dem folgenden kürzeren Äquivalent:

const myArray = [1,2,3,4];

Und jetzt sagen wir, dass wir das zweite Element aus dem Array entfernen sollten, wir können es einfach tun: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

Diese Art, ein Element aus einem Array zu löschen, wird heute in der Community aufgrund seiner einfachen und unveränderlichen Natur dringend empfohlen. Im Allgemeinen sollten Methoden, die Mutationen verursachen, vermieden werden. Beispielsweise sollten Sie Push() durch concat() und splice() durch slice() ersetzen. 

Verwenden Sie jQuery.grep () :

var y = [1, 2, 3, 9, 4]
var removeItem = 9;

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>

Das Entfernen eines bestimmten Elements/Strings aus einem Array kann in einem Einzeiler erfolgen: Ich denke immer noch, dass dies der eleganteste Einzeiler ist, den Sie für diese Art von Problem erhalten können: 

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

wobei 'theArray' das Array ist, aus dem Sie etwas Bestimmtes entfernen möchten.

Posten Sie meinen Code, der ein Array-Element an Ort und Stelle entfernt, und reduzieren Sie auch die Array-Länge.

function removeElement(idx, arr) {
    // check the index value
    if (idx < 0 || idx >= arr.length) {
        return;
    }
    // shift the elements
    for (var i = idx; i > 0; --i) {
        arr[i] = arr[i - 1];
    }
    // remove the first element in array
    arr.shift();
}

Es gibt viele fantastische Antworten, aber für mich war es am einfachsten, mein Element vollständig aus dem Array zu entfernen, sondern einfach den Wert auf null zu setzen. Dies funktioniert für die meisten Fälle, die ich habe, und ist eine gute Lösung, da ich die Variable später verwenden werde und nicht möchte, dass sie wegfällt. Dieser Ansatz ist auch vollständig browserübergreifend kompatibel.

array.key = null;

Entfernen Sie das letzte oder alle Vorkommnisse oder das erste Vorkommen? 

var array = [2, 5, 9, 5];

// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Remove this line to remove all occurrences
  }
}

oder

var array = [2, 5, 9, 5];

// Remove first occurrence
for (var i = 0; array.length; i++) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Do not remove this line
  }
}

Für alle, die eine Methode replizieren möchten, die ein neues Array zurückgibt, bei dem doppelte Nummern oder Zeichenfolgen entfernt wurden, wurde dies aus den vorhandenen Antworten zusammengestellt:

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.Push(element);
  }

  return dupFree;
}

Ich habe eine Funktion gemacht 

function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}

Und so benutzt.

pop(valuetoremove,myarray);

Prost!

Eine sehr naive Implementierung wäre wie folgt:

Array.prototype.remove = function(data) {
    const dataIdx = this.indexOf(data)
    if(dataIdx >= 0) {
        this.splice(dataIdx ,1);
    }
    return this.length;
}

let a = [1,2,3];
// this will change arr a to [1, 3]
a.remove(2);

Ich gebe die Länge des Arrays aus der Funktion zurück, um den anderen Methoden wie Array.prototype.Push() zu entsprechen.

Ich hatte dieses Problem selbst (in einer Situation, in der das Array ersetzt werden konnte) und löste es mit einem einfachen:

var filteredItems = this.items.filter(function (i) {
    return i !== item;
});

Um dem obigen Ausschnitt ein wenig Kontext zu geben:

self.thingWithItems = {
        items: [],
        removeItem: function (item) {
            var filteredItems = this.items.filter(function (i) {
                return i !== item;
            });

            this.items = filteredItems;
        }
    };

Diese Lösung sollte sowohl mit Referenz- als auch mit Wertelementen funktionieren. Es hängt alles davon ab, ob Sie einen Verweis auf das ursprüngliche Array beibehalten müssen, ob diese Lösung anwendbar ist. 

Noch eine andere Antwort, für mich ist die einfachere die bessere, und da wir 2018 (nahe 2019) sind, gebe ich Ihnen diese (nahe) Zeile, um die ursprüngliche Frage zu beantworten:

Array.prototype.remove = function (value) { 
    return this.filter(f => f != value) 
}

Das Nützliche ist, dass Sie es in einem Curry-Ausdruck verwenden können, wie zum Beispiel:

[1,2,3].remove(2).sort()

var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);

Mit Array.findindex können wir die Anzahl der Codezeilen reduzieren.

developer.mozilla.org

var index,
    input = [1,2,3],
    indexToRemove = 1;
    integers = [];

for (index in input) {
    if (input.hasOwnProperty(index)) {
        if (index !== indexToRemove) {
            integers.Push(result); 
        }
    }
}
input = integers;

Diese Lösung benötigt ein Array von Eingaben und durchsucht die Eingabe nach dem zu entfernenden Wert. Dadurch wird das gesamte Eingabearray durchlaufen, und das Ergebnis ist eine zweite Ganzzahl des Arrays, bei der der bestimmte Index entfernt wurde. Das Integer-Array wird dann wieder in das Eingangsarray kopiert. 

Ihre Frage hat nicht angegeben, ob Reihenfolge oder unterschiedliche Werte erforderlich sind.

Wenn Sie sich nicht um die Reihenfolge kümmern und nicht mehr als einmal denselben Wert im Container haben, verwenden Sie ein Set. Es wird viel schneller und prägnanter sein. 

var aSet = new Set();

aSet.add(1);
aSet.add(2);
aSet.add(3);

aSet.delete(2);

[2,3,5].filter(i => ![5].includes(i))

Wert mit Index und Spleiß entfernen!

function removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}

element vom letzten löschen 

arrName.pop();

element von Anfang an löschen 

arrName.shift();

aus der Mitte löschen

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

ein Element vom letzten löschen

arrName.splice(-1);

Löschen Sie mithilfe der Array-Indexnummer

 delete arrName[1];

Was für eine Schande, Sie haben ein Array von Ganzzahlen, nicht ein Objekt, bei dem die Schlüssel Zeichenfolgenäquivalente dieser Ganzzahlen sind.

Ich habe viele dieser Antworten durchgesehen und sie scheinen alle "rohe Gewalt" einzusetzen, soweit ich sehen kann. Ich habe nicht jeden einzelnen geprüft, entschuldige mich, wenn dem nicht so ist. Für ein kleineres Array ist dies in Ordnung, aber was ist, wenn Sie Tausende von ganzen Zahlen darin haben?

Korrigieren Sie mich, wenn ich falsch liege, aber können wir nicht davon ausgehen, dass in einer key => value-Karte, wie sie ein JS-Objekt ist, der Schlüsselabrufmechanismus als technisch ausgereift und optimiert betrachtet werden kann? (NB: Wenn ein Superexperte sagt, dass dies nicht der Fall ist, kann ich vorschlagen, stattdessen ES6 Map class zu verwenden, was sicherlich der Fall sein wird).

Ich schlage nur vor, dass unter bestimmten Umständen die beste Lösung darin besteht, Ihr Array in ein Objekt zu konvertieren. Das Problem besteht natürlich darin, dass Sie ganzzahlige Werte wiederholen können. Ich schlage vor, diese in Buckets als "Wert" der key => value-Einträge zu setzen. (NB: Wenn Sie sicher sind, dass Sie keine sich wiederholenden Array-Elemente haben, kann dies wesentlich einfacher sein: Werte "gleich" wie "keys" und einfach Object.values(...), um Ihr modifiziertes Array zurückzuholen).

Sie könnten also folgendes tun:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =   function( acc, val, currIndex ){ 
    // not seen this val before: make bucket... NB although val's typeof is 'number'
    // there is seamless equivalence between the object key (always string)
    // and this variable val 
    ! ( val in acc ) ? acc[ val ] = []: 0;
    // drop another array index in the bucket
    acc[ val ].Push( currIndex );
    return acc; 
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

ausgabe:

Objekt [<1 leerer Steckplatz>, Array 1 , Array [2], Array 1 , Array 1 , <5 leere Slots>, 46 mehr…]

es ist dann einfach, alle Nummern zu löschen 55

delete myIntsMapObj[ 55 ]; // again, although keys are strings this works

Sie müssen sie nicht alle löschen: Indexwerte werden in der Reihenfolge ihres Aussehens in ihre Buckets verschoben, also (zum Beispiel):

myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop(); 

löscht das erste bzw. letzte Vorkommen. Sie können die Häufigkeit des Auftretens einfach zählen, alle 55s durch 3s ersetzen, indem Sie den Inhalt eines Buckets in einen anderen übertragen usw.

... Ihr modifiziertes int-Array zurückzubekommen, ist geringfügig betroffen: aber jeder Bucket enthält den Index (im ursprünglichen Array) des durch den (string) -Schlüssel dargestellten Werts. Jeder dieser Bucket-Werte ist ebenfalls eindeutig: Sie wandeln sie also in Schlüssel in einem neuen Objekt um, wobei die (reelle) Ganzzahl aus dem "Ganzzahl-Zeichenfolge-Schlüssel" als Wert verwendet wird ... und dann die Schlüssel sortieren und Object.values( ... ) gehen.

Das hört sich sehr umständlich und zeitaufwändig an, aber natürlich hängt alles von den Umständen und der gewünschten Verwendung ab. Meines Wissens ist es so, dass alle Versionen und Kontexte von JS nur in einem Thread arbeiten und der Thread nicht "losgelassen" wird, sodass es zu einer schrecklichen Überlastung mit einer "Brute-Force" -Methode kommen kann: Die Operation indexOf verursacht nicht so viel , aber mehrfach wiederholte slicesplice ops.

_/Nachtrag
Wenn Sie sure sind, ist dies zu viel Engineering für Ihren Anwendungsfall. Der einfachste "Brute-Force" -Ansatz ist sicherlich

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(ja, andere Antworten haben Array.prototype.filter... entdeckt)

Die folgende Methode entfernt alle Einträge eines bestimmten Werts aus einem Array, ohne ein neues Array zu erstellen, und zwar mit einer einzigen Iteration, nämlich superfast. Und es funktioniert in alten Internet Explorer 5.5 Browsern:

function removeFromArray(arr, removeValue) {
  for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
    if (k > 0)
      arr[i - k] = arr[i];

    if (arr[i] === removeValue)
      k++;
  }

  for (; k--;)
    arr.pop();
}

var a = [0, 1, 0, 2, 0, 3];

document.getElementById('code').innerHTML =
  'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]

removeFromArray(a, 0);

document.getElementById('code').innerHTML +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]

<code id="code"></code>

Um bestimmte Elemente oder nachfolgende Elemente zu entfernen, ist die Methode Array.splice () gut geeignet. Die Methode splice () ändert den Inhalt eines Arrays, indem vorhandene Elemente entfernt oder ersetzt werden und/oder neue Elemente hinzugefügt werden der entfernte Artikel.

Syntax: _ ​​array.splice (index, deleteCount, item1, ....., itemX)

Hier ist index obligatorisch und Restargumente sind optional.

Zum Beispiel:

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

Hinweis: Die MethodeArray.splice () kann verwendet werden, wenn Sie den Index des Elements kennen, das Sie löschen möchten. Wir können jedoch einige weitere Fälle haben, wie unten erwähnt:

1. Wenn Sie nur das letzte Element löschen möchten, können Sie Array.pop () verwenden.

2. Wenn Sie nur das erste Element löschen möchten, können Sie Array.shift () verwenden.

3. Wenn Sie das Element alleine kennen, aber nicht die Position (oder den Index) des Elements, und alle übereinstimmenden Elemente mit der Methode Array.filter () löschen möchten:

   let arr = [1, 2, 1, 3, 4, 1, 5, 1];
   
   let newArr = arr.filter(function(val){
       return val !== 1;
    });
    //newArr => [2, 3, 4, 5]
   

ODER mithilfe der Methode splice ()

let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    for( let i = 0; i < arr.length-1; i++){
       if ( arr[i] === 11) {
         arr.splice(i, 1); 
       }
    }
    console.log(arr);
    // [1, 2, 3, 4, 5, 6]

ODER Angenommen, wir möchten del aus dem Array arr löschen:

let arr = [1, 2, 3, 4, 5, 6];
let del = 4;
if(arr.indexOf(4) >= 0) {
arr.splice(arr.indexOf(4), 1)
}

OR

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}

4. Wenn Sie das Element allein kennen, aber nicht die Position (oder den Index) des Elements, und Sie möchten nur das erste übereinstimmende Element mit der splice () -Methode löschen:

   let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
   
   for( let i = 0; i < arr.length-1; i++){
     if ( arr[i] === 11) {
       arr.splice(i, 1);
       break;
     }
   }
   console.log(arr);
   // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
   

Wenn Sie ältere Versionen von Internet Explorer unterstützen müssen, empfehle ich die Verwendung der folgenden Polyfill (Anmerkung: Dies ist nicht ein Framework). Es ist ein zu 100% rückwärtskompatibler Ersatz aller modernen Array-Methoden (JavaScript 1.8.5/ECMAScript 5 Array-Extras), der für Internet Explorer 6+, Firefox 1.5+, Chrome, Safari und Opera funktioniert.

https://github.com/plusdude/array-generics

Oft ist es besser, einfach ein neues Array mit der Filterfunktion zu erstellen.

const array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]

Dies verbessert auch die Lesbarkeit imho. Ich bin kein Fan von Slice, obwohl ich manchmal weiß, dass man es versuchen sollte.

Definieren Sie eine Methode mit dem Namen remove () für Arrayobjekte, indem Sie die Protokollierungsfunktion von JavaScript verwenden.

Verwenden Sie die Methode splice () , um Ihre Anforderungen zu erfüllen.

Bitte schauen Sie sich den Code unten an.

Array.prototype.remove = function(item) {
    // index will have -1 if item does not exist
    // else it will have the index of 1st item found in array
    var index = this.indexOf(item); 

    if (index > -1) {
        // splice() method is used to add/remove items(s) in array
        this.splice(index, 1); 
    }

    return index;
}


var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];

// Printing array
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// Removing 67 (getting its index i.e. 2)
console.log("Removing 67")
var index = arr.remove(67)

if (index > 0){
    console.log("Item 67 found at ", index)
} else {
    console.log("Item 67 does not exist in array")
}

// Printing updated array
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// ............... Output ................................
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
// Removing 67
// Item 67 found at  2
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]

Hinweis: Nachfolgend finden Sie den vollständigen Beispielcode für Node.js REPL , der die Verwendung von Push (), pop (), shift (), unshift () und splice () beschreibt Methoden.

> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> arr.Push(55);
17
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
> // Popping item from array (i.e. from end)
undefined
> arr.pop()
55
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Remove item from beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
16
> arr
[ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.unshift(11, 22); // Adding 2 more items at the beginning of array
18
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
undefined
> Array.prototype.remove = function(item) {
... var index = this.indexOf(item);
... if (index > -1) {
..... this.splice(index, 1); // splice() method is used to add/remove items in array
..... }
... return index;
... }
[Function]
>
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(45);   // Remove 45 (You will get the index of removed item)
3
> arr
[ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(22)    // Remove 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67)    // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89)    // Remove 89
2
> arr
[ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(100);  // 100 doesn't exist, remove() will return -1
-1
>

Vielen Dank.

Spleißen, filtern und löschen, um ein Element aus dem Array zu entfernen

Jedes Array hat seinen Index und es hilft, bestimmte Elemente mit ihrem Index zu löschen.

Die Methode splice () 

array.splice (index, 1 ); Der erste Parameter ist index und der zweite ist die Anzahl der Elemente, die Sie verwenden

möchte aus diesem Index löschen.

Für ein Element verwenden wir also 1. 

Die Löschmethode

array löschen [Index]

Die filter () -Methode

Wenn Sie ein Element löschen möchten, das in Array wiederholt wird, filtern Sie das Array.

removeAll = array.filter (e => e! = elem);

dabei ist elem das Element, das Sie aus Array entfernen möchten, und Array ist Ihr Arrayname

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

array.splice (start [ deleteCount [ item1 [ item2 [ ...]]]])

Start

Index, an dem das Array geändert werden soll (mit Origin 0). Ist die Länge des Arrays größer, wird der tatsächliche Startindex auf die Länge des Arrays gesetzt. Wenn dies negativ ist, beginnen so viele Elemente vom Ende des Arrays (mit Origin -1) und werden auf 0 gesetzt, wenn der absolute Wert größer als die Länge des Arrays ist.

deleteCount Optional

Eine Ganzzahl, die die Anzahl der alten Arrayelemente angibt, die entfernt werden sollen ..__ Wenn deleteCount weggelassen wird oder wenn sein Wert größer als array.length - start ist (dh, wenn er größer ist als die Anzahl der im Array verbleibenden Elemente Beginnend mit Start) werden dann alle Elemente vom Anfang bis zum Ende des Arrays gelöscht .. Wenn DeleteCount 0 oder negativ ist, werden keine Elemente entfernt. In diesem Fall sollten Sie mindestens ein neues Element angeben (siehe unten).

item1, item2, ... Optional

Die Elemente, die dem Array hinzugefügt werden sollen, beginnend am Startindex. Wenn Sie keine Elemente angeben, entfernt splice () nur Elemente aus dem Array.

Für weitere Referenzen gehen Sie bitte durch:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

Es gibt bereits viele Antworten, aber da es noch niemand mit einem Einliner geschafft hat, dachte ich, ich würde meine Methode zeigen. Dabei wird die Tatsache genutzt, dass die Funktion string.split () beim Erstellen eines Arrays alle angegebenen Zeichen entfernt. Hier ist ein Beispiel: 

var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);

In diesem Beispiel werden alle 4er aus dem Array entfernt. Beachten Sie jedoch, dass jedes Array, das das Zeichen "-" enthält, Probleme mit diesem Beispiel verursacht. Kurz gesagt, die Join-Funktion ("-") führt dazu, dass Ihre Zeichenfolge nicht ordnungsgemäß zusammengefügt wird. In einer solchen Situation können alle "-" - Zeichenfolgen im obigen Snipet durch eine beliebige Zeichenfolge ersetzt werden, die nicht im ursprünglichen Array verwendet wird. Hier ist ein anderes Beispiel: 

var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("[email protected]#").split("[email protected]#[email protected]#").join("[email protected]#").split("[email protected]#");
console.log(out);

Nicht vor Ort Lösung

arr.slice(0,i).concat(arr.slice(i+1));

let arr = [10, 20, 30, 40, 50]

let i = 2 ; // position to remove (starting from 0)
let r = arr.slice(0,i).concat(arr.slice(i+1));

console.log(r);

sie können das Array-Objekt wie folgt erweitern, um eine benutzerdefinierte Löschfunktion zu definieren

let numbers = [1,2,4,4,5,3,45,9];

numbers.delete = function(value){
    var indexOfTarget = this.indexOf(value)

    if(indexOfTarget !== -1)
    {
        console.log("array before delete " + this)
        this.splice(indexOfTarget, 1)
        console.log("array after delete " + this)
    }else{
        console.error("element " + value + " not found")
    }
}
numbers.delete(888)
//expected output:
//element 888 not found
numbers.delete(1)

//expected output;
//array before delete 1,2,4,4,5,3,45,9
//array after delete 2,4,4,5,3,45,9

Ich hoffe das hilft

Nutzen Sie die reduzierte Methode wie folgt:

fall a) Wenn Sie ein Element nach Index entfernen müssen:

function remove(arr, index) {
  return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}

fall b) Wenn u Element durch den Wert des Elements (int) entfernt werden muss:

function remove(arr, value) {
  return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}

Auf diese Weise können wir ein neues Array zurückgeben (wird ein cooler funktionaler Weg sein - besser als Push oder Splice verwenden), wenn das Element entfernt ist.

Array.prototype.remove = function(x) {
    var y=this.slice(x+1);
    var z=[];
    for(i=0;i<=x-1;i++) {
        z[z.length] = this[i];
    }

    for(i=0;i<y.length;i++){
        z[z.length]=y[i];
    }

    return z;
}

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

arr.splice(0,1)

console.log(arr)

Ausgang [2, 3, 4, 5];