So entfernen Sie einen bestimmten Wert mit jQuery aus dem Array

Ich habe ein Array, das so aussieht: var y = [1, 2, 3];

Ich möchte 2aus dem Array entfernen y.

Wie kann ich mit jQuery einen bestimmten Wert aus einem Array entfernen? Ich habe es versucht, pop()aber das entfernt immer das letzte Element.

Ein funktionierendes JSFIDDLE

Sie können so etwas tun:

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

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

Ergebnis:

[1, 3]

http://snipplr.com/view/14381/remove-item-from-array-with-jquery/

Mit jQuery können Sie eine einzeilige Operation wie folgt ausführen:

Beispiel: http://jsfiddle.net/HWKQY/

y.splice( $.inArray(removeItem, y), 1 );

Verwendet die native .splice()und jQuery's $.inArray().

jQuery.filterMethode ist nützlich. Dies ist für ArrayObjekte verfügbar .

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

var result = arr.filter(function(elem){
   return elem != 5; 
});//result -> [1,2,3,4]

http://jsfiddle.net/emrefatih47/ar0dhvhw/

In Ecmascript 6:

let values = [1,2,3,4,5];
let evens = values.filter(v => v % 2 == 0);
alert(evens);

https://jsfiddle.net/emrefatih47/nnn3c2fo/

Sie können underscore.js verwenden . Es macht die Dinge wirklich einfach.

In Ihrem Fall ist der gesamte Code, den Sie schreiben müssen, -

_.without([1,2,3], 2);

und das Ergebnis wird [1,3] sein.

Es reduziert den Code, den Sie schreiben.

Kein jQuery-Weg, aber ... Warum nicht einen einfacheren Weg verwenden? Entfernen Sie 'c' aus dem folgenden Array

var a = ['a','b','c','d']
a.splice(a.indexOf('c'),1);
>["c"]
a
["a", "b", "d"]

Sie können auch Folgendes verwenden: (Hinweis für mich: Ändern Sie keine Objekte, die Sie nicht besitzen. )

Array.prototype.remove = function(v) { this.splice(this.indexOf(v) == -1 ? this.length : this.indexOf(v), 1); }
var a = ['a','b','c'];
a.remove('c'); //value of "a" is now ['a','b']

Das Hinzufügen ist einfachera.push('c')

Element im Array entfernen

var arr = ["jQuery", "JavaScript", "HTML", "Ajax", "Css"];
var itemtoRemove = "HTML";
arr.splice($.inArray(itemtoRemove, arr), 1);

//This prototype function allows you to remove even array from array
Array.prototype.remove = function(x) { 
    var i;
    for(i in this){
        if(this[i].toString() == x.toString()){
            this.splice(i,1)
        }
    }
}

Anwendungsbeispiel

var arr = [1,2,[1,1], 'abc'];
arr.remove([1,1]);
console.log(arr) //[1, 2, 'abc']

var arr = [1,2,[1,1], 'abc'];
arr.remove(1);
console.log(arr) //[2, [1,1], 'abc']

var arr = [1,2,[1,1], 'abc'];
arr.remove('abc');
console.log(arr) //[1, 2, [1,1]]

Um diese Prototypfunktion verwenden zu können, müssen Sie sie in Ihren Code einfügen. Dann können Sie es auf jedes Array mit 'Punktnotation' anwenden:

someArr.remove('elem1')

In Javascript gibt es keine native Möglichkeit, dies zu tun. Sie können stattdessen eine Bibliothek verwenden oder eine kleine Funktion schreiben: http://ejohn.org/blog/javascript-array-remove/

Sie können die .not-Funktion folgendermaßen verwenden:

var arr = [ 1 , 2 , 3 , 5 , 8];
var searchValue = 2;

var newArr = $(arr).not([searchValue]).get();

Meine Version der Antwort von user113716. Er entfernt einen Wert, wenn keine Übereinstimmung gefunden wird, was nicht gut ist.

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

var i = $.inArray(removeItem,y)

if (i >= 0){
    y.splice(i, 1);
}

alert(y);

Dadurch wird jetzt 1 Element entfernt, wenn eine Übereinstimmung gefunden wird, 0, wenn keine Übereinstimmungen gefunden werden.

