Как удалить определенный элемент из массива в JavaScript?
У меня есть массив целых чисел, и я использую .push()
метод для добавления элементов к нему.
Есть ли простой способ удалить определенный элемент из массива? Эквивалент чего-то вроде array.remove(int);
,
Я должен использовать основной JavaScript - не допускается никаких структур.
159 ответов
Если вы хотите удалить несколько элементов, я нашел это самым простым:
const oldArray = [1, 2, 3, 4, 5]
const removeItems = [1, 3, 5]
const newArray = oldArray.filter((value) => {
return !removeItems.includes(value)
})
console.log(newArray)
выход:
[2, 4]
Взятие прибыли по методу снижения следующим образом:
случай а) если вам нужно удалить элемент по индексу:
function remove(arr, index) {
return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}
случай б) если вам нужно удалить элемент по значению элемента (int):
function remove(arr, value) {
return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}
Таким образом, мы можем вернуть новый массив (это будет классный функциональный способ - намного лучше, чем использовать push или splice) с удаленным элементом.
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)
Выход [2, 3, 4, 5];
Метод splice() изменяет содержимое массива, удаляя или заменяя существующие элементы и / или добавляя новые элементы.
array.splice (start [, deleteCount [, item1 [, item2 [,...]]]])
Начните
Индекс, с которого начинается изменение массива (с началом 0). Если он больше длины массива, фактический начальный индекс будет установлен равным длине массива. Если отрицательно, начнется, что много элементов с конца массива (с происхождением -1) и будет установлен в 0, если абсолютное значение больше, чем длина массива.
deleteCount Необязательно
Целое число, указывающее количество удаляемых старых элементов массива. Если deleteCount опущен или если его значение больше, чем array.length - start (то есть, если оно больше, чем число элементов, оставшихся в массиве, начиная с начала), то все элементы от начала до конца из массива будут удалены. Если deleteCount равен 0 или отрицателен, никакие элементы не удаляются. В этом случае вы должны указать хотя бы один новый элемент (см. Ниже).
item1, item2,... Необязательно
Элементы для добавления в массив, начиная с начального индекса. Если вы не укажете никаких элементов, splice() удалит только элементы из массива.
Для получения дополнительной информации, пожалуйста, пройдите:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
Уже есть много ответов, но поскольку никто еще не сделал этого с одним вкладышем, я решил показать свой метод. Он использует тот факт, что функция string.split() удалит все указанные символы при создании массива. Вот пример:
var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);
В этом примере все 4 удаляются из массива. Однако важно отметить, что любой массив, содержащий символ "-", вызовет проблемы с этим примером. Короче говоря, это заставит функцию join("-") неправильно соединить вашу строку. В такой ситуации все строки "-" в приведенном выше фрагменте можно заменить любой строкой, которая не будет использоваться в исходном массиве. Вот еще один пример:
var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("!@#").split("!@#4!@#").join("!@#").split("!@#");
console.log(out);
Array.prototype.remove = function(start, end) {
var n = this.slice((end || start) + 1 || this.length);
return this.length = start < 0 ? this.length + start : start,
this.push.apply(this, n)
}
начало и конец могут быть отрицательными, в этом случае они считаются с конца массива.
если указано только начало, удаляется только один элемент.
функция возвращает новую длину массива.
z=[0,1,2,3,4,5,6,7,8,9];
newlength=z.remove(2,6);
(8) [0, 1, 7, 8, 9]
z=[0,1,2,3,4,5,6,7,8,9];
newlength=z.remove(-4,-2);
(7) [0, 1, 2, 3, 4, 5, 9]
z=[0,1,2,3,4,5,6,7,8,9];
newlength=z.remove(3,-2);
(4) [0, 1, 2, 9]
Это зависит от того, хотите ли вы сохранить пустое место или нет.
Если вам нужен пустой слот:
array[index] = undefined;
Если вам не нужен пустой слот:
Чтобы сохранить оригинал:
oldArray = [...array];
Это изменяет массив.
array.splice(index, 1);
И если вам нужно значение этого элемента, вы можете просто сохранить возвращенный элемент массива:
var value = array.splice(index, 1)[0];
Если вы хотите удалить в любом конце массива, вы можете использовать array.pop() для последнего или array.shift() для первого (оба также возвращают значение элемента).
Если вы не знаете индекс элемента, вы можете использовать array.indexOf(item), чтобы получить его (в if(), чтобы получить один элемент, или в while(), чтобы получить их все).
Фильтр с различными типами массива
**simple array**
const arr = ['1','2','3'];
const updatedArr = arr.filter(e => e !== '3');
console.warn(updatedArr);
**array of object**
const newArr = [{id:1,name:'a'},{id:2,name:'b'},{id:3,name:'c'}]
const updatedNewArr = newArr.filter(e => e.id !== 3);
console.warn(updatedNewArr);
**array of object with different parameter name**
const newArr = [{SINGLE_MDMC:{id:1,cout:10}},{BULK_MDMC:{id:1,cout:15}},{WPS_MDMC:{id:2,cout:10}},]
const newArray = newArr.filter((item) => !Object.keys(item).includes('SINGLE_MDMC'));
console.log(newArray)
Я нашел другой способ удалить определенный элемент из массива.
В приведенном ниже примере я удаляю « 2 » из списка.
1. Если массив содержит повторяющиеся значения, например, [1,2,3,4,2,2,1,1,2]
var arr = [1,2,3,4,2,2,1,1,2];
console.log(arr.filter((e)=>e!=2));
2. Если массив не содержит повторяющегося значения, например. [1,2,3,4,5]
var arr = [1,2,3,4];
arr.splice(arr.indexOf(2),1);
console.log(arr);
Помимо всех этих решений, это также можно сделать с помощью array.reduce...
const removeItem =
idx =>
arr =>
arr.reduce((acc, a, i) => idx === i ? acc : acc.concat(a), [])
const array = [1, 2, 3]
const index = 1
const newArray = removeItem(index)(array)
console.log(newArray) // logs the following array to the console : [1, 3]
... или рекурсивная функция (которая, честно говоря, не такая элегантная... может быть, у кого-то есть лучшее рекурсивное решение??)...
const removeItemPrep =
acc =>
i =>
idx =>
arr =>
// If the index equals i, just feed in the unchanged accumulator(acc) else...
i === idx ? removeItemPrep(acc)(i + 1)(idx)(arr) :
// If the array length + 1 of the accumulator is smaller than the array length of the original array concatenate the array element at index i else...
acc.length + 1 < arr.length ? removeItemPrep(acc.concat(arr[i]))(i + 1)(idx)(arr) :
// return the accumulator
acc
const removeItem = removeItemPrep([])(0)
const array = [1, 2, 3]
const index = 1
const newArray = removeItem(index)(array)
console.log(newArray) // logs the following array to the console : [1, 3]
Лодаш :
let a1 = {name:'a1'}
let a2 = {name:'a2'}
let a3 = {name:'a3'}
let list = [a1, a2, a3]
_.remove(list, a2)
//list now is [{name: "a1"}, {name: "a3"}]
Подробности см. здесь: .remove(array, [predicate=.identity])
Если вам нужен [...].remove(el)-подобный синтаксис, как и в других языках программирования, вы можете добавить этот код:
// Add remove method to Array prototype
Array.prototype.remove = function(value, count=this.length) {
while(count > 0 && this.includes(value)) {
this.splice(this.indexOf(value), 1);
count--;
}
return this;
}
Применение
// Original array
const arr = [1,2,2,3,2,5,6,7];
// Remove all 2s from array
arr.remove(2); // [1,3,5,6,7]
// Remove one 2 from beginning of array
arr.remove(2, 1); // [1,2,3,2,5,6,7]
// Remove two 2s from beginning of array
arr.remove(2, 2); // [1,3,2,5,6,7]
Вы можете манипулировать методом в соответствии с вашими потребностями.
function array_remove(arr, index) {
for (let i = index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
arr.length -= 1;
return arr;
}
my_arr = ['A', 'B', 'C', 'D'];
console.log(array_remove(my_arr, 0));
Определение:
function RemoveEmptyItems(arr) {
var result = [];
for (var i = 0; i < arr.length; i++) if (arr[i] != null && arr[i].length > 0) result.push(arr[i]);
return result;
}
Применение:
var arr = [1,2,3, "", null, 444];
arr = RemoveEmptyItems(arr);
console.log(arr);
Чтобы удалить элемент, передав его значение-
const remove=(value)=>{
myArray = myArray.filter(element=>element !=value);
}
Чтобы удалить элемент, передав его порядковый номер -
const removeFrom=(index)=>{
myArray = myArray.filter((_, i)=>{
return i!==index
})
}
Мне это нравится.
const arr = ["apple", "banana", "orange", "pear", "grape"];
const itemToRemove = "orange";
const filteredArr = arr.filter(item => item !== itemToRemove);
console.log(filteredArr); // ["apple", "banana", "pear", "grape"]
Если вы хотите создать новый массив вместо изменения исходного массива, используйтеArray.prototype.toSpliced()
:
const index = array.indexOf(value);
const newArray = array.toSpliced(index, 1);
В JavaScript вы можете использоватьArray.prototype.filter()
метод для удаления определенного значения из массива.
Вот пример:
let array = [1, 2, 3, 4, 5];
let value = 3;
array = array.filter(function(element) {
return element !== value;
});
console.log(array); // Output: [1, 2, 4, 5]
В приведенном выше коде мы сначала создаем массив и определяем значение, которое хотим удалить. Затем мы используем этот метод для создания нового массива, включающего только те элементы, которые не равны заданному значению. Наконец, мы присваиваем новый массив обратно исходной переменной массива.
Обратите внимание, чтоfilter()
метод создает новый массив вместо изменения исходного массива. Если вы хотите напрямую изменить исходный массив, вы можете использовать цикл for для перебора массива и удаления элемента по заданному индексу.
Вот пример:
let array = [1, 2, 3, 4, 5];
let value = 3;
for (let i = 0; i < array.length; i++) {
if (array[i] === value) {
array.splice(i, 1);
i--; // decrement i since the array has been modified
}
}
console.log(array); // Output: [1, 2, 4, 5]
В этом примере мы используемfor loop
чтобы перебрать массив и проверить, равен ли каждый элемент заданному значению. Если это так, мы используем метод splice() для удаления элемента по текущему индексу. Посколькуsplice()
метод изменяет исходный массив, мы уменьшаемi
чтобы убедиться, что мы проверяем следующий элемент в обновленном массиве.
Вы можете выполнить эту задачу разными способами в JavaScript.
Если вы знаете индекс значения: в этом случае вы можете использовать splice
var arr = [1,2,3,4] // Let's say we have the index, coming from some API let index = 2; // splice is a destructive method and modifies the original array arr.splice(2, 1)
Если у вас нет индекса и есть только значение: в этом случае вы можете использовать фильтр
// Let's remove '2', for example arr = arr.filter((value)=>{ return value !== 2; })
Если вы хотите избежать прямого изменения исходного массива, используйтеArray.prototype.toSpliced()
. Тем не менее, имейте в виду, что в настоящее время поддержка браузеров ограничена .
Например, у вас есть массив символов и вы хотите удалить из него букву «А».
Массив имеет метод фильтра, который может фильтровать и возвращать только те элементы, которые вам нужны.
let CharacterArray = ['N', 'B', 'A'];
Я хочу вернуть элементы, кроме «А».
CharacterArray = CharacterArray.filter(character => character !== 'A');
Тогда CharacterArray должен быть: ['N', 'B']
let removeAnElement = (arr, element)=>{
let findIndex = -1;
for (let i = 0; i<(arr.length); i++){
if(arr[i] === element){
findIndex = i;
break;
}
}
if(findIndex == -1){
return arr;
}
for (let i = findIndex; i<(arr.length-1); i++){
arr[i] = arr[i+1];
}
arr.length -= 1;
return arr;
}
let array = ['apple', 'ball', 'cat', 'dog', 'egg'];
let removeElement = 'ball';
let tempArr2 = removeAnElement(array, 'dummy');
console.log(tempArr2);
// ['apple', 'cat', 'dog', 'egg']
let tempArr = removeAnElement(array, removeElement);
console.log(tempArr);`enter code here`
// ['apple', 'cat', 'dog', 'egg']
Это может быть глобальная функция или метод настраиваемого объекта, если вам не разрешено добавлять в собственные прототипы. Он удаляет все элементы из массива, которые соответствуют любому из аргументов.
Array.prototype.remove = function() {
var what, a = arguments, L = a.length, ax;
while (L && this.length) {
what = a[--L];
while ((ax = this.indexOf(what)) !== -1) {
this.splice(ax, 1);
}
}
return this;
};
var ary = ['three', 'seven', 'eleven'];
ary.remove('seven');
Чтобы сделать его глобальным
function removeA(arr) {
var what, a = arguments, L = a.length, ax;
while (L > 1 && arr.length) {
what = a[--L];
while ((ax= arr.indexOf(what)) !== -1) {
arr.splice(ax, 1);
}
}
return arr;
}
var ary = ['three', 'seven', 'eleven'];
removeA(ary, 'seven');
А чтобы позаботиться об IE8 и ниже -
if(!Array.prototype.indexOf) {
Array.prototype.indexOf = function(what, i) {
i = i || 0;
var L = this.length;
while (i < L) {
if(this[i] === what) return i;
++i;
}
return -1;
};
}
Использование filter(): метод filter() создает новый массив со всеми элементами, которые соответствуют определенному условию.
Вы можете использовать его, чтобы отфильтровать конкретный элемент, который хотите удалить. Вот пример:
const array = [1, 2, 3, 4, 5];
const itemToRemove = 3;
const filteredArray = array.filter(item => item !== itemToRemove);
console.log(filteredArray);
// Output: [1, 2, 4, 5]
const arr = [2, 3, 1, 6];
const _index = arr.indexOf(3);
if (_index > -1) { // _index>-1 only when item exists in the array
arr.splice(_index, 1);
}
Попробуйте удалить элемент массива с помощью оператора удаления
Например:
const arr = [10, 20, 30, 40, 50, 60];
delete arr[2]; // It will Delete element present at index 2
console.log( arr ); // [10, 20, undefined , 40, 50, 60]
Примечание. Использование оператора удаления оставит пустые места/отверстия в массиве. Он не будет предупреждать о длине массива. Чтобы изменить длину массива при удалении из него элемента, используйте вместо этого метод splice.
Надеюсь, это может решить все ваши проблемы.
Я сделал эти методы как методы расширения для объектов типа Array, вы можете добавить их в свои коды и использовать как собственные методы Array.
if (!Array.prototype.removeItem) {
Object.defineProperty(Array.prototype, 'removeItem', {
/**
* Removing first instance of specified item by @value from array
* @param {any} value
* @returns
*/
value: function (value) {
var index = this.indexOf(value);
if (index > -1)
this.splice(index, 1);
return this;
}
});
}
if (!Array.prototype.removeIndex) {
Object.defineProperty(Array.prototype, 'removeIndex', {
/**
* Removing item at @index
* @param {int} index
* @returns
*/
value: function (index) {
if (index > -1)
this.splice(index, 1);
return this;
}
});
}
if (!Array.prototype.removeItems) {
Object.defineProperty(Array.prototype, 'removeItems', {
/**
* Removing all items like @value .\n
* If @value is null this function will removes all items
* @param {any} value
* @returns
*/
value: function (value) {
if (value == null)
return [];
else {
let i = 0;
while (i < this.length) {
if (this[i] === value)
this.splice(i, 1);
else
++i;
}
}
return this;
}
});
}