Come rimuovere un valore specifico dall'array usando jQuery

Ho un array che assomiglia a questo: var y = [1, 2, 3];

Vorrei rimuovere 2dall'array y.

Come posso rimuovere un valore particolare da un array usando jQuery? Ho provato pop()ma questo rimuove sempre l'ultimo elemento.

Un JSFIDDLE funzionante

Puoi fare qualcosa del genere:

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

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

Risultato:

[1, 3]

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

Con jQuery, puoi eseguire un'operazione su una riga come questa:

Esempio: http://jsfiddle.net/HWKQY/

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

Utilizza il nativo .splice()e jQuery $.inArray().

jQuery.filteril metodo è utile. Questo è disponibile per gli Arrayoggetti.

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/

Puoi usare underscore.js . Rende davvero le cose semplici.

Nel tuo caso tutto il codice che dovrai scrivere è -

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

e il risultato sarà [1,3].

Riduce il codice che scrivi.

Non un modo jQuery ma ... Perché non usare un modo più semplice. Rimuovere 'c' dal seguente array

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

Puoi anche usare: (Nota per me: non modificare oggetti che non possiedi )

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

L'aggiunta è più semplicea.push('c')

Rimuovi elemento nell'array

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

Esempio di utilizzo

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

Per utilizzare questa funzione prototipo è necessario incollarlo nel codice. Quindi puoi applicarlo a qualsiasi array con 'notazione punto':

someArr.remove('elem1')

Non esiste un modo nativo per farlo in Javascript. È possibile utilizzare una libreria o scrivere una piccola funzione per fare questo invece: http://ejohn.org/blog/javascript-array-remove/

È possibile utilizzare la funzione .not in questo modo:

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

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

La mia versione della risposta di user113716. Rimuove un valore se non viene trovata alcuna corrispondenza, il che non va bene.

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

var i = $.inArray(removeItem,y)

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

alert(y);

Questo ora rimuove 1 elemento se viene trovata una corrispondenza, 0 se non viene trovata alcuna corrispondenza.

Come funziona:

• $ .inArray (value, array) è una funzione jQuery che trova il primo indice di a valuein unarray
• Quanto sopra restituisce -1 se il valore non viene trovato, quindi verifica che i sia un indice valido prima di procedere alla rimozione. Rimuovere l'indice -1 significa rimuovere l'ultimo, che non è utile qui.
• .splice (indice, conteggio) rimuove countnumero di valori a partire da index, quindi vogliamo solo una countdi1

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

Esiste una soluzione semplice con giunzione. Secondo W3School sta seguendo la sintassi della giunzione;

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

indice obbligatorio. Un numero intero che specifica in quale posizione aggiungere / rimuovere gli elementi, utilizzare valori negativi per specificare la posizione dalla fine dell'array

quanto richiesto. Il numero di elementi da rimuovere. Se impostato su 0, nessun elemento verrà rimosso

item1, ..., itemX Opzionale. I nuovi elementi da aggiungere all'array

Tieni presente che, se trovato, i seguenti j faranno uscire uno o più oggetti corrispondenti dall'array dato, altrimenti non rimuoveranno l'ultimo elemento dell'array.

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;

O

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

Quindi il finale dovrebbe apparire come il seguente

x.splice( startItemIndex , itemsFound );

Spero che sia di aiuto.

Innanzitutto controlla se l'elemento esiste nell'array

$.inArray(id, releaseArray) > -1

la riga sopra restituisce l'indice di quell'elemento se esiste nella matrice, altrimenti restituisce -1

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

ora sopra la riga rimuoverà questo elemento dall'array se trovato. Riassumendo la logica seguente è il codice richiesto per controllare e rimuovere l'elemento dall'array.

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

Avevo un compito simile in cui dovevo eliminare più oggetti contemporaneamente in base a una proprietà degli oggetti nell'array.

Quindi dopo alcune iterazioni finisco con:

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

Estenderei la classe Array con una pick_and_remove()funzione, in questo modo:

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

Anche se può sembrare un po 'prolisso, ora puoi chiamare pick_and_remove()qualsiasi array tu voglia!

Uso:

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

Puoi vedere tutto questo nell'azione a tema Pokemon qui.

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

È quindi possibile chiamare la funzione in qualsiasi punto del codice.

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"!

Questo funziona in tutti i casi ed evita i problemi nei metodi sopra. Spero che aiuti!

Prova questo funziona per me

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

La seconda risposta più votata qui è sulla strada più vicina possibile a un metodo jQuery di una riga del comportamento desiderato che l'OP vuole, ma sono inciampati alla fine del loro codice e ha un difetto. Se il tuo articolo da rimuovere non è effettivamente nella matrice, l'ultimo elemento verrà rimosso.

Alcuni hanno notato questo problema e alcuni hanno offerto il modo di fare un giro per proteggersi. Offro il metodo più breve e pulito che ho trovato e ho commentato sotto la loro risposta il modo di correggere il loro codice secondo questo metodo.

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

l'array x rimuoverà facilmente l'elemento "ciao" e l'array y non verrà toccato.

L'uso dell'argomento $.inArray(removeItem,array)come secondo argomento finisce per essere la lunghezza da giuntare. Dal momento che l'elemento non è stato trovato, questo viene valutato array.splice(-1,-1);, il che non comporterà semplicemente la giunzione di nulla ... il tutto senza dover scrivere un ciclo per questo.

Per rimuovere in sicurezza 2 dall'array utilizzando JavaScript vanilla:

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

Fonte Polyfill: Mozilla

Solo per aggiungere alla risposta di Sarfraz, nessuno ancora sorpreso l'ha trasformata in una funzione.

Utilizzare la risposta di ddagsan utilizzando il metodo .filter se si dispone dello stesso valore più di una volta nell'array.

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>