Comment supprimer une valeur spécifique d'un tableau à l'aide de jQuery

J'ai un tableau qui ressemble à ceci: var y = [1, 2, 3];

Je voudrais supprimer 2du tableau y.

Comment puis-je supprimer une valeur particulière d'un tableau à l'aide de jQuery? J'ai essayé pop()mais cela supprime toujours le dernier élément.

Un JSFIDDLE fonctionnel

Vous pouvez faire quelque chose comme ça:

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

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

Résultat:

[1, 3]

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

Avec jQuery, vous pouvez effectuer une opération sur une seule ligne comme celle-ci:

Exemple: http://jsfiddle.net/HWKQY/

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

Utilise le natif .splice()et jQuery $.inArray().

jQuery.filterest utile. Ceci est disponible pour les Arrayobjets.

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/

Dans Ecmascript 6:

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

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

Vous pouvez utiliser underscore.js . Cela rend vraiment les choses simples.

Dans votre cas, tout le code que vous devrez écrire est -

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

et le résultat sera [1,3].

Cela réduit le code que vous écrivez.

Pas un moyen jQuery mais ... Pourquoi ne pas utiliser un moyen plus simple. Supprimer «c» du tableau suivant

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

Vous pouvez également utiliser: (Remarque pour moi-même: ne modifiez pas les objets que vous ne possédez pas )

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'ajout est plus simplea.push('c')

Supprimer l'élément dans le tableau

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

Exemple d'utilisation

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

Pour utiliser cette fonction prototype, vous devez la coller dans votre code. Ensuite, vous pouvez l'appliquer à n'importe quel tableau avec la «notation par points»:

someArr.remove('elem1')

Il n'y a aucun moyen natif de le faire en Javascript. Vous pouvez utiliser une bibliothèque ou écrire une petite fonction pour le faire à la place: http://ejohn.org/blog/javascript-array-remove/

Vous pouvez utiliser la fonction .not comme ceci:

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

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

Ma version de la réponse de user113716. Son supprime une valeur si aucune correspondance n'est trouvée, ce qui n'est pas bon.

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

var i = $.inArray(removeItem,y)

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

alert(y);

Cela supprime désormais 1 élément si une correspondance est trouvée, 0 si aucune correspondance n'est trouvée.

Comment ça fonctionne:

• $ .inArray (valeur, tableau) est une fonction jQuery qui trouve le premier index d'un valuedans unarray
• Ce qui précède renvoie -1 si la valeur n'est pas trouvée, vérifiez donc que i est un index valide avant de procéder à la suppression. La suppression de l'index -1 signifie la suppression du dernier, ce qui n'est pas utile ici.
• .splice (index, count) supprime le countnombre de valeurs à partir de index, donc nous voulons juste un countde1

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

Il existe une solution simple avec épissure. Selon W3School, la syntaxe d'épissage est la suivante;

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

index Obligatoire. Un entier qui spécifie à quelle position ajouter / supprimer des éléments, Utilisez des valeurs négatives pour spécifier la position à partir de la fin du tableau

combien requis. Le nombre d'éléments à supprimer. S'il est défini sur 0, aucun élément ne sera supprimé

item1, ..., itemX Facultatif. Le ou les nouveaux éléments à ajouter au tableau

Gardez cela à l'esprit, les js suivants feront apparaître un ou plusieurs éléments correspondants du tableau donné s'ils sont trouvés, sinon ils ne supprimeraient pas le dernier élément du tableau.

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;

Ou

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

La finale devrait donc ressembler à ceci

x.splice( startItemIndex , itemsFound );

J'espère que cela t'aides.

Vérifie d'abord si l'élément existe dans le tableau

$.inArray(id, releaseArray) > -1

la ligne ci-dessus renvoie l'index de cet élément s'il existe dans le tableau, sinon il renvoie -1

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

maintenant au-dessus de la ligne supprimera cet élément du tableau s'il est trouvé. Pour résumer la logique ci-dessous est le code requis pour vérifier et supprimer l'élément du tableau.

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

J'ai eu une tâche similaire où je devais supprimer plusieurs objets à la fois en fonction d'une propriété des objets du tableau.

Donc, après quelques itérations, je me retrouve avec:

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

J'étendrais la classe Array avec une pick_and_remove()fonction, comme ceci:

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

Bien que cela puisse sembler un peu bavard, vous pouvez maintenant appeler pick_and_remove()n'importe quel tableau que vous souhaitez!

Usage:

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

Vous pouvez voir tout cela dans une action sur le thème pokemon ici.

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

Vous pouvez ensuite appeler la fonction n'importe où dans votre code.

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

Cela fonctionne dans tous les cas et évite les problèmes dans les méthodes ci-dessus. J'espère que cela pourra aider!

Essayez ça ça marche pour moi

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

La deuxième réponse la plus votée ici est sur la piste la plus proche possible d'une méthode jQuery à une ligne du comportement souhaité du PO, mais ils ont trébuché à la fin de leur code, et il a un défaut. Si votre élément à supprimer n'est pas réellement dans le tableau, le dernier élément sera supprimé.

Quelques-uns ont remarqué ce problème et certains ont proposé des moyens de boucler pour éviter cela. J'offre la méthode la plus courte et la plus propre que j'ai pu trouver, et j'ai commenté sous leur réponse la manière de corriger leur code selon cette méthode.

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

le tableau x supprimera facilement l'élément "bye" et le tableau y sera intact.

L'utilisation de l'argument $.inArray(removeItem,array)comme deuxième argument finit par être la longueur à épisser. Étant donné que l'élément n'a pas été trouvé, cela est évalué array.splice(-1,-1);, ce qui entraînera simplement que rien ne sera épissé ... le tout sans avoir à écrire une boucle pour cela.

Pour supprimer en toute sécurité 2 du tableau à l'aide de 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]

Source Polyfill: Mozilla

Juste pour ajouter à la réponse de Sarfraz, personne n'a surpris que cela en soit encore une fonction.

Utilisez la réponse de ddagsan en utilisant la méthode .filter si vous avez plusieurs fois la même valeur dans votre tableau.

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>