Je ne sais pas comment vous vous attendez à ce que array.remove(int) se comporte. Il y a trois possibilités, je pense que vous pourriez vouloir.

Pour supprimer un élément d'un tableau à un indice i :

array.splice(i, 1);

si vous voulez supprimer tous les éléments de valeur number du tableau:

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

Si vous voulez juste faire l'élément à l'index i n'existe plus, mais vous ne voulez pas le index des autres éléments à modifier:

delete array[i];

Edité le 2016 octobre

• Faire simple, intuitive et explicite ( https://en.wikipedia.org/wiki/Occam%27s_razor )
• Faire immuable (tableau d'origine restent inchangées)
• Faire avec la norme JS fonctions, si votre navigateur ne supportant pas - utilisation polyfill

dans cet exemple de code, j'utilise "tableau.filtrer.(..) " fonction pour supprimer les éléments indésirables du tableau, cette fonction ne change pas le tableau original et en crée un nouveau. Si votre navigateur ne supporte pas cette fonction (par exemple, IE avant la version 9, ou Firefox avant la version 1.5), envisagez d'utiliser le filtre polyfill de Mozilla .

suppression d'un article (ECMA-262 édition 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 ]

suppression de l'article (Code ES2015)

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 "() = > {} " la syntaxe de fonction de flèche n'est pas prise en charge dans IE at all, Chrome before 45 version, Firefox before 22 version, Safari before 10 version. Pour utiliser la syntaxe ES2015 dans les anciens navigateurs, vous pouvez utiliser BabelJS

---

suppression d'articles multiples (code ES2016)

un autre avantage de cette méthode est que vous pouvez supprimer plusieurs éléments

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 " array.comprendre.(..)" la fonction n'est pas pris en charge dans IE, Chrome avant de 47 version, Firefox avant 43 version, Safari avant la version 9 et le Bord avant de la 14 à la version ici est polyfill de Mozilla

suppression de plusieurs éléments (JavaScript expérimental de pointe 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 ]

essayez-le vous-même à BabelJS :)

référence

• "1519640920 Tableau.prototype.comprend
• Cette Syntaxe De Liaison De Proposition
• composition fonctionnelle

dépend si vous voulez garder une place vide ou non.

si vous voulez un slot vide, supprimer est très bien:

delete array[ index ];

si vous ne le faites pas, vous devez utiliser la splice méthode:

array.splice( index, 1 );

et si vous avez besoin de la valeur de cet article, vous pouvez simplement stocker l'élément du tableau retourné:

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

Dans le cas où vous voulez le faire dans un certain ordre, vous pouvez utiliser array.pop() pour le dernier ou array.shift() pour le premier (et les deux renvoient également la valeur de l'article).

Et si vous ne connaissez pas l'index de l'élément, vous pouvez utiliser array.indexOf( item ) (dans "la 151960920" pour obtenir un élément ou dans un while() pour obtenir tous d'entre eux). array.indexOf( item ) renvoie soit l'indice, soit -1 s'il n'est pas trouvé. 

un ami avait des problèmes dans Internet Explorer 8 , et m'a montré ce qu'il a fait. Je lui ai dit que c'était mal, et il m'a dit qu'il a la réponse ici. La réponse top actuelle ne fonctionnera pas dans tous les navigateurs (Internet Explorer 8 par exemple), et il ne supprimera la première occurrence de l'élément.

supprimer toutes les instances d'un tableau

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

Il parcourt le tableau en arrière (depuis indices et de la longueur changera lorsque des éléments sont supprimés) et supprime l'élément s'il est trouvé. Il fonctionne dans tous les navigateurs.

il y a deux grandes approches:

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

2. supprimer : delete anArray[index];

soyez prudent lorsque vous utilisez delete pour un tableau. Il est bon pour supprimer les attributs des objets mais pas si bon pour les tableaux. Il est préférable d'utiliser splice pour les tableaux.

gardez à l'esprit que lorsque vous utilisez delete pour un tableau vous pourriez obtenir des résultats erronés pour anArray.length . En d'autres termes, delete supprimerait l'élément mais ne mettrait pas à jour la valeur de la propriété length.

vous pouvez également vous attendre à avoir des trous dans les numéros d'index après avoir utilisé delete, par exemple, vous pourriez finir par avoir des index 1,3,4,8,9,11 et de longueur comme il était avant d'utiliser delete. Dans ce cas, toutes les boucles indexées for craqueraient, puisque les index ne sont pas plus séquentielle.

si vous êtes forcé d'utiliser delete pour une raison quelconque, alors vous devez utiliser for each boucles quand vous avez besoin de boucle à travers les tableaux. En fait, évitez toujours d'utiliser des boucles indexées, si possible. De cette façon, le code serait plus robuste et moins sujettes à des problèmes avec les index.

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)

Il n'est pas nécessaire d'utiliser indexOf ou splice . Cependant, il fonctionne mieux si vous ne voulez supprimer une occurrence d'un élément.

Trouver et déplacer (move):

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

Utiliser indexOf et splice (indexof):

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

utiliser uniquement splice (splice):

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

Exécuter en temps sur nodejs pour le tableau avec les éléments de 1000 (en moyenne plus de 10000 pistes):

l'index de est environ 10 fois plus lent que move . Même s'il est amélioré en supprimant l'appel à indexOf dans splice il exécute beaucoup pire que 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

Trop vieux pour répondre, mais peut-il aider quelqu'un, en fournissant un prédicat au lieu d'une valeur.

NOTE: il mettra à jour le tableau donné, et retournera les lignes affectées

Utilisation

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

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

définition

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 a publié une bonne mise en œuvre :

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

si vous ne voulez pas étendre un objet global, vous pouvez faire quelque chose comme ceci, à la place:

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

mais la principale raison pour laquelle je poste ceci est de mettre en garde les utilisateurs contre la mise en œuvre alternative proposée dans les commentaires sur cette page (14 Décembre 2007):

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

il semble bien fonctionner au début, mais à travers un processus douloureux j'ai découvert qu'il échoue en essayant d'enlever le deuxième à dernier élément dans un tableau. Par exemple, si vous avez un tableau à 10 éléments et que vous essayez de supprimer le 9ème élément avec ceci:

myArray.remove(8);

vous vous retrouvez avec un tableau à 8 éléments. Je ne sais pas pourquoi mais J'ai confirmé que L'implémentation originale de John n'a pas ce problème.

trait de Soulignement.js peut être utilisé pour résoudre des problèmes avec plusieurs navigateurs. Il utilise les méthodes de construction de navigateur si présent. S'ils sont absents, comme dans le cas des anciennes versions d'Internet Explorer, il utilise ses propres méthodes.

un exemple simple pour supprimer des éléments du tableau (à partir du site web):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]

vous pouvez le faire facilement avec filtre méthode:

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

cela supprime tous les éléments du tableau et fonctionne aussi plus rapidement que la combinaison de slice et indexOf

Si vous voulez un nouveau tableau avec les supprimé des postes supprimés, vous pouvez toujours supprimer l'élément spécifique et filtrer le tableau. Il pourrait avoir besoin d'une extension du array object pour les navigateurs qui ne mettent pas en œuvre la méthode de filtre, mais à long terme son plus facile car tout ce que vous faites est cela:

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

devrait afficher [1, 2, 3, 4, 6]

vous pouvez utiliser ES6.

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

sortie:

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

vérifiez ce code. Il fonctionne dans chaque navigateur principal .

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

appelez cette fonction

remove_item(array,value);

vous pouvez utiliser lodash _.pull (muter ensemble), _.pullAt (mutate array) ou _.sans (ne mute pas array),

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

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

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

OK, par exemple vous avez le tableau ci-dessous:

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

et nous voulons supprimer le numéro 4, Vous pouvez simplement faire le code ci-dessous:

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

si vous réutilisez cette fonction, vous écrivez une fonction réutilisable qui sera attachée à la fonction Native array comme ci-dessous:

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

mais qu'en est-il si vous avez le tableau ci-dessous à la place avec quelques [5]s dans le tableau?

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

nous avons besoin d'une boucle pour les vérifier tous, mais il est plus facile et plus efficace d'utiliser les fonctions JavaScript intégrées, donc nous écrivons une fonction qui utilise un filtre comme ci-dessous à la place:

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]

