J'ai un tableau de nombres et j'utilise la méthode .push() pour y ajouter des éléments.

Existe-t-il un moyen simple de supprimer un élément spécifique d'un tableau?

L'équivalent de quelque chose comme -

array.remove(number);

Je dois utiliser core JavaScript - les frameworks ne sont pas autorisés.

8042
Walker 24 avril 2011 à 02:17

29 réponses

Meilleure réponse

Recherchez le index de l'élément de tableau que vous souhaitez supprimer à l'aide de indexOf, puis supprimez cet index avec splice.

La méthode splice () modifie le contenu d'un tableau en supprimant les éléments existants et / ou en ajoutant de nouveaux éléments.

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

Le deuxième paramètre de splice est le nombre d'éléments à supprimer. Notez que splice modifie le tableau en place et renvoie un nouveau tableau contenant les éléments qui ont été supprimés.

11527
laurent 29 déc. 2019 à 19:33

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

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

array.splice(i, 1);

Si vous souhaitez supprimer tous les éléments avec la valeur number du tableau:

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

Si vous voulez simplement que l'élément à l'index i n'existe plus, mais vous ne voulez pas que les index des autres éléments changent:

delete array[i];
1218
Peter Mortensen 8 mars 2020 à 17:09

Vous pouvez le faire facilement avec le filter 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 également plus rapidement qu'une combinaison de slice et indexOf.

66
Peter Mortensen 1 sept. 2019 à 22:16

Vous avez 1 à 9 dans le tableau et vous souhaitez supprimer 5. Utilisez le code ci-dessous:

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

Si vous souhaitez plusieurs valeurs. Exemple: - 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, 1,7 and 8 removed", newNumberArray);

Si vous souhaitez supprimer une valeur de tableau dans un tableau. Exemple: [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);

Le navigateur pris en charge est un lien.

20
Thilina Sampath 2 sept. 2019 à 04:01
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)
141
Anthony 25 sept. 2017 à 04:56

Je suis assez nouveau sur 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");

Sortie - Comme prévu. ["item1", "item1"]

Vous pouvez avoir des besoins différents des miens, vous pouvez donc facilement les modifier en fonction de vos besoins. J'espère que ça aidera quelqu'un.

29
yckart 30 déc. 2014 à 16:17

Je souhaite répondre sur la base de ECMAScript 6. Supposons que vous ayez un tableau comme ci-dessous:

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

Si vous souhaitez supprimer à un index spécial comme 2, écrivez le code ci-dessous:

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

Mais si vous voulez supprimer un élément spécial comme 3 et que vous ne connaissez pas son index, faites comme ci-dessous:

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

Astuce : veuillez utiliser une fonction de flèche pour le rappel du filtre, sauf si vous obtiendrez un tableau vide.

26
Peter Mortensen 1 sept. 2019 à 22:59

La suppression d'un élément / chaîne particulier d'un tableau peut être effectuée dans une seule ligne:

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

Où:

theArray : le tableau dont vous voulez supprimer quelque chose de particulier

stringToRemoveFromArray : la chaîne que vous souhaitez supprimer et 1 est la quantité d'éléments que vous souhaitez supprimer.

REMARQUE : Si "stringToRemoveFromArray" ne se trouve pas dans votre tableau in, cela supprimera le dernier élément du tableau.

C'est toujours une bonne pratique de vérifier si l'élément existe dans votre tableau avant de le supprimer.

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

Si vous avez accès à des versions plus récentes d'Ecmascript sur les ordinateurs de votre client (AVERTISSEMENT, peut ne pas fonctionner sur les stations plus anciennes):

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

Où «3» est la valeur que vous souhaitez supprimer du tableau. Le tableau deviendrait alors: ['1','2','4','5','6']

30
Max Alexander Hanna 3 avril 2020 à 01:58

ES6 et sans mutation: (octobre 2016)

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)
34
Dipen 10 févr. 2020 à 07:37

John Resig a publié une bonne implémentation:

// 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 souhaitez 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 raison principale pour laquelle je poste ceci est pour mettre en garde les utilisateurs contre l'implémentation alternative suggéré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;
};

Cela semble bien fonctionner au début, mais grâce à un processus douloureux, j'ai découvert qu'il échouait en essayant de supprimer l'avant-dernier élément d'un tableau. Par exemple, si vous avez un tableau à 10 éléments et que vous essayez de supprimer le 9e é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 d'origine de John n'a pas ce problème.

64
magiccrafter 16 févr. 2015 à 12:51

Voici quelques façons de supprimer un élément d'un tableau à l'aide de JavaScript .

Toutes les méthodes décrites ne modifient pas le tableau d'origine et en créent plutôt un nouveau.

Si vous connaissez l'index d'un article

Supposons que vous ayez un tableau et que vous souhaitiez supprimer un élément en position i.

Une méthode consiste à utiliser slice():

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

console.log(filteredItems)

slice() crée un nouveau tableau avec les index 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 de la première position suivant celle que nous avons supprimée jusqu'à la fin du tableau.

Si vous connaissez la valeur

Dans ce cas, une bonne option consiste à utiliser filter(), qui offre une approche plus déclarative :

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