Wie es funktioniert:

• $ .inArray (Wert, Array) ist eine jQuery-Funktion, die den ersten Index von a valuein einem findetarray
• Der obige Wert gibt -1 zurück, wenn der Wert nicht gefunden wird. Überprüfen Sie daher, ob i ein gültiger Index ist, bevor Sie ihn entfernen. Das Entfernen von Index -1 bedeutet das Entfernen des letzten, was hier nicht hilfreich ist.
• .splice (Index, Anzahl) entfernt die countAnzahl der Werte ab index, daher möchten wir nur eine countvon1

//in case somebody needs something like this:  multidimensional array (two items)

var ar = [[0,'a'],[1,'b'],[2,'c'],[3,'d'],[4,'e'],[5,'f']];

var removeItem = 3;  


ar = jQuery.grep(ar, function(n) {
  return n[0] != removeItem;   //or n[1] for second item in two item array
});
ar;

Es gibt eine einfache Lösung mit Spleiß. Laut W3School folgt die Spleißsyntax ;

array.splice(index, howmany, item1, ....., itemX)

Index Erforderlich. Eine Ganzzahl, die angibt, an welcher Position Elemente hinzugefügt / entfernt werden sollen. Verwenden Sie negative Werte, um die Position am Ende des Arrays anzugeben

wie viele erforderlich. Die Anzahl der zu entfernenden Elemente. Bei der Einstellung 0 werden keine Elemente entfernt

item1, ..., itemX Optional. Die neuen Elemente, die dem Array hinzugefügt werden sollen

Beachten Sie, dass die folgenden js ein oder mehrere übereinstimmende Elemente aus dem angegebenen Array entfernen, wenn sie gefunden werden. Andernfalls wird das letzte Element des Arrays nicht entfernt.

var x = [1,2,3,4,5,4,4,6,7];
var item = 4;
var startItemIndex = $.inArray(item, x);
var itemsFound = x.filter(function(elem){
                            return elem == item;
                          }).length;

Oder

var itemsFound = $.grep(x, function (elem) {
                              return elem == item;
                           }).length;

Das Finale sollte also wie folgt aussehen

x.splice( startItemIndex , itemsFound );

Hoffe das hilft.

Überprüft zunächst, ob das Element im Array vorhanden ist

$.inArray(id, releaseArray) > -1

Die obige Zeile gibt den Index dieses Elements zurück, wenn es im Array vorhanden ist. Andernfalls wird -1 zurückgegeben

 releaseArray.splice($.inArray(id, releaseArray), 1);

Jetzt über der Zeile wird dieses Element aus dem Array entfernt, wenn es gefunden wird. Um die folgende Logik zusammenzufassen, ist der erforderliche Code zum Überprüfen und Entfernen des Elements aus dem Array.

  if ($.inArray(id, releaseArray) > -1) {
                releaseArray.splice($.inArray(id, releaseArray), 1);
            }
            else {
                releaseArray.push(id);
            }

Ich hatte eine ähnliche Aufgabe, bei der ich mehrere Objekte gleichzeitig löschen musste, basierend auf einer Eigenschaft der Objekte im Array.

Nach ein paar Iterationen habe ich also:

list = $.grep(list, function (o) { return !o.IsDeleted });

Ich würde die Array-Klasse um eine pick_and_remove()Funktion erweitern, wie folgt:

var ArrayInstanceExtensions = {
    pick_and_remove: function(index){
        var picked_element = this[index];
        this.splice(index,1);
        return picked_element;
    } 
};
$.extend(Array.prototype, ArrayInstanceExtensions);

Während es ein bisschen ausführlich erscheinen mag, können Sie jetzt pick_and_remove()jedes Array aufrufen, das Sie möglicherweise wollen!

Verwendungszweck:

array = [4,5,6]           //=> [4,5,6]
array.pick_and_remove(1); //=> 5
array;                    //=> [4,6]

All dies können Sie hier in Pokemon-Action sehen.

/** SUBTRACT ARRAYS **/

function subtractarrays(array1, array2){
    var difference = [];
    for( var i = 0; i < array1.length; i++ ) {
        if( $.inArray( array1[i], array2 ) == -1 ) {
                difference.push(array1[i]);
        }
    }
return difference;
}  