il y a aussi des bibliothèques tierces qui vous aident à le faire, comme Lodash ou Underscore, pour plus d'info regardez lodash _.tirer._ ,pullAt ou _.sans.

Je suis assez nouveau à JavaScript et j'avais besoin de cette fonctionnalité. J'ai simplement écrit ceci:

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

Puis quand je veux l'utiliser:

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

"151920920 de Sortie" - Comme prévu. ["élément1", "élément1"]

vous pouvez avoir des besoins différents de moi, donc vous pouvez facilement le modifier pour les adapter. J'espère que cela aide quelqu'un.

ES6 et sans mutation: (octobre 2016)

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

puis:

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

mise à jour: cette méthode est recommandée uniquement si vous ne pouvez pas utiliser ECMAScript 2015 (anciennement ES6). Si vous pouvez l'utiliser, d'autres réponses ici de fournir beaucoup plus propres implémentations.

---

ce gist ici va résoudre votre problème, et supprime également toutes les occurrences de l'argument au lieu de seulement 1 (ou une valeur spécifiée).

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

Utilisation:

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]

Si vous avez des objets complexes, dans le tableau, vous pouvez utiliser des filtres? Dans les situations où $.inArray ou d'un tableau.splice est pas aussi facile à utiliser. Surtout si les objets sont peut-être superficiels dans le tableau.