console.log(filteredItems)

Cela utilise les fonctions fléchées ES6. Vous pouvez utiliser les fonctions traditionnelles pour prendre en charge les anciens navigateurs:

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 transpiler le code ES6 vers ES5 pour le rendre plus digeste pour les anciens navigateurs, tout en écrivant du JavaScript moderne dans votre code.

Suppression de plusieurs éléments

Et si au lieu d'un seul élément, vous souhaitez supprimer plusieurs éléments?

Trouvons la solution la plus simple.

Par index

Vous pouvez simplement créer une fonction et supprimer des éléments en 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)

Par valeur

Vous pouvez rechercher une inclusion dans 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)

Évitez de muter la matrice d'origine

splice() (à ne pas confondre avec slice()) mute le tableau d'origine et doit être évité.

(initialement publié sur https://flaviocopes.com/how-to-remove- item-from-array /)

34
Flavio Copes 14 avril 2019 à 16:39

Vous pouvez utiliser ES6. Par exemple, pour supprimer la valeur «3» dans ce cas:

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

Production :

["1", "2", "4", "5", "6"]
62
darmis 1 oct. 2019 à 22:13

Vous ne devez jamais muter votre tableau. Comme c'est contre le modèle de programmation fonctionnelle. Vous pouvez créer un nouveau tableau sans référencer le tableau dont vous souhaitez modifier les données à l'aide de la méthode ECMAScript 6 filter;

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

Supposons que vous souhaitiez supprimer 5 du tableau, vous pouvez simplement le faire comme ceci:

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

Cela vous donnera un nouveau tableau sans la valeur que vous vouliez supprimer. Le résultat sera donc:

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

Pour une meilleure compréhension, vous pouvez lire la documentation MDN sur Array.filter.

23
Peter Mortensen 1 sept. 2019 à 22:41

Sur la base de toutes les réponses qui étaient principalement correctes et en tenant compte des meilleures pratiques suggérées (notamment en n'utilisant pas directement Array.prototype), j'ai trouvé 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 amélioration des performances. L'utilisation d'ES6 au lieu d'ES5 est également une bien meilleure approche. À cette fin, voici le 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)

J'écris actuellement un article de blog dans lequel j'ai testé plusieurs solutions pour Array sans problème et comparé le temps qu'il faut pour fonctionner. Je mettrai à jour cette réponse avec le lien une fois que j'aurai terminé ce post. Juste pour vous faire savoir, j'ai comparé ce qui précède avec 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 pour encapsuler les valeurs exlcude dans un Map ou Object accélère les requêtes!

18
Ardi 19 nov. 2018 à 23:02

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

Par exemple. si vous avez un objet avec un champ Id et que vous souhaitez que l'objet soit supprimé d'un tableau:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
27
Anik Islam Abhi 10 nov. 2015 à 04:20

Mise à jour: cette méthode n'est recommandée que si vous ne pouvez pas utiliser ECMAScript 2015 (anciennement ES6). Si vous pouvez l'utiliser, d'autres réponses ici fournissent des implémentations beaucoup plus soignées.


Cet élément ici résoudra votre problème et supprimera également toutes les occurrences de l'argument au lieu d'une seule ( 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;
}

Usage:

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]
25
zykadelic 1 sept. 2017 à 22:41

Si vous souhaitez supprimer un nouveau tableau avec les positions supprimées, vous pouvez toujours supprimer l'élément spécifique et filtrer le tableau. Il peut avoir besoin d'une extension de objet tableau pour les navigateurs qui n'implémentent pas la méthode de filtrage , mais à long terme, c'est plus facile puisque tout ce que vous faites est le suivant:

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

Il doit afficher [1, 2, 3, 4, 6].

52
Peter Mortensen 1 sept. 2019 à 20:30

Un ami rencontrait des problèmes dans Internet Explorer 8 et m'a montré ce qu'il avait fait. Je lui ai dit que c'était mal, et il m'a dit qu'il avait obtenu la réponse ici. La première réponse actuelle ne fonctionnera pas dans tous les navigateurs (Internet Explorer 8 par exemple) et supprimera uniquement 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 (puisque les indices et la longueur changeront à mesure que les éléments sont supprimés) et supprime l'élément s'il est trouvé. Cela fonctionne dans tous les navigateurs.

268
Peter Mortensen 1 sept. 2019 à 21:54

Underscore.js peut être utilisé pour résoudre des problèmes avec plusieurs navigateurs. Il utilise des méthodes de navigateur intégrées si elles sont présentes. S'ils sont absents comme dans le cas des anciennes versions d'Internet Explorer, il utilise ses propres méthodes personnalisées.

Un exemple simple pour supprimer des éléments du tableau (du site Web):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
63
Peter Mortensen 21 mai 2017 à 11:29

Performance

Aujourd'hui (2019-12-09), je réalise des tests de performances sur macOS v10.13.6 (High Sierra) pour les solutions choisies. Je montre delete (A), mais je ne l'utilise pas en comparaison avec d'autres méthodes, car cela laisse un espace vide dans le tableau.

Les conclusions

  • la solution la plus rapide est array.splice (C) (sauf Safari pour les petits tableaux où il a la deuxième fois)
  • pour les grands tableaux, array.slice+splice (H) est la solution immuable la plus rapide pour Firefox et Safari; Array.from (B) est le plus rapide dans Chrome
  • les solutions mutables sont généralement 1,5x à 6x plus rapides qu'immuables
  • pour les petites tables sur Safari, étonnamment la solution mutable (C) est plus lente que la solution immuable (G)

Détails

Dans les tests, je supprime l'élément central du tableau de différentes manières. Les solutions A, C sont en place. Les solutions B, D, E, F, G, H sont immuables.

Résultats pour un tableau à 10 éléments

Enter image description here

Dans Chrome, le array.splice (C) est la solution sur place la plus rapide. Le array.filter (D) est la solution immuable la plus rapide. Le plus lent est array.slice (F). Vous pouvez effectuer le test sur votre machine ici.

Résultats pour un tableau avec 1 000 000 d'éléments

Enter image description here

Dans Chrome, le array.splice (C) est la solution en place la plus rapide (le delete (C) est similaire rapidement - mais il a laissé un emplacement vide dans le tableau (il n'effectue donc pas de retirer')). Le array.slice-splice (H) est la solution immuable la plus rapide. Le plus lent est array.filter (D et E). Vous pouvez effectuer le test sur votre machine ici.

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);
This snippet only presents code used in performance tests - it does not perform tests itself.