Sie können die Funktion dann an einer beliebigen Stelle in Ihrem Code aufrufen.

var I_like    = ["love", "sex", "food"];
var she_likes = ["love", "food"];

alert( "what I like and she does't like is: " + subtractarrays( I_like, she_likes ) ); //returns "Naughty :P"!

Dies funktioniert in allen Fällen und vermeidet die Probleme bei den oben genannten Methoden. Ich hoffe, das hilft!

Versuchen Sie dies, es funktioniert für mich

_clientsSelected = ["10", "30", "12"];
function (removeItem) {
console.log(removeItem);
   _clientsSelected.splice($.inArray(removeItem, _clientsSelected), 1);
   console.log(_clientsSelected);
`enter code here`},

Die zweithäufigste Antwort hier ist auf dem Weg, der einer einzeiligen jQuery-Methode des beabsichtigten Verhaltens, das das OP wünscht, am nächsten kommt, aber sie sind am Ende ihres Codes gestolpert, und es hat einen Fehler. Wenn sich Ihr zu entfernendes Element nicht tatsächlich im Array befindet, wird das letzte Element entfernt.

Einige haben dieses Problem bemerkt, und einige haben Möglichkeiten angeboten, sich durchzuschleifen, um sich davor zu schützen. Ich biete die kürzeste und sauberste Methode an, die ich finden konnte, und ich habe unter ihrer Antwort kommentiert, wie der Code gemäß dieser Methode repariert werden kann.

var x = [1, 2, "bye", 3, 4];
var y = [1, 2, 3, 4];
var removeItem = "bye";

// Removing an item that exists in array
x.splice( $.inArray(removeItem,x), $.inArray(removeItem,x) ); // This is the one-liner used

// Removing an item that DOESN'T exist in array
y.splice( $.inArray(removeItem,y), $.inArray(removeItem,y) ); // Same usage, different array

// OUTPUT -- both cases are expected to be [1,2,3,4]
alert(x + '\n' + y);

Array x entfernt leicht das Element "bye" und Array y bleibt unberührt.

Die Verwendung des Arguments $.inArray(removeItem,array)als zweites Argument ergibt tatsächlich die Länge zum Spleißen. Da das Element nicht gefunden wurde, wird dies ausgewertet array.splice(-1,-1);, was nur dazu führt, dass nichts gespleißt wird ... alles ohne dass dafür eine Schleife geschrieben werden muss.

So entfernen Sie 2 mit Vanille-JavaScript sicher aus dem Array:

// Define polyfill for browsers that don't natively support Array.indexOf()
if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function(searchElement, fromIndex) {
    var k;
    if (this===null) {
      throw new TypeError('"this" is null or not defined');
    }
    var O = Object(this),
      len = O.length >>> 0;
    if (len===0) return -1;
    var n = +fromIndex || 0;
    if (Math.abs(n)===Infinity) n = 0;
    if (n >= len) return -1;
    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
    while (k < len) {
      if (k in O && O[k]===searchElement) return k;
      ++k;
    }
    return -1;
  };
}

// Remove first instance of 2 from array
if (y.indexOf(2) > -1) {
  y.splice(y.indexOf(2), 1);
}

/* To remove all instances of 2 from array, change 'if' to 'while':
while (y.indexOf(2) > -1) {
  y.splice(y.indexOf(2), 1);
}
*/

console.log(y);  // Returns [1, 3]

Polyfill-Quelle: Mozilla

Nur um die Antwort von Sarfraz zu ergänzen: Überrascht hat es noch niemand in eine Funktion geschafft.

Verwenden Sie die Antwort von ddagsan mit der .filter-Methode, wenn Sie denselben Wert mehrmals in Ihrem Array haben.

function arrayRemoveVal(array, removeValue){
	var newArray = jQuery.grep(array, function(value) {return value != removeValue;});
	return newArray;
}
var promoItems = [1,2,3,4];	
promoItems = arrayRemoveVal(promoItems, 3);// removes 3
console.log(promoItems);
promoItems = arrayRemoveVal(promoItems, 3);// removes nothing
console.log(promoItems);

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.2.3/jquery.min.js"></script>