E. G. si vous avez un objet avec un champ Id et que vous voulez que l'objet soit retiré d'un tableau:

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

vous ne devez jamais muter votre réseau votre réseau. Comme ceci est contre le modèle de programmation fonctionnelle. Ce que vous pouvez faire est de créer un nouveau tableau sans faire référence au tableau que vous voulez changer les données en utilisant la méthode es6 filter ;

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

Supposons que vous souhaitez supprimer 5 du tableau vous pouvez simplement le faire comme cela.

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

cela vous donnera un nouveau tableau sans la valeur que vous vouliez supprimer. Donc le résultat sera

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

pour plus de compréhension, vous pouvez lire la documentation MDN sur Array.filtre https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

plus moderne", 151940920" ECMAScript 2015 (anciennement connu comme l'Harmonie ou de l'ES 6) approche. Donnée:

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

puis:

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

Céder:

[1, 2, 4]

vous pouvez utiliser Babel et un polyfill service pour s'assurer que cela est bien pris en charge par tous les navigateurs.

voici quelques façons de supprimer un élément d'un tableau en utilisant JavaScript .

toute la méthode décrite ne pas muter le tableau original , et à la place créer un nouveau.

si vous connaissez l'index d'un article

supposons que vous ayez un tableau, et que vous voulez supprimer un élément en position i .

L'une des méthodes est d'utiliser 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() crée un nouveau tableau avec les indices qu'il reçoit. Nous créons simplement un nouveau tableau, du début à l'index que nous voulons supprimer, et concaténons un autre tableau à partir de la première position suivant celle que nous avons supprimée à la fin du tableau.

si vous connaissez la valeur

dans ce cas, une bonne option est d'utiliser filter() , qui offre un plus déclaratif :

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

console.log(filteredItems)

utilise les fonctions de flèche ES6. Vous pouvez utiliser les fonctions traditionnelles pour prendre en charge les navigateurs plus anciens:

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

console.log(filteredItems)

ou vous pouvez utiliser Babel et transférer le code ES6 de nouveau à ES5 pour le rendre plus digestible pour les vieux navigateurs, encore écrire JavaScript moderne dans votre code.

suppression de plusieurs articles

Que faire si au lieu d'un seul article, vous voulez supprimer de nombreux articles?

trouvons la solution la plus simple.

par index

vous pouvez juste créer une fonction et supprimer des éléments dans la série:

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)

en valeur

vous pouvez rechercher l'inclusion à l'intérieur de la fonction de rappel:

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)

éviter de muter le réseau d'origine

splice() (à ne pas confondre avec slice() ) mute le réseau original, et doit être évitée.

(Initialement posté à https://flaviocopes.com/how-to-remove-item-from-array / )

je sais qu'il y a déjà beaucoup de réponses, mais beaucoup d'entre elles semblent compliquer le problème. Voici un moyen simple et récursif de supprimer toutes les instances d'un soi d'appel - clé jusqu'à ce que l'index ne soit pas trouvé. Oui , il fonctionne seulement dans les navigateurs avec indexOf , mais il est simple et peut être facilement polyfilled.

fonction autonome

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

    if(index === -1) return;

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

le Prototype de la méthode

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

    if(index === -1) return;

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

j'ai une autre bonne solution pour enlever d'un tableau:

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

vous pouvez faire une boucle arrière pour vous assurer de ne pas foirer les index, s'il y a plusieurs instances de l'élément.

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

basé sur toutes les réponses qui étaient principalement correctes et en tenant compte des meilleures pratiques suggérées (en particulier ne pas utiliser Array.prototype directement), je suis venu avec le code ci-dessous:

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

en examinant la fonction ci-dessus, malgré le fait qu'elle fonctionne bien, j'ai réalisé qu'il pourrait y avoir une certaine amélioration du rendement. Utiliser également ES6 au lieu de ES5 est une approche bien meilleure. À cette fin, il s'agit du code amélioré:

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

comment utiliser:

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)

je suis en train d'écrire un billet de blog dans lequel j'ai comparé plusieurs solutions pour Array sans problème et comparé le temps qu'il faut pour exécuter. Je mettrai à jour cette réponse avec le lien une fois que j'ai fini ce post. Juste pour vous faire savoir, j'ai comparé ce qui précède contre lodash sans et au cas où le navigateur prend en charge Map , il bat lodash! Notez que je n'utilise pas Array.prototype.indexOf ou Array.prototype.includes exlcudeValues dans un Map ou Object rend querying plus rapide! ( https://jsperf.com/array-without-benchmark-against-lodash )

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