Comparaison pour les navigateurs: Chrome v78.0.0, Safari v13.0.4 et Firefox v71.0.0

Enter image description here

20
Peter Mortensen 8 mars 2020 à 17:33

Découvrez ce code. Il fonctionne dans tous les principaux navigateurs .

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);
43
Ekramul Hoque 24 mai 2014 à 07:02

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

Rechercher et déplacer (déplacer):

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

Utilisez indexOf et splice (index de):

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

Utilisez uniquement splice (épissure):

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

Temps d'exécution sur nodejs pour tableau à 1000 éléments (moyenne sur 10000 exécutions):

indexof est environ 10 fois plus lent que move . Même s'il est amélioré en supprimant l'appel à indexOf dans splice , il est bien 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
103
slosd 11 sept. 2015 à 12:47

Cela fournit un prédicat au lieu d'une valeur.

REMARQUE: il mettra à jour le tableau donné et renverra les lignes affectées.

Usage

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;
    }
};
71
Peter Mortensen 1 sept. 2019 à 22:18

Vous pouvez utiliser loda _.pull (tableau de mutation), _. pullAt (tableau de mutation) ou _.without (ne mute pas le tableau),

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']
41
Chun Yang 25 août 2015 à 21:19

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

Fonction autonome

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

    if(index === -1) return;

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

Méthode prototype

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

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}
18
wharding28 19 févr. 2014 à 22:20

Une approche plus moderne, ECMAScript 2015 (anciennement Harmony ou ES 6). Donné:

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

Alors:

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

Rendement:

[1, 2, 4]

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

22
Peter Mortensen 25 juin 2016 à 13:01

Il existe deux approches principales:

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

  2. supprimer : delete anArray[index];

Soyez prudent lorsque vous utilisez la suppression pour un tableau. C'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 pouvez obtenir des résultats erronés pour anArray.length. En d'autres termes, delete supprimerait l'élément, mais il 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é la suppression, par exemple vous pourriez vous retrouver avec les index 1, 3, 4, 8, 9 et 11 et leur longueur comme avant d'utiliser la suppression. Dans ce cas, toutes les boucles for indexées se bloqueraient, car les index ne sont plus séquentiels.

Si vous êtes obligé d'utiliser delete pour une raison quelconque, vous devez utiliser for each effectue une boucle lorsque vous devez parcourir les tableaux. En fait, évitez toujours d'utiliser des boucles for indexées, si possible. De cette façon, le code serait plus robuste et moins sujet aux problèmes d'index.

166
Peter Mortensen 1 sept. 2019 à 21:51

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 utiliser 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 de tableau native 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 que diriez-vous 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 un moyen plus simple et plus efficace utilise les fonctions JavaScript intégrées, nous écrivons donc 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 existe également des bibliothèques tierces qui vous aident à le faire, comme Lodash ou Underscore. Pour plus d'informations, consultez lodash _.pull, _.pullAt ou _.without.

34
Peter Mortensen 1 sept. 2019 à 22:33

Cela dépend si vous souhaitez conserver un emplacement vide ou non.

Si vous voulez un emplacement vide, la suppression est très bien:

delete array[index];

Si ce n'est pas le cas, vous devez utiliser la méthode splice:

array.splice(index, 1);

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

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

Si vous souhaitez 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'élément).

Et si vous ne connaissez pas l'index de l'élément, vous pouvez utiliser array.indexOf(item) pour l'obtenir (dans un if() pour obtenir un élément ou dans un while() pour les obtenir tous) . array.indexOf(item) renvoie l'index ou -1 s'il n'est pas trouvé.

440
Peter Mortensen 1 sept. 2019 à 20:29