У меня есть массив чисел, и я использую метод .push ()
, чтобы добавить элементы к нему.
Есть ли простой способ удалить определенный элемент из массива? Эквивалент чего-то вроде array.remove (number);
.
Я должен использовать core JavaScript - фреймворки не допускаются.
Найдите index
элемента массива, который вы хотите удалить, а затем удалите этот индекс с помощью splice
.
Метод splice () изменяет содержимое массива, удаляя существующие элементы и / или добавление новых элементов.
<!- начать фрагмент: js hide: ложная консоль: истинная павианка: ложная ->
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
изменяет массив на месте и возвращает новый массив, содержащий элементы, которые были удалены.
Я не знаю, как вы ожидаете, что 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];
В этом примере кода я использую "array.filter (...) " функция для удаления нежелательных элементов из массива. Эта функция не изменяет исходный массив и создает новый. Если ваш браузер не поддерживает эту функцию (например,. Internet & nbsp; Exporer до версии 9 или Firefox до версии 1.5), рассмотрите возможность использования полифилла фильтра от Mozilla .
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 ]
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 ECMAScript & nbsp; 6 "() => {}" синтаксис функции стрелки не поддерживается в Интернете и вообще не поддерживается, Chrome до 45 версий, Firefox до 22 версий и Safari до 10 версий. Чтобы использовать синтаксис ECMAScript & nbsp; 6 в старых браузерах, вы можете использовать BabelJS.
Дополнительным преимуществом этого метода является то, что вы можете удалить несколько элементов
let forDeletion = [2, 3, 5]
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!
console.log(arr)
// [ 1, 4 ]
IMPORTANT "array.includes (...) "функция вообще не поддерживается в Интернете и в Интернете, в Chrome до версии 47, в Firefox до версии 43, в Safari до версии 9 и в Edge до версии 14, так что здесь есть polyfill от Mozilla .
Если предложение «Этот связующий синтаксис» когда-либо будет принято, вы сможете это сделать:
// 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 ]
[ Попробуйте сами в BabelJS :) ][6]
Ссылка
[6]: https://babeljs.io/repl/#?babili = false & evaluate = true & lineWrap = false & presets = es2015% 2Cstage-0% 2Cstage-2 & targets = & browserers = chrome% 20% 20% 20% 20% 20function% 20remove (...forDeletion)% 20% 7B% 0A% 20% 20% 20% 20% 20% 20% 20return% 20this.filter (позиция% 20% 3D% 3E% 20!for02%
Это зависит от того, хотите ли вы сохранить пустое место или нет.
Если вам нужен пустой слот, удаление в порядке:
delete array[index];
Если вы этого не сделаете, вы должны использовать метод splice:
array.splice(index, 1);
И если вам нужно значение этого элемента, вы можете просто сохранить элемент возвращаемого массива:
var value = array.splice(index, 1)[0];
Если вы хотите сделать это в каком-то порядке, вы можете использовать array.pop ()
для последнего или array.shift ()
для первого (и оба возвращают значение элемента тоже).
И если вы не знаете индекс элемента, вы можете использовать array.indexOf (item)
, чтобы получить его (в if ()
, чтобы получить один элемент, или в while ()
, чтобы получить все из них). array.indexOf (item)
возвращает либо индекс, либо -1, если не найден.& NBSP;
У друга были проблемы в Internet & nbsp; Explorer & nbsp; 8, и он показал мне, что он сделал. Я сказал ему, что это неправильно, и он сказал мне, что получил ответ здесь. Текущий верхний ответ не будет работать во всех браузерах (например, Internet & nbsp; Explorer & nbsp; 8), и он удалит только первое вхождение элемента.
function remove(arr, item) {
for (var i = arr.length; i--;) {
if (arr[i] === item) {
arr.splice(i, 1);
}
}
}
Он проходит через массив назад (поскольку индексы и длина будут меняться при удалении элементов) и удаляет элемент, если он найден. Работает во всех браузерах.
Есть два основных подхода:
spice () : anArray.splice (индекс, 1);
delete : delete anArray [index];
Будьте осторожны при использовании удаления для массива. Это хорошо для удаления атрибутов объектов, но не так хорошо для массивов. Лучше использовать splice
для массивов.
Имейте в виду, что когда вы используете delete
для массива, вы можете получить неправильные результаты для anArray.length
. Другими словами, «delete» удалит элемент, но не обновит значение свойства length.
Вы также можете ожидать, что после использования удаления будут пробелы в индексных номерах, например,. Вы можете получить индексы 1, 3, 4, 8, 9 и 11 и длину, как это было до использования удаления. В этом случае все индексированные циклы for
будут падать, поскольку индексы больше не являются последовательными.
Если по какой-то причине вы вынуждены использовать delete
, вам следует использовать для каждого
цикла, когда вам нужно циклически просматривать массивы. На самом деле, всегда избегайте использования индексированных циклов 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
(indexof):
function indexof(arr, val) {
var i;
while ((i = arr.indexOf(val)) != -1) {
arr.splice(i, 1);
}
}
Используйте только splice
(splice):
function splice(arr, val) {
for (var i = arr.length; i--;) {
if (arr[i] === val) {
arr.splice(i, 1);
}
}
}
Время выполнения на nodejs для массива с 1000 элементами (в среднем более 10000 прогонов):
indexOf
в splice , он работает намного хуже, чем 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
Это обеспечивает предикат вместо значения.
ПРИМЕЧАНИЕ: он обновит данный массив и вернет затронутые строки.
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;
}
};
Underscore.js может использоваться для решения проблем с несколькими браузерами. Он использует встроенные методы браузера, если они есть. Если они отсутствуют, как в случае более старых версий Internet & nbsp; Explorer, он использует свои собственные методы.
Простой пример удаления элементов из массива (с сайта):
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
Джон Ресиг поставил хорошую реализацию:
{{8980346}}}
Если вы не хотите расширять глобальный объект, вы можете сделать что-то вроде следующего:
// 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 г.):
{{8980348}}}
Поначалу это работает хорошо, но в результате болезненного процесса я обнаружил, что он терпит неудачу при попытке удалить элемент от второго до последнего в массиве. Например, если у вас есть массив из 10 элементов, и вы пытаетесь удалить 9-й элемент с помощью этого:
myArray.remove(8);
Вы получаете массив из 8 элементов. Не знаю почему, но я подтвердил, что первоначальная реализация Джона не имеет этой проблемы.
Вы можете сделать это легко с помощью метода фильтр:
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
.
Вы можете использовать ES6. Например, чтобы удалить значение «3» в этом случае:
var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');
console.log(newArray);
Вывод:
["1", "2", "4", "5", "6"]
Если вы хотите удалить новый массив с удаленными позициями, вы всегда можете удалить определенный элемент и отфильтровать массив. Может потребоваться расширение объекта массива для браузеров, которые не реализуют метод фильтра, но в долгосрочной перспективе это проще, поскольку все, что вы делаете, это:
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);
Вы можете использовать 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']
Хорошо, например, у вас есть массив ниже:
var num = [1, 2, 3, 4, 5];
И мы хотим удалить номер 4. Вы можете просто использовать приведенный ниже код:
num.splice(num.indexOf(4), 1); // num will be [1, 2, 3, 5];
Если вы повторно используете эту функцию, вы пишете многоразовую функцию, которая будет прикреплена к функции массива native , как показано ниже:
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] s в массиве?
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.
Все описанные методы не изменяют исходный массив, а создают новый.
Предположим, у вас есть массив, и вы хотите удалить элемент в позиции i
.
Один из методов - использовать 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()
создает новый массив с полученными индексами. Мы просто создаем новый массив от начала до индекса, который хотим удалить, и конкатенируем другой массив от первой позиции, следующей за удаленной, до конца массива.
В этом случае хорошим вариантом является использование 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/)
Я довольно новичок в 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"]
У вас могут быть другие потребности, чем у меня, поэтому вы можете легко изменить их в соответствии с ними. Я надеюсь, что это кому-то поможет.
const removeByIndex = (list, index) =>
[
...list.slice(0, index),
...list.slice(index + 1)
];
Затем:
removeByIndex([33,22,11,44],1) //=> [33,11,44]