Как удалить определенный элемент из массива в JavaScript?
У меня есть массив целых чисел, и я использую .push() метод для добавления элементов к нему.
Есть ли простой способ удалить определенный элемент из массива? Эквивалент чего-то вроде array.remove(int);,
Я должен использовать основной JavaScript - не допускается никаких структур.
159 ответов
Найти index элемента массива, который вы хотите удалить, затем удалите этот индекс с splice,
Метод splice() изменяет содержимое массива, удаляя существующие элементы и / или добавляя новые элементы.
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);Второй параметр splice количество элементов для удаления. Обратите внимание, что splice изменяет массив на месте и возвращает новый массив, содержащий элементы, которые были удалены.
Примечание: поддержка браузера для indexOf ограничена; это не поддерживается в Internet Explorer 7 и 8.
Если тебе надо indexOf в неподдерживаемом браузере попробуйте следующее polyfill, Найти больше информации об этом polyfill здесь
Array.prototype.indexOf || (Array.prototype.indexOf = function(d, e) {
var a;
if (null == this) throw new TypeError('"this" is null or not defined');
var c = Object(this),
b = c.length >>> 0;
if (0 === b) return -1;
a = +e || 0;
Infinity === Math.abs(a) && (a = 0);
if (a >= b) return -1;
for (a = Math.max(0 <= a ? a : b - Math.abs(a), 0); a < b;) {
if (a in c && c[a] === d) return a;
a++
}
return -1
});
Отредактировано в октябре 2016
- Сделайте это просто, интуитивно понятно и явно ( https://en.wikipedia.org/wiki/Occam%27s_razor)
- Сделайте это неизменным (исходный массив остается неизменным)
- Сделайте это с помощью стандартных функций JS, если ваш браузер их не поддерживает - используйте polyfill
В этом примере кода я использую функцию "array.filter(...)" для удаления ненужных элементов из массива, эта функция не меняет исходный массив и создает новый. Если ваш браузер не поддерживает эту функцию (например, IE до версии 9 или Firefox до версии 1.5), рассмотрите возможность использования фильтра polyfill из Mozilla.
Извлечение элемента (ECMA-262 Edition 5 код, также известный как 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 ]
Удаление предмета (код 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 ]
ВАЖНО ES2015 "() => {}" Синтаксис функции стрелок вообще не поддерживается в IE, Chrome до 45 версии, Firefox до 22 версии, Safari до 10 версии. Чтобы использовать синтаксис ES2015 в старых браузерах, вы можете использовать BabelJS
Удаление нескольких элементов (код ES2016)
Дополнительным преимуществом этого метода является то, что вы можете удалить несколько элементов
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 ]
ВАЖНО! Функция "array.include (...)" вообще не поддерживается в IE, Chrome до 47 версии, Firefox до 43 версии, Safari до 9 версии и Edge до 14 версии, так что здесь есть полифил из Mozilla
Удаление нескольких элементов (передовой экспериментальный JavaScript 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 ]
Ссылка
Я не знаю, как вы ожидаете array.remove(int) вести себя. Есть три возможности, о которых вы можете подумать.
Убрать элемент массива по индексу i:
array.splice(i, 1);
Если вы хотите удалить каждый элемент со значением number из массива:
for(var i = array.length - 1; i >= 0; i--) {
if(array[i] === number) {
array.splice(i, 1);
}
}
Если вы просто хотите сделать элемент по индексу i больше не существует, но вы не хотите, чтобы индексы других элементов изменились:
delete array[i];
Зависит от того, хотите ли вы оставить пустое место или нет.
Если вам нужен пустой слот, удаление возможно:
delete array[ index ];
Если вы этого не сделаете, вы должны использовать метод соединения:
array.splice( index, 1 );
И если вам нужно значение этого элемента, вы можете просто сохранить элемент возвращаемого массива:
var value = array.splice( index, 1 )[0];
Если вы хотите сделать это в каком-то порядке, вы можете использовать array.pop() за последний или array.shift() для первого (и оба возвращают значение элемента тоже).
И если вы не знаете индекс предмета, вы можете использовать array.indexOf( item ) чтобы получить это (в if() чтобы получить один предмет или в while() чтобы получить их все). array.indexOf( item ) возвращает индекс или -1, если не найден.
У друга были проблемы в Internet Explorer 8, и он показал мне, что он сделал. Я сказал ему, что это неправильно, и он сказал мне, что получил ответ здесь. Текущий верхний ответ не будет работать во всех браузерах (например, Internet Explorer 8), и он будет удалять только первое вхождение элемента.
Удалить ВСЕ экземпляры из массива
function remove(arr, item) {
for (var i = arr.length; i--;) {
if (arr[i] === item) {
arr.splice(i, 1);
}
}
}
Он перебирает массив в обратном направлении (поскольку индексы и длина изменяются при удалении элементов) и удаляет элемент, если он найден. Работает во всех браузерах.
Есть два основных подхода:
сплайс ():
anArray.splice(index, 1);удалить:
delete anArray[index];
Будьте осторожны, когда вы используете delete для массива. Это хорошо для удаления атрибутов объектов, но не так хорошо для массивов. Лучше использовать splice для массивов.
Имейте в виду, что при использовании delete для массива вы можете получить неправильные результаты для anArray.length, Другими словами, delete удалит элемент, но не обновит значение свойства length.
Вы также можете ожидать наличия дырок в индексах после использования delete, например, вы можете получить индексы 1,3,4,8,9,11 и длину, как это было до использования delete. В этом случае все проиндексировано for циклы будут аварийно завершаться, поскольку индексы больше не будут последовательными.
Если вы вынуждены использовать delete по какой-то причине, тогда вы должны использовать for each циклы, когда вам нужно перебрать массивы. На самом деле, всегда избегайте использования индексированных циклов for, если это возможно. Таким образом, код будет более надежным и менее подверженным проблемам с индексами.
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)Там нет необходимости использовать indexOf или же splice, Однако он работает лучше, если вы хотите удалить только одно вхождение элемента.
Найти и переместить (переместить):
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;
}
использование indexOf а также splice (индекс):
function indexof(arr, val) {
var i;
while ((i = arr.indexOf(val)) != -1) {
arr.splice(i, 1);
}
}
Использовать только splice (сплайсинг):
function splice(arr, val) {
for (var i = arr.length; i--;) {
if (arr[i] === val) {
arr.splice(i, 1);
}
}
}
Время выполнения на nodejs для массива с 1000 элементов (в среднем более 10000 запусков):
indexof примерно в 10 раз медленнее, чем двигаться. Даже если улучшить, удалив вызов indexOf в соединении это работает намного хуже чем движение.
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
Вы можете использовать фильтр для этого
function removeNumber(arr, num){
return arr.filter(el => {return el !== num});
}
let numbers = [1,2,3,4];
numbers = removeNumber(numbers, 3);
console.log(numbers); // [1,2,4]
Слишком стар, чтобы отвечать, но пусть это кому-то поможет, предоставив предикат вместо значения.
ПРИМЕЧАНИЕ: он обновит данный массив и возвратит затронутые строки
использование
var removed = helper.removeOne(arr, row => row.id === 5 );
var removed = helper.remove(arr, row => row.name.startsWith('BMW'));
Определение
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;
}
};
Вы можете сделать это легко с помощью метода фильтра:
function remove(arrOriginal, elementToRemove){
return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) );
Это удаляет все элементы из массива, а также работает быстрее, чем комбинация slice и indexOf.
Джон Резиг опубликовал хорошую реализацию:
// 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);
};
Если вы не хотите расширять глобальный объект, вместо этого вы можете сделать что-то вроде следующего:
// 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);
};
Но главная причина, по которой я публикую это, состоит в том, чтобы предостеречь пользователей от альтернативной реализации, предложенной в комментариях на этой странице (14 декабря 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;
};
Поначалу кажется, что это хорошо работает, но через болезненный процесс, который я обнаружил, он терпит неудачу при попытке удалить второй или последний элемент в массиве. Например, если у вас есть массив из 10 элементов, и вы пытаетесь удалить 9-й элемент следующим образом:
myArray.remove(8);
Вы получите массив из 8 элементов. Не знаю почему, но я подтвердил, что оригинальная реализация Джона не имеет этой проблемы.
Вы можете использовать ES6.
var array=['1','2','3','4','5','6']
var index = array.filter((value)=>value!='3');
Выход:
["1", "2", "4", "5", "6"]
http://underscorejs.org/ можно использовать для решения проблем с несколькими браузерами. Он использует встроенные методы браузера, если таковые имеются. Если они отсутствуют, как в случае более старых версий Internet Explorer, он использует свои собственные пользовательские методы.
Простой пример удаления элементов из массива (с сайта):
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
Вот несколько способов удалить элемент из массива с помощью JavaScript.
Все описанные методы не изменяют исходный массив, а создают новый.
Если вы знаете индекс предмета
Предположим, у вас есть массив, и вы хотите удалить элемент в позиции i,
Одним из методов является использование 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() создает новый массив с индексами, которые он получает. Мы просто создаем новый массив от начала до индекса, который мы хотим удалить, и объединяем другой массив с первой позиции, следующей за той, которую мы удалили, до конца массива.
Если вы знаете значение
В этом случае один хороший вариант заключается в использовании filter(), который предлагает более декларативный подход:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)
console.log(filteredItems)Это использует функции стрелки ES6. Вы можете использовать традиционные функции для поддержки старых браузеров:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
return item !== valueToRemove
})
console.log(filteredItems)или вы можете использовать Babel и перенести код ES6 обратно в ES5, чтобы сделать его более удобным для старых браузеров, и в то же время написать современный JavaScript в своем коде.
Удаление нескольких предметов
Что если вместо одного элемента вы хотите удалить много элементов?
Давайте найдем самое простое решение.
По индексу
Вы можете просто создать функцию и удалить элементы последовательно:
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)По значению
Вы можете искать включение внутри функции обратного вызова:
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)Избегайте мутации исходного массива
splice() (не путать с slice()) изменяет исходный массив, и его следует избегать.
(первоначально размещено на https://flaviocopes.com/how-to-remove-item-from-array/)
Если вы хотите новый массив с удаленными удаленными позициями, вы всегда можете удалить определенный элемент и отфильтровать массив. Это может потребовать расширения объекта массива для браузеров, которые не реализуют метод фильтра, но в долгосрочной перспективе это проще, так как все, что вы делаете, это:
var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));
Должен отображаться [1, 2, 3, 4, 6]
Проверьте этот код. Это работает в любом крупном браузере.
remove_item = function (arr, value) {
var b = '';
for (b in arr) {
if (arr[b] === value) {
arr.splice(b, 1);
break;
}
}
return arr;
}
Вызвать эту функцию
remove_item(array,value);
Удаление определенного элемента / строки из массива может быть выполнено в один слой: я все еще думаю, что это самый элегантный вкладыш, который вы можете получить для такого типа проблемы:
theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
где 'theArray' - массив, из которого вы хотите удалить что-то конкретное.
Обновление ES10
В этом посте суммируются общие подходы к удалению элементов из массива в ECMAScript 2019 (ES10).
1. Общие случаи
1.1. Удаление элемента массива по значению с помощью.splice()
| На месте: Да |
| Удаляет дубликаты: Да (цикл), Нет (indexOf) |
| По значению / индексу: По индексу |
Если вы знаете значение, которое хотите удалить из массива, вы можете использовать метод splice. Сначала вы должны определить индекс целевого элемента. Затем вы используете индекс в качестве начального элемента и удаляете только один элемент.
// With a 'for' loop
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for( let i = 0; i < arr.length; i++){
if ( arr[i] === 5) {
arr.splice(i, 1);
}
} // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
// With the .indexOf() method
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf(5);
arr.splice(i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Удаление элемента массива с помощью.filter() метод
| На месте: Нет |
| Удаляет дубликаты: Да |
| По значению / индексу: По значению |
Конкретный элемент можно отфильтровать из массива, предоставив функцию фильтрации. Затем такая функция вызывается для каждого элемента в массиве.
const value = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter(item => item !== value)
console.log(arr)
// [ 1, 2, 4, 5 ]
1.3. Удаление элемента массива путем расширенияArray.prototype
| На месте: Да / Нет (зависит от реализации) |
| Удаляет дубликаты: Да / Нет (зависит от реализации) |
| По значению / индексу: По индексу / по значению (зависит от реализации) |
Прототип массива может быть расширен дополнительными методами. Затем такие методы будут доступны для использования в созданных массивах.
Примечание. Расширение прототипов объектов из стандартной библиотеки JavaScript (например, Array) некоторыми рассматривается как антипаттерн.
// In-place, removes all, by value implementation
Array.prototype.remove = function(item) {
for (let i = 0; i < this.length; i++) {
if (this[i] === item) {
this.splice(i, 1);
}
}
}
const arr1 = [1,2,3,1];
arr1.remove(1) // arr1 equals [2,3]
// Non-stationary, removes first, by value implementation
Array.prototype.remove = function(item) {
const arr = this.slice();
for (let i = 0; i < this.length; i++) {
if (arr[i] === item) {
arr.splice(i, 1);
return arr;
}
}
return arr;
}
let arr2 = [1,2,3,1];
arr2 = arr2.remove(1) // arr2 equals [2,3,1]
1.4. Удаление элемента массива с помощьюdelete оператор
| На месте: Да |
| Удаляет дубликаты: Нет |
| По значению / индексу: По индексу |
Использование оператора удаления не влияет на свойство длины. Это также не влияет на индексы последующих элементов. Массив становится разреженным, что является причудливым способом сказать, что удаленный элемент не удаляется, а становится неопределенным.
const arr = [1, 2, 3, 4, 5, 6];
delete arr[4]; // Delete element with index 4
console.log( arr ); // [1, 2, 3, 4, undefined, 6]
Оператор удаления предназначен для удаления свойств из объектов JavaScript, массивы которых являются объектами.
1.5. Удаление элемента массива с помощьюObject утилиты (>= ES10)
| На месте: Нет |
| Удаляет дубликаты: Да |
| По значению / индексу: По значению |
Представлен ES10 Object.fromEntries, который можно использовать для создания желаемого массива из любого объекта, подобного массиву, и фильтрации нежелательных элементов во время процесса.
const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values(Object.fromEntries(
Object.entries(object)
.filter(([ key, val ]) => val !== valueToRemove)
));
console.log(arr); // [1,2,4]
2. Особые случаи
2.1 Удаление элемента, если он находится в конце массива
2.1.1. Изменение массиваlength| На месте: Да |
| Удаляет дубликаты: Нет |
| По стоимости / индексу: N/A |
Элементы массива JavaScript можно удалить из конца массива, установив для свойства length значение меньше текущего. Любой элемент, индекс которого больше или равен новой длине, будет удален.
const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Set length to remove element
console.log( arr ); // [1, 2, 3, 4, 5]
.pop() метод| На месте: Да |
| Удаляет дубликаты: Нет |
| По стоимости / индексу: N/A |
Метод pop удаляет последний элемент массива, возвращает этот элемент и обновляет свойство length. Метод pop изменяет массив, для которого он вызывается. Это означает, что в отличие от использования delete последний элемент полностью удаляется, а длина массива уменьшается.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop(); // returns 6
console.log( arr ); // [1, 2, 3, 4, 5]
2.2. Удаление элемента, если он находится в начале массива
| На месте: Да |
| Удаляет дубликаты: Нет |
| По стоимости / индексу: N/A |
В .shift()работает так же, как метод pop, за исключением того, что он удаляет первый элемент массива JavaScript вместо последнего. Когда элемент удаляется, остальные элементы смещаются вниз.
const arr = [1, 2, 3, 4];
arr.shift(); // returns 1
console.log( arr ); // [2, 3, 4]
2.3. Удаление элемента, если это единственный элемент в массиве
| На месте: Да |
| Удаляет дубликаты: N/A |
| По стоимости / индексу: N/A |
Самый быстрый способ - установить в качестве переменной массива пустой массив.
let arr = [1];
arr = []; //empty array
В качестве альтернативы можно использовать технику из 2.1.1, установив длину на 0.
Вы можете использовать lodash _.pull (массив мутирования), _.pullAt (массив мутирования) или _.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']
ES6 и без мутации: (октябрь 2016 г.)
const removeByIndex = (list, index) =>
[
...list.slice(0, index),
...list.slice(index + 1)
];
Затем:
removeByIndex([33,22,11,44],1) //=> [33,11,44]
Спектакль
Сегодня (2019-12-09) я провожу тесты производительности на macOS v10.13.6 (High Sierra) для выбранных решений. я показываюdelete (A), но я не использую его по сравнению с другими методами, потому что он оставил пустое место в массиве.
Выводы
- самое быстрое решение
array.splice(C) (кроме Safari для небольших массивов, где он есть второй раз) - для больших массивов,
array.slice+splice(H) - самое быстрое неизменное решение для Firefox и Safari;Array.from(B) самый быстрый в Chrome - изменяемые решения обычно в 1,5-6 раз быстрее, чем неизменяемые
- для небольших таблиц в Safari, на удивление, изменяемое решение (C) медленнее, чем неизменное решение (G)
Детали
В тестах я удаляю средний элемент из массива разными способами. A, C решения на месте. В, D, Е, F, G, H растворы являются неизменяемыми.
Результаты для массива из 10 элементов
В Chrome array.splice(C) - самое быстрое решение на месте. Вarray.filter(D) - самое быстрое неизменное решение. Самый медленныйarray.slice(F). Вы можете выполнить тест на вашей машине здесь.
Результаты для массива с 1.000.000 элементов
В Chrome array.splice (C) - это самое быстрое решение на месте (delete(C) аналогичен быстро - но он оставил пустой слот в массиве (поэтому он не выполняет "полное удаление")). Вarray.slice-splice(H) - самое быстрое неизменное решение. Самый медленныйarray.filter(D и E). Вы можете выполнить тест на вашей машине здесь.
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.Сравнение для браузеров: Chrome v78.0.0, Safari v13.0.4 и Firefox v71.0.0
ОК, например, у вас есть массив ниже:
var num = [1, 2, 3, 4, 5];
И мы хотим удалить номер 4, вы можете просто сделать следующий код:
num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5];
Если вы повторно используете эту функцию, вы напишете повторно используемую функцию, которая будет присоединена к функции Native array, как показано ниже:
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];
}
Но как быть, если вместо этого у вас есть массив ниже с несколькими [5] в массиве?
var num = [5, 6, 5, 4, 5, 1, 5];
Нам нужен цикл, чтобы проверить их все, но проще и эффективнее использовать встроенные функции JavaScript, поэтому мы пишем функцию, которая использует фильтр, как показано ниже:
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]
Также есть сторонние библиотеки, которые помогут вам сделать это, такие как Lodash или Underscore, для получения дополнительной информации смотрите lodash _.pull, _.pullAt или _.without.
Я довольно новичок в JavaScript и мне нужна эта функциональность. Я просто написал это:
function removeFromArray(array, item, index) {
while((index = array.indexOf(item)) > -1) {
array.splice(index, 1);
}
}
Тогда, когда я хочу использовать это:
//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");
Выход - как и ожидалось. ["item1", "item1"]
У вас могут быть другие потребности, чем у меня, поэтому вы можете легко изменить их в соответствии с их потребностями. Я надеюсь, что это помогает кому-то.
Я хочу ответить на основе ES6, Предположим, у вас есть массив, как показано ниже:
let arr = [1,2,3,4];
Если вы хотите удалить специальный индекс, как 2, напишите ниже код:
arr.splice(2, 1); //=> arr became [1,2,4]
Но если вы хотите удалить специальный элемент, такой как 3 и вы не знаете, его индекс, как показано ниже:
arr = arr.filter(e => e !== 3) //=> arr became [1,2,4]
Обновление: этот метод рекомендуется, только если вы не можете использовать ECMAScript 2015 (ранее известный как ES6). Если вы можете использовать его, другие ответы здесь обеспечивают гораздо более аккуратные реализации.
Этот список решит вашу проблему, а также удалит все вхождения аргумента вместо 1 (или указанного значения).
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;
}
Использование:
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]
Вы никогда не должны изменять свой массив вашего массива. Как это против функционального шаблона программирования. Что вы можете сделать, это создать новый массив без ссылки на массив, который вы хотите изменить данные с помощью метода es6 filter;
var myArray = [1,2,3,4,5,6];
Предположим, вы хотите удалить 5 из массива вы можете просто сделать это так.
myArray = myArray.filter(value => value !== 5);
Это даст вам новый массив без значения, которое вы хотите удалить. Так что результат будет
[1,2,3,4,6]; // 5 has been removed from this array
Для дальнейшего понимания вы можете прочитать документацию по MDN на Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
Если у вас есть сложные объекты в массиве, вы можете использовать фильтры? В ситуациях, когда $.inArray или array.splice не так просты в использовании. Особенно если объекты, возможно, мелкие в массиве.
Например, если у вас есть объект с полем Id, и вы хотите удалить объект из массива:
this.array = this.array.filter(function(element, i) {
return element.id !== idToRemove;
});
Вы можете сделать обратный цикл, чтобы убедиться, что индексы не испорчены, если имеется несколько экземпляров элемента.
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
Более современный подход ECMAScript 2015 (ранее известный как Harmony или ES 6). Дано:
const items = [1, 2, 3, 4];
const index = 2;
Затем:
items.filter((x, i) => i !== index);
Уступая:
[1, 2, 4]
Вы можете использовать Babel и службу polyfill, чтобы гарантировать, что это хорошо поддерживается во всех браузерах.