Comment puis-je supprimer un élément particulier d'un tableau en JavaScript?
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 - no les frameworks sont autorisés.
Recherchez la index de l'élément de tableau à supprimer, puis supprimez cet index avec splice .
La méthode splice () modifie le contenu d'un tableau en supprimant éléments existants et/ou l'ajout de nouveaux éléments.
var array = [2, 5, 9];
console.log(array)
var 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 supprimés.
Je ne sais pas comment vous vous attendez à ce que array.remove(int) se comporte. Je peux penser à trois possibilités que vous voudrez peut-être.
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 index i n'existe plus, vous ne voulez pas que les index des autres éléments changent:
delete array[i];
Édité en octobre 2016
- Faites-le simple, intuitif et explicite ( https://en.wikipedia.org/wiki/Occam%27s_razor )
- Faites-le immuable (le tableau d'origine reste inchangé)
- Faites-le avec les fonctions JS standard, si votre navigateur ne les prend pas en charge - use polyfill
Dans cet exemple de code, j'utilise la fonction "array.filter (...)" pour supprimer les éléments indésirables du tableau. Cette fonction ne modifie pas le tableau d'origine et en crée un nouveau. Si votre navigateur ne prend pas en charge cette fonction (par exemple, IE avant la version 9 ou Firefox avant la version 1.5), envisagez d'utiliser le filtre de remplissage de Mozilla .
Retrait d'un article (code ECMA-262 Edition 5 alias 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 ]
Retrait 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 la fonction de flèche n'est pas prise en charge dans IE, Chrome avant la version 45, Firefox avant la version 22, Safari avant la version 10. Pour utiliser la syntaxe ES2015 dans les anciens navigateurs, vous pouvez utiliser BabelJS
Suppression de plusieurs éléments (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 La fonction "array.includes (...)" n'est pas prise en charge dans IE, Chrome avant la version 47, Firefox avant la version 43, Safari avant la version 9 et Edge avant la version 14 afin voici polyfill de Mozilla
Suppression de plusieurs éléments (JavaScript expérimental à la fine pointe de la technologie 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 vous-même dans BabelJS :)
Référence
Cela dépend si vous souhaitez conserver un emplacement vide ou non.
Si vous voulez un emplacement vide, supprimer est acceptable:
delete array[ index ];
Si vous ne le faites pas, vous devriez 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 ordre quelconque, 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 une if() pour obtenir un élément ou dans while() pour les obtenir tous). array.indexOf( item ) renvoie soit l'index, 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 avait fait. Je lui ai dit que c'était faux et il m'a dit qu'il avait la réponse ici. La réponse actuelle maximale ne fonctionnera pas dans tous les navigateurs (Internet Explorer 8 par exemple) et ne supprimera que 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 (car les index et la longueur changeront à mesure que les éléments seront supprimés) et supprimera l'élément s'il est trouvé. Cela fonctionne dans tous les navigateurs.
Il y a deux approches principales:
splice ():
anArray.splice(index, 1);delete:
delete anArray[index];
Soyez prudent lorsque vous utilisez delete pour un tableau. C'est bon pour la suppression d'attributs d'objets mais pas si bon pour les tableaux. Il vaut mieux 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 à des trous dans les index après avoir utilisé delete, par exemple. vous pourriez vous retrouver avec les index 1,3,4,8,9,11 et la longueur tels qu'ils étaient avant d'utiliser delete. 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 loops lorsque vous devez parcourir en boucle des tableaux. En fait, évitez toujours d'utiliser des boucles indexées pour, si possible. Ainsi, le code serait plus robuste et moins sujet aux problèmes d’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, cela fonctionne mieux si vous ne voulez supprimer qu'une seule occurrence d'un élément.
Trouver 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 (indexof):
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 un tableau avec 1000 éléments (moyenne de plus de 10 000 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, sa performance sera 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
Trop vieux pour répondre, mais cela peut 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
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;
}
};
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 souhaitez pas étendre un objet global, vous pouvez effectuer les opérations suivantes:
// 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 pour mettre en garde les utilisateurs contre la mise en œuvre alternative suggérée dans les commentaires sur cette page (14 déc 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 que cela échouait lorsque j'essayais de supprimer l'avant-dernier élément d'un tableau. Par exemple, si vous avez un tableau de 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 de 8 éléments. Je ne sais pas pourquoi mais j'ai confirmé que la mise en œuvre originale de John ne présentait pas ce problème.
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 d'anciennes versions d'Internet Explorer, il utilise ses propres méthodes personnalisées.
Un exemple simple pour supprimer des éléments d'un tableau (du site Web):
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
Vous pouvez le faire facilement avec filter method:
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 que la combinaison de slice et indexOf
Si vous voulez un nouveau tableau avec les positions supprimées supprimées, vous pouvez toujours supprimer l'élément spécifique et filtrer le tableau. Cela peut nécessiter une extension de array array pour les navigateurs qui n'implémentent pas la méthode de filtrage, mais à long terme, c'est plus facile car tout ce que vous faites est la suivante:
var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));
Doit 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"]
Découvrez ce code. Cela fonctionne dans tous les navigateurs majeurs .
remove_item = function (arr, value) {
var b = '';
for (b in arr) {
if (arr[b] === value) {
arr.splice(b, 1);
break;
}
}
return arr;
}
Appeler cette fonction
remove_item(array,value);
Vous pouvez utiliser lodash _.pull (tableau mutate), _.pullAt (tableau mutate) ou _.without
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 rencontrez 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 de tableau natif 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] dans le tableau?
var num = [5, 6, 5, 4, 5, 1, 5];
Nous avons besoin d’une boucle pour toutes les vérifier, mais le moyen le plus simple et le plus efficace consiste à utiliser les fonctions JavaScript intégrées. Nous avons donc écrit une fonction qui utilise le filtre comme ci-dessous:
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, telles que Lodash ou Underscore, pour plus d’informations, consultez lodash _.pull, _.pullAt ou _.outout.
Je suis assez nouveau pour 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 le modifier pour les adapter. J'espère que ça aidera quelqu'un.
ES6 & sans mutation: (octobre 2016)
const removeByIndex = (list, index) =>
[
...list.slice(0, index),
...list.slice(index + 1)
];
Ensuite :
removeByIndex([33,22,11,44],1) //=> [33,11,44]
Update: 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 fournissent des implémentations bien plus soignées.
Cet article ici résoudra votre problème et supprimera également toutes les occurrences de l’argument au lieu de 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;
}
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]
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 voulez que l'objet soit supprimé d'un tableau:
this.array = this.array.filter(function(element, i) {
return element.id !== idToRemove;
});
Voici quelques façons de supprimer un élément d'un tableau en utilisant JavaScript.
Toutes les méthodes décrites ne modifient pas le tableau d'origine, mais en créent un nouveau.
Si vous connaissez l'index d'un article
Supposons que vous avez un tableau et que vous souhaitez 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-1).concat(items.slice(i, 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 à partir de la première position qui suit 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)Ceci 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 transpiler le code ES6 en ES5 pour le rendre plus digeste pour les anciens navigateurs, tout en écrivant du code JavaScript moderne dans votre code.
Supprimer 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 le tableau d'origine
splice() (à ne pas confondre avec slice()) mute le tableau d'origine et doit être évité.
(à l'origine posté à https://flaviocopes.com/how-to-remove-item-from-array/ )
Vous ne devriez jamais transformer votre tableau en tableau. Comme cela est contre modèle de programmation fonctionnelle. Ce que vous pouvez faire est de créer un nouveau tableau sans faire référence au tableau dont vous voulez modifier les données à l'aide de la méthode es6 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 voulez 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.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
Une approche plus moderne, ECMAScript 2015 (anciennement appelée Harmony ou ES 6). Donné:
const items = [1, 2, 3, 4];
const index = 2;
Ensuite:
items.filter((x, i) => i !== index);
Rendement:
[1, 2, 4]
Vous pouvez utiliser Babel et un service polyfill pour vous assurer qu’il est bien pris en charge par les navigateurs.
Je sais qu'il y a déjà beaucoup de réponses, mais beaucoup d'entre elles semblent compliquer exagérément le problème. Voici un moyen simple et récursif de supprimer toutes les occurrences d’une clé - d’auto-appels 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);
}
J'ai une autre bonne solution pour supprimer 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 rater les index, s'il existe 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);
}
Démo en direct
Sur la base de toutes les réponses qui étaient principalement correctes et en prenant en compte les meilleures pratiques suggérées (notamment en n'utilisant pas directement Array.prototype), j'ai proposé 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 que cela fonctionne bien, j'ai réalisé qu'il pourrait y avoir une amélioration des performances. Utiliser également ES6 au lieu de ES5 est une bien meilleure approche. Pour cela, 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 évalué 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 ce post terminé. Juste pour que vous sachiez, j'ai comparé ce qui précède à lodash sans et dans le cas où le navigateur supporte Map, il bat lodash! Notez que je n'utilise pas Array.prototype.indexOf ou Array.prototype.includes pour envelopper les valeurs exlcudeValues dans une Map ou Object, ce qui accélère l'interrogation!
Vous avez 1 à 9 tableau et vous voulez supprimer 5 utiliser 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 voulez multiplier la valeur ex: - 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, 5 removed", newNumberArray);Si vous souhaitez supprimer une valeur de tableau dans un tableau, par 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);comprend le navigateur pris en charge est link
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');
Supprimer par index
Fonction qui retourne une copie du tableau sans l'élément à l'index.
/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
return array.filter(function(elem, _index){
return index != _index;
});
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));
$> [ 1, 4, 5, 6, 7 ]
Supprimer par valeur
Fonction qui retourne une copie du tableau sans la valeur.
/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
return array.filter(function(elem, _index){
return value != elem;
});
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));
$> [ 1, 3, 4, 6, 7]
Je veux répondre en fonction deES6. Supposons que vous avez un tableau comme ci-dessous:
let arr = [1,2,3,4];
Si vous voulez supprimer un index spécial comme 2, écrivez en dessous du code:
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, procédez comme ci-dessous:
arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]
Conseil : veuillez utiliser une fonction de flèche pour rappeler le filtre, sauf si vous obtenez un tableau vide.
Créer un nouveau tableau:
var my_array = new Array();
Ajoute des éléments à ce tableau:
my_array.Push("element1");
La fonction indexOf (retourne index ou -1 si non trouvé):
var indexOf = function(needle)
{
if(typeof Array.prototype.indexOf === 'function') // newer browsers
{
indexOf = Array.prototype.indexOf;
}
else // older browsers
{
indexOf = function(needle)
{
var index = -1;
for(var i = 0; i < this.length; i++)
{
if(this[i] === needle)
{
index = i;
break;
}
}
return index;
};
}
return indexOf.call(this, needle);
};
Vérifier l'indice de cet élément (testé avec firefox et IE8 +):
var index = indexOf.call(my_array, "element1");
Supprime 1 élément situé à l'index du tableau
my_array.splice(index, 1);
J'ai également couru dans la situation où je devais supprimer un élément de Array. .indexOf ne fonctionnait pas dans IE*, partageant donc ma solution jQuery.inArray() fonctionnelle.
var index = jQuery.inArray(val,arr);
if (index > -1) {
arr.splice(index, 1);
//console.log(arr);
}
2017-05-08
La plupart des réponses données fonctionnent pour une comparaison stricte, ce qui signifie que les deux objets référencent exactement le même objet en mémoire (ou sont des types primitifs), mais vous souhaitez souvent supprimer un objet non primitif d'un tableau ayant une certaine valeur. Par exemple, si vous appelez un serveur et souhaitez vérifier un objet récupéré par rapport à un objet local.
const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a // Non-primitive object that reference the same object as "a"
assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)
//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
return JSON.stringify(x) === JSON.stringify(y)
}
//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}
const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);
//resultArray = [{'field':90}]
Il existe des implémentations alternatives/plus rapides pour valuesAreEqual, mais cela fait l'affaire. Vous pouvez également utiliser un comparateur personnalisé si vous avez un champ spécifique à vérifier (par exemple, un UUID extrait par rapport à un UUID local).
Notez également qu'il s'agit d'une opération fonctionnelle, ce qui signifie qu'elle ne modifie pas le tableau d'origine.
Je pense que beaucoup d'instructions JavaScript ne sont pas bien pensées pour la programmation fonctionnelle. Splice renvoie l'élément supprimé à l'endroit où vous avez le plus souvent besoin du tableau réduit. C'est mauvais.
Imaginez que vous effectuez un appel récursif et que vous deviez passer un tableau avec un élément de moins, probablement sans l'élément indexé actuel. Ou imaginez que vous passez un autre appel récursif et que vous deviez passer un tableau avec un élément poussé.
Dans aucun de ces cas, vous pouvez exécuter myRecursiveFunction(myArr.Push(c)) ou myRecursiveFunction(myArr.splice(i,1)). Le premier idiot passera en fait la longueur du tableau et le deuxième idiot passera l'élément supprimé en tant que paramètre.
Donc, ce que je fais en fait ... Pour supprimer un élément de tableau et passer le résultat à une fonction en tant que paramètre en même temps, je procède comme suit:
myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))
Quand il s’agit de Push, c’est plus bête ... J'aime,
myRecursiveFunction((myArr.Push(c),myArr))
Je crois que dans un langage fonctionnel approprié, une méthode qui mute l'objet sur lequel elle est appelée doit renvoyer une référence à l'objet même.
Dans CoffeeScript :
my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
Utilisez InArray de jQuery:
A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`
Note: inArray retournera -1, si l'élément n'a pas été trouvé.
JavaScript JavaScript (ES5.1) - en place édition
Support du navigateur: Internet Explorer 9 ou ultérieur ( support du navigateur détaillé )
/**
* Removes all occurences of the item from the array.
*
* Modifies the array “in place”, i.e. the array passed as an argument
* is modified as opposed to creating a new array. Also returns the modified
* array for your convenience.
*/
function removeInPlace(array, item) {
var foundIndex, fromIndex;
// Look for the item (the item can have multiple indices)
fromIndex = array.length - 1;
foundIndex = array.lastIndexOf(item, fromIndex);
while (foundIndex !== -1) {
// Remove the item (in place)
array.splice(foundIndex, 1);
// Bookkeeping
fromIndex = foundIndex - 1;
foundIndex = array.lastIndexOf(item, fromIndex);
}
// Return the modified array
return array;
}
JavaScript Vanille (ES5.1) - immuable édition
Prise en charge du navigateur: identique à l'édition vanille de JavaScript en place
/**
* Removes all occurences of the item from the array.
*
* Returns a new array with all the items of the original array except
* the specified item.
*/
function remove(array, item) {
var arrayCopy;
arrayCopy = array.slice();
return removeInPlace(arrayCopy, item);
}
Vanilla ES6 - immuable édition
Support du navigateur: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( support détaillé du navigateur )
/**
* Removes all occurences of the item from the array.
*
* Returns a new array with all the items of the original array except
* the specified item.
*/
function remove(array, item) {
// Copy the array
array = [...array];
// Look for the item (the item can have multiple indices)
let fromIndex = array.length - 1;
let foundIndex = array.lastIndexOf(item, fromIndex);
while (foundIndex !== -1) {
// Remove the item by generating a new array without it
array = [
...array.slice(0, foundIndex),
...array.slice(foundIndex + 1),
];
// Bookkeeping
fromIndex = foundIndex - 1;
foundIndex = array.lastIndexOf(item, fromIndex)
}
// Return the new array
return array;
}
Supprimez l'élément à l'index i, sans transformer le tableau d'origine
/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
return Array.from(array).splice(index, 1);
}
// Another way is
function removeElement(array, index) {
return array.slice(0).splice(index, 1);
}
J'aime cette version de splice, en supprimant un élément par sa valeur en utilisant $.inArray:
$(document).ready(function(){
var arr = ["C#","Ruby","PHP","C","C++"];
var itemtoRemove = "PHP";
arr.splice($.inArray(itemtoRemove, arr),1);
});
Vous pouvez parcourir chaque array- élément et splice s'il existe dans votre array.
function destroy(arr, val) {
for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
return arr;
}
Je viens de créer un polyfill sur le Array.prototype via Object.defineProperty pour supprimer un élément souhaité d'un tableau sans générer d'erreurs lors de l'itération ultérieure via for .. in ..
if (!Array.prototype.remove) {
// Object.definedProperty is used here to avoid problems when iterating with "for .. in .." in Arrays
// https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
Object.defineProperty(Array.prototype, 'remove', {
value: function () {
if (this == null) {
throw new TypeError('Array.prototype.remove called on null or undefined')
}
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments[i] === 'object') {
if (Object.keys(arguments[i]).length > 1) {
throw new Error('This method does not support more than one key:value pair per object on the arguments')
}
var keyToCompare = Object.keys(arguments[i])[0]
for (var j = 0; j < this.length; j++) {
if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
this.splice(j, 1)
break
}
}
} else {
var index = this.indexOf(arguments[i])
if (index !== -1) {
this.splice(index, 1)
}
}
}
return this
}
})
} else {
var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
errorMessage += 'This may lead to unwanted results when remove() is executed.'
console.log(errorMessage)
}
Supprimer une valeur entière
var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]
Supprimer une valeur de chaîne
var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']
Suppression d'une valeur booléenne
var a = [true, false, true]
a.remove(false)
a // Output => [true, true]
Il est également possible de supprimer un objet dans le tableau via cette méthode Array.prototype.remove. Il vous suffit de spécifier le key => value de la Object à supprimer.
Supprimer une valeur d'objet
var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
a.remove({a: 1})
a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]
J'ai fait une extension assez efficace au tableau JavaScript de base:
Array.prototype.drop = function(k) {
var valueIndex = this.indexOf(k);
while(valueIndex > -1) {
this.removeAt(valueIndex);
valueIndex = this.indexOf(k);
}
};
Grâce à ma solution, vous pouvez supprimer un ou plusieurs éléments d'un tableau à l'aide de JavaScript pur. Il n'y a pas besoin d'une autre bibliothèque JavaScript.
var myArray = [1,2,3,4,5]; // First array
var removeItem = function(array,value) { // My clear function
if(Array.isArray(value)) { // For multi remove
for(var i = array.length - 1; i >= 0; i--) {
for(var j = value.length - 1; j >= 0; j--) {
if(array[i] === value[j]) {
array.splice(i, 1);
};
}
}
}
else { // For single remove
for(var i = array.length - 1; i >= 0; i--) {
if(array[i] === value) {
array.splice(i, 1);
}
}
}
}
removeItem(myArray,[1,4]); // myArray will be [2,3,5]
Supprimer une valeur, en utilisant une comparaison lâche, sans transformer le tableau d'origine, ES6
/**
* Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
*
* @param {Array} array Array to remove value from
* @param {*} value Value to remove
* @returns {Array} Array with `value` removed
*/
export function arrayRemove(array, value) {
for(let i=0; i<array.length; ++i) {
if(array[i] == value) {
let copy = [...array];
copy.splice(i, 1);
return copy;
}
}
return array;
}
Bien que la plupart des réponses ci-dessus répondent à la question, la raison pour laquelle la méthode slice() n'a pas été utilisée n'est pas suffisamment claire. Oui, filter() répond aux critères d'immutabilité, mais que diriez-vous de l'équivalent plus court suivant:
const myArray = [1,2,3,4];
Et maintenant, disons que nous devrions supprimer le deuxième élément du tableau, nous pouvons simplement faire: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]
Cette manière de supprimer un élément d'un tableau est fortement encouragée aujourd'hui dans la communauté en raison de sa nature simple et immuable. En général, les méthodes qui provoquent une mutation doivent être évitées. Par exemple, vous êtes encouragé à remplacer Push() par concat() et splice() par slice()
Utilisez jQuery.grep () :
var y = [1, 2, 3, 9, 4]
var removeItem = 9;
y = jQuery.grep(y, function(value) {
return value != removeItem;
});
console.log(y)<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>Supprimer un élément/une chaîne d'un tableau peut être fait dans un seul liner: Je pense toujours que c'est le liner le plus élégant que vous puissiez obtenir pour ce type de problème:
theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
où 'theArray' est le tableau dont vous voulez supprimer quelque chose de particulier.
Publiez mon code qui supprime un élément de tableau à la place et réduit également la longueur du tableau.
function removeElement(idx, arr) {
// check the index value
if (idx < 0 || idx >= arr.length) {
return;
}
// shift the elements
for (var i = idx; i > 0; --i) {
arr[i] = arr[i - 1];
}
// remove the first element in array
arr.shift();
}
Il y a beaucoup de réponses fantastiques ici, mais pour moi, ce qui a le plus fonctionné n'a tout simplement pas été de supprimer complètement mon élément du tableau, mais simplement de définir sa valeur sur null. Cela fonctionne dans la plupart des cas, et c'est une bonne solution, car j'utiliserai la variable plus tard et je ne veux pas qu'elle disparaisse, juste vide pour l'instant. En outre, cette approche est totalement compatible avec tous les navigateurs.
array.key = null;
Supprimer la dernière occurrence ou toutes les occurrences ou la première occurrence?
var array = [2, 5, 9, 5];
// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
if (array[i] === 5) {
array.splice(i, 1);
break; // Remove this line to remove all occurrences
}
}
ou
var array = [2, 5, 9, 5];
// Remove first occurrence
for (var i = 0; array.length; i++) {
if (array[i] === 5) {
array.splice(i, 1);
break; // Do not remove this line
}
}
Pour ceux qui cherchent à répliquer une méthode qui renverra un nouveau tableau dont les numéros ou les chaînes en double ont été supprimés, cela a été mis en place à partir de réponses existantes:
function uniq(array) {
var len = array.length;
var dupFree = [];
var tempObj = {};
for (var i = 0; i < len; i++) {
tempObj[array[i]] = 0;
}
console.log(tempObj);
for (var i in tempObj) {
var element = i;
if (i.match(/\d/)) {
element = Number(i);
}
dupFree.Push(element);
}
return dupFree;
}
J'ai fait une fonction
function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}
Et utilisé comme ça.
pop(valuetoremove,myarray);
À votre santé!
Une implémentation très naïve serait la suivante:
Array.prototype.remove = function(data) {
const dataIdx = this.indexOf(data)
if(dataIdx >= 0) {
this.splice(dataIdx ,1);
}
return this.length;
}
let a = [1,2,3];
// this will change arr a to [1, 3]
a.remove(2);Je retourne la longueur du tableau à partir de la fonction pour se conformer aux autres méthodes comme Array.prototype.Push().
J'ai eu ce problème moi-même (dans une situation où le remplacement de la matrice était acceptable) et résolu avec un simple:
var filteredItems = this.items.filter(function (i) {
return i !== item;
});
Pour donner un peu de contexte à l'extrait ci-dessus:
self.thingWithItems = {
items: [],
removeItem: function (item) {
var filteredItems = this.items.filter(function (i) {
return i !== item;
});
this.items = filteredItems;
}
};
Cette solution devrait fonctionner avec les éléments de référence et les éléments de valeur. Tout dépend si vous devez conserver une référence au tableau d'origine pour savoir si cette solution est applicable.
var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);
En utilisant Array.findindex, nous pouvons réduire le nombre de lignes de code.
var index,
input = [1,2,3],
indexToRemove = 1;
integers = [];
for (index in input) {
if (input.hasOwnProperty(index)) {
if (index !== indexToRemove) {
integers.Push(result);
}
}
}
input = integers;
Cette solution utilisera un tableau d'entrées et recherchera dans la saisie la valeur à supprimer. Cela va parcourir tout le tableau en entrée et le résultat sera un deuxième tableau d'entiers dont l'index spécifique a été supprimé. Le tableau d'entiers est ensuite recopié dans le tableau d'entrée.
Votre question n'indique pas si un ordre ou des valeurs distinctes sont requis.
Si vous ne vous souciez pas de l'ordre et que le conteneur n'a pas la même valeur plus d'une fois, utilisez un ensemble. Ce sera beaucoup plus rapide et plus succinct.
var aSet = new Set();
aSet.add(1);
aSet.add(2);
aSet.add(3);
aSet.delete(2);
[2,3,5].filter(i => ![5].includes(i))
Supprimer la valeur avec index et splice!
function removeArrValue(arr,value) {
var index = arr.indexOf(value);
if (index > -1) {
arr.splice(index, 1);
}
return arr;
}
supprimer un élément du dernier
arrName.pop();
supprimer un élément du premier
arrName.shift();
supprimer du milieu
arrName.splice(starting index,number of element you wnt to delete);
Ex: arrName.splice(1,1);
supprimer un élément du dernier
arrName.splice(-1);
Supprimer en utilisant le numéro d'index du tableau
delete arrName[1];
Quel dommage que vous ayez un tableau d'entiers, pas un objet où les clés sont des chaînes équivalentes à ces entiers.
J'ai parcouru beaucoup de ces réponses et elles semblent toutes utiliser la "force brute" aussi loin que je peux voir. Je n'ai pas examiné chacun d'entre eux, excusez-moi si ce n'est pas le cas. Cela convient très bien pour un petit tableau, mais que se passe-t-il si vous avez des milliers d'entiers dans celui-ci?
Corrigez-moi si je me trompe, mais ne pouvons-nous pas supposer que dans une mappe key => value, du type d'un objet JS, le mécanisme de récupération de clé peut être supposé être hautement conçu et optimisé? (NB: si un super expert me dit que ce n'est pas le cas, je peux suggérer d'utiliser la classe Map de ES6 à la place, ce qui sera certainement le cas).
Je suggère simplement que, dans certaines circonstances, la meilleure solution pourrait être de convertir votre tableau en objet ... Le problème étant, bien sûr, que vous pourriez avoir des valeurs entières répétitives. Je suggère de mettre ceux-ci dans des compartiments en tant que partie "valeur" des entrées key => value. (NB: si vous êtes sûr de ne pas avoir d'éléments de tableau récurrents, cela peut être beaucoup plus simple: utilisez les valeurs "mêmes que", et allez simplement Object.values(...) pour récupérer votre tableau modifié).
Alors tu pourrais faire:
const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f = function( acc, val, currIndex ){
// not seen this val before: make bucket... NB although val's typeof is 'number'
// there is seamless equivalence between the object key (always string)
// and this variable val
! ( val in acc ) ? acc[ val ] = []: 0;
// drop another array index in the bucket
acc[ val ].Push( currIndex );
return acc;
}
const myIntsMapObj = arr.reduce( f, {});
console.log( myIntsMapObj );
sortie:
Objet [<1 emplacement vide>, Array 1 , Array [2], Array 1 , Array 1 , <5 emplacements vides>, 46 de plus…]
il est alors facile de supprimer tous les nombres 55
delete myIntsMapObj[ 55 ]; // again, although keys are strings this works
Vous n'êtes pas obligé de tous les supprimer: les valeurs d'index sont placées dans leurs compartiments par ordre d'apparition, ainsi (par exemple):
myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop();
supprimera la première et la dernière occurrence respectivement. Vous pouvez facilement compter la fréquence des événements, remplacer tous les 55 par 3 en transférant le contenu d'un compartiment à un autre, etc.
... récupérer votre tableau int modifié est légèrement impliqué: chaque compartiment contient l'index (dans le tableau d'origine) de la valeur représentée par la clé (chaîne). Chacune de ces valeurs de compartiment est également unique: vous devez donc les transformer en clés dans un nouvel objet, avec le nombre entier (réel) de la "chaîne de clé entière" comme valeur ... puis triez les clés et passez à Object.values( ... ).
Cela semble très compliqué et prend beaucoup de temps ... mais évidemment tout dépend des circonstances et de l'utilisation souhaitée. D'après ce que je comprends, toutes les versions et tous les contextes de JS ne fonctionnent que dans un seul thread, et le thread ne "lâche pas". Il pourrait donc y avoir une congestion horrible avec une méthode de "force brute": causée pas par les opérations indexOf , mais plusieurs répétitions slicesplice.
_/ Addenda
Si vous êtes sûr, c’est trop d’ingénierie pour votre cas d’utilisation, l’approche la plus simple en matière de "force brute" est
const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )
(oui, d'autres réponses ont repéré Array.prototype.filter...)
La méthode suivante supprimera toutes les entrées d'une valeur donnée d'un tableau sans créer de nouveau tableau et avec une seule itération, soit superfast. Et cela fonctionne dans l'ancien Internet Explorer 5.5 browser:
function removeFromArray(arr, removeValue) {
for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
if (k > 0)
arr[i - k] = arr[i];
if (arr[i] === removeValue)
k++;
}
for (; k--;)
arr.pop();
}
var a = [0, 1, 0, 2, 0, 3];
document.getElementById('code').innerHTML =
'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]
removeFromArray(a, 0);
document.getElementById('code').innerHTML +=
'<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]<code id="code"></code>Array.splice () method fonctionne bien . La méthode splice () modifie le contenu d'un tableau en supprimant ou en remplaçant des éléments existants et/ou en ajoutant de nouveaux éléments. les articles enlevés.
Syntaxe: _ array.splice (index, deleteCount, item1, ....., itemX)}
Ici, index est obligatoire et les arguments rest sont facultatifs.
Par exemple:
let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]
Remarque: La méthodeArray.splice () peut être utilisée si vous connaissez l'index de l'élément que vous souhaitez supprimer. Mais nous aurons peut-être quelques cas supplémentaires, comme mentionné ci-dessous.
Si vous voulez supprimer le dernier élément, vous pouvez utiliser Array.pop ()
Si vous souhaitez supprimer uniquement le premier élément, vous pouvez utiliser Array.shift ()
Si vous connaissez l'élément seul mais pas la position (ou l'index) de l'élément et souhaitez supprimer tous les éléments correspondants à l'aide de Array.filter () method:
let arr = [1, 2, 1, 3, 4, 1, 5, 1]; let newArr = arr.filter(function(val){ return val !== 1; }); //newArr => [2, 3, 4, 5]
OU en utilisant la méthode splice ()
let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
for( let i = 0; i < arr.length-1; i++){
if ( arr[i] === 11) {
arr.splice(i, 1);
}
}
console.log(arr);
// [1, 2, 3, 4, 5, 6]
OU Supposons que nous voulions supprimer del du tableau arr:
let arr = [1, 2, 3, 4, 5, 6];
let del = 4;
if(arr.indexOf(4) >= 0) {
arr.splice(arr.indexOf(4), 1)
}
OR
let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
if(arr[i] === del) {
arr.splice(i, 1);
}
}
Si vous connaissez l'élément seul mais pas la position (ou l'index) de l'élément et souhaitez supprimer le tout premier élément correspondant à l'aide de la méthode splice ():
let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]; for( let i = 0; i < arr.length-1; i++){ if ( arr[i] === 11) { arr.splice(i, 1); break; } } console.log(arr); // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
Si vous devez prendre en charge les anciennes versions d'Internet Explorer, je vous recommande d'utiliser le polyfill suivant (remarque: il s'agit de not un framework). Il s'agit d'un remplacement à 100% compatible avec toutes les méthodes de tableau modernes (JavaScript 1.8.5/ECMAScript 5 Array Extras) compatible avec Internet Explorer 6+, Firefox 1.5+, Chrome, Safari et Opera.
Souvent, il est préférable de simplement créer un nouveau tableau avec la fonction de filtrage.
const array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]
Cela améliore également la lisibilité à mon humble avis. Je ne suis pas un partisan de slice, même si vous savez que vous devriez parfois y aller.
Définissez une méthode appelée remove () sur des objets de tableau en utilisant la fonctionnalité de prototypage de JavaScript.
Utilisez splice () method pour répondre à votre besoin.
Veuillez regarder le code ci-dessous.
Array.prototype.remove = function(item) {
// index will have -1 if item does not exist
// else it will have the index of 1st item found in array
var index = this.indexOf(item);
if (index > -1) {
// splice() method is used to add/remove items(s) in array
this.splice(index, 1);
}
return index;
}
var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
// Printing array
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)
// Removing 67 (getting its index i.e. 2)
console.log("Removing 67")
var index = arr.remove(67)
if (index > 0){
console.log("Item 67 found at ", index)
} else {
console.log("Item 67 does not exist in array")
}
// Printing updated array
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)
// ............... Output ................................
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
// Removing 67
// Item 67 found at 2
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
Remarque: Voici l'exemple de code complet exécuté sur Node.js REPL qui décrit l'utilisation de Push (), pop (), shift (), unshift () et splice (). méthodes.
> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> arr.Push(55);
17
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
> // Popping item from array (i.e. from end)
undefined
> arr.pop()
55
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Remove item from beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
16
> arr
[ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.unshift(11, 22); // Adding 2 more items at the beginning of array
18
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
undefined
> Array.prototype.remove = function(item) {
... var index = this.indexOf(item);
... if (index > -1) {
..... this.splice(index, 1); // splice() method is used to add/remove items in array
..... }
... return index;
... }
[Function]
>
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(45); // Remove 45 (You will get the index of removed item)
3
> arr
[ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(22) // Remove 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67) // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89) // Remove 89
2
> arr
[ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(100); // 100 doesn't exist, remove() will return -1
-1
>
Merci.
Splice, filter et delete pour supprimer un élément d'un tableau
Chaque tableau a son index et il est utile de supprimer un élément particulier avec son index.
La méthode splice ()
array.splice (index, 1 ); Le premier paramètre est index et le second est le nombre d'éléments
vouloir supprimer de cet index.
Donc, pour un seul élément, nous utilisons 1.
La méthode de suppression
delete array [index]
La méthode filter ()
Si vous souhaitez supprimer un élément répété dans un tableau, filtrez le tableau.
removeAll = array.filter (e => e! = elem);
où elem est l'élément que vous souhaitez supprimer du tableau et tableau est le nom de votre tableau
La méthode splice () modifie le contenu d'un tableau en supprimant ou en remplaçant des éléments existants et/ou en ajoutant de nouveaux éléments.
array.splice (start [ deleteCount [ item1 [ item2 [ ...]]]])
début
Index auquel commencer à changer le tableau (avec Origin 0). S'il est supérieur à la longueur du tableau, l'index de départ réel sera défini sur la longueur du tableau. S'il est négatif, beaucoup d'éléments commençant par la fin du tableau (avec Origine -1) seront définis sur 0 si la valeur absolue est supérieure à la longueur du tableau.
deleteCount Facultatif
Un entier indiquant le nombre d'anciens éléments de tableau à supprimer . Si deleteCount est omis ou si sa valeur est supérieure à array.length-start (c'est-à-dire, si elle est supérieure au nombre d'éléments restants dans le tableau, débutant au début), tous les éléments du début à la fin du tableau seront supprimés . Si deleteCount est 0 ou négatif, aucun élément n'est supprimé. Dans ce cas, vous devez spécifier au moins un nouvel élément (voir ci-dessous).
item1, item2, ... facultatif
Les éléments à ajouter au tableau, commençant à l'index de début. Si vous ne spécifiez aucun élément, splice () ne supprimera que les éléments du tableau.
Pour plus de références, merci de bien vouloir:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
Il y a déjà beaucoup de réponses, mais comme personne ne l'a encore fait avec un liner, j'ai pensé montrer ma méthode. Elle tire parti du fait que la fonction string.split () supprimera tous les caractères spécifiés lors de la création d'un tableau. Voici un exemple:
var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);Dans cet exemple, tous les 4 sont supprimés de la matrice. Cependant, il est important de noter que tout tableau contenant le caractère "-" causera des problèmes avec cet exemple. En bref, la fonction join ("-") réunira votre chaîne de manière incorrecte. Dans une telle situation, toutes les chaînes "-" du snipet ci-dessus peuvent être remplacées par toute chaîne qui ne sera pas utilisée dans le tableau d'origine. Voici un autre exemple:
var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("!@#").split("!@#4!@#").join("!@#").split("!@#");
console.log(out);Solution non en place
arr.slice(0,i).concat(arr.slice(i+1));
let arr = [10, 20, 30, 40, 50]
let i = 2 ; // position to remove (starting from 0)
let r = arr.slice(0,i).concat(arr.slice(i+1));
console.log(r);vous pouvez étendre l'objet tableau pour définir une fonction de suppression personnalisée comme suit
let numbers = [1,2,4,4,5,3,45,9];
numbers.delete = function(value){
var indexOfTarget = this.indexOf(value)
if(indexOfTarget !== -1)
{
console.log("array before delete " + this)
this.splice(indexOfTarget, 1)
console.log("array after delete " + this)
}else{
console.error("element " + value + " not found")
}
}
numbers.delete(888)
//expected output:
//element 888 not found
numbers.delete(1)
//expected output;
//array before delete 1,2,4,4,5,3,45,9
//array after delete 2,4,4,5,3,45,9J'espère que ça aide
Profitant de la méthode de réduction comme suit:
cas a) si vous devez supprimer élément par index:
function remove(arr, index) {
return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}
cas b) si vous devez supprimer un élément par la valeur de l’élément (int):
function remove(arr, value) {
return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}
Ainsi, de cette manière, nous pouvons renvoyer un nouveau tableau (ce sera une manière fonctionnelle et intéressante - mieux que d’utiliser Push ou splice) avec l’élément supprimé.
Array.prototype.remove = function(x) {
var y=this.slice(x+1);
var z=[];
for(i=0;i<=x-1;i++) {
z[z.length] = this[i];
}
for(i=0;i<y.length;i++){
z[z.length]=y[i];
}
return z;
}
var arr =[1,2,3,4,5];
arr.splice(0,1)
console.log(arr)
Sortie [2, 3, 4, 5];