Как удалить конкретный элемент из массива в JavaScript?
у меня есть массив целых чисел, и я использую .push()
метод добавления элементов к нему.
есть ли простой способ удалить определенный элемент из массива? Эквивалент чего-то вроде array.remove(int);
.
Я должен использовать базовый JavaScript -нет основы.
30 ответов
найти 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
});
Я не знаю, как вы ожидаете 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);
}
}
если вы просто хотите сделать элемент в index i
больше не существует, но вы не хотите, чтобы индексы других элементов менялись:
delete array[i];
отредактировано 2016 октября
- сделайте это просто, интуитивно и явно (https://en.wikipedia.org/wiki/Occam%27s_razor)
- Do It immutable (исходный массив остается неизменным)
- сделайте это со стандартными функциями JS, если Ваш браузер не поддерживает их -использовать polyfill
в этом примере я использую "массива.фильтр.(..)" функция для удаления нежелательных элементов из массива, эта функция не изменяет исходный массив и создает новый. Если Ваш браузер не поддерживает эту функцию (например, IE до версии 9, или Firefox до версии 1.5), рассмотрите возможность использования фильтр polyfill от Mozilla.
удаление элемента (ECMA-262 Edition 5 code aka 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 ]
удаление элемента (код 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 at все, 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 ]
важно "массива.включает.(..) "функция не поддерживается в IE вообще, Chrome до версии 47, Firefox до версии 43, Safari до версии 9 и Edge до версии 14 так вот polyfill от 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 ]
ссылка
зависит от того, хотите ли вы сохранить пустое место или нет.
если вы хотите, пустой слот, удалить нормально:
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);
}
}
}
он проходит через массив назад (так как индексы и длина будут меняться по мере удаления элементов) и удаляет элемент, если он найден. Он работает во всех браузерах.
существует два основных подхода:
splice ():
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
циклы, когда вам нужно перебирать массивы. На самом деле, всегда избегайте использования индексированных циклов, если это возможно. Таким образом, код будет более надежным и менее подверженным проблемы с индексами.
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
(соединения):
function splice(arr, val) {
for (var i = arr.length; i--;) {
if (arr[i] === val) {
arr.splice(i, 1);
}
}
}
время выполнения на nodejs для массива с 1000 элементами (в среднем более 10000 runs):
метод 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
слишком стар для ответа, но может помочь кому-то, предоставив предикат вместо значения.
Примечание: он обновит данный массив и вернет затронутые строки
использование
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;
}
};
Джон В Отставку опубликовал хорошую реализацию:
// 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-элементный массив. Не знаю почему, но я подтвердил, что первоначальная реализация Джона не имеет этой проблемы.
подчеркивания.js может использоваться для решения проблем с несколькими браузерами. Он использует методы браузера в сборке, если они присутствуют. Если они отсутствуют, как в случае более старых версий Internet Explorer, он использует свои собственные пользовательские методы.
простой пример удаления элементов из массива (с сайта):
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
вы можете сделать это легко с фильтр способ:
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
Если вы хотите новый массив с удаленными позициями, вы всегда можете удалить конкретный элемент и отфильтровать массив. Возможно, потребуется расширение массив объектов для браузеров, которые не реализуют метод фильтра, но в долгосрочной перспективе его проще, так как все, что вы делаете, это:
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]
вы можете использовать ES6.
var array=['1','2','3','4','5','6']
var index = array.filter((value)=>value!='3');
выход :
["1", "2", "4", "5", "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 _.тяни!--3--> (мутировать массив), _.пуллат!--3--> (мутировать массив) или _.без (не мутирует массив),
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];
если вы повторно используете эту функцию, вы пишете многоразовую функцию, которая будет прикреплена к собственной функции массива, как показано ниже:
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 _.тянуть._ ,пуллат или _.без.
Я довольно новичок в JavaScript и нуждался в этой функциональности. Я просто написал следующее:--3-->
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");
вывод - как и ожидалось. ["элемент1", "элемент1"]
Вы можете иметь различные потребности, чем я, так что вы можете легко изменить его, чтобы удовлетворить их. Надеюсь, это кому-то поможет.
ES6 & без мутации: (октябрь 2016)
const removeByIndex = (list, index) =>
[
...list.slice(0, index),
...list.slice(index + 1)
];
затем :
removeByIndex([33,22,11,44],1) //=> [33,11,44]
обновление: этот метод рекомендуется, только если вы не можете использовать 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]
Если у вас есть сложные объекты в массив вы можете использовать фильтры? В ситуациях, когда $.inArray или массива.splice не так прост в использовании. Особенно, если объекты, возможно, неглубоки в массиве.
Е. Г. если у вас есть объект с полем ID, и вы хотите, чтобы объект удален из массива:
this.array = this.array.filter(function(element, i) {
return element.id !== idToRemove;
});
вы никогда не должны изменять свой массив массив. Поскольку это противоречит шаблону функционального программирования. Что вы можете сделать, это создать новый массив без ссылки на массив, который вы хотите изменить данные с помощью метода 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.фильтр https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
более современный, ECMAScript 2015 (ранее известный как гармония или ES 6) подход. Дано:
const items = [1, 2, 3, 4];
const index = 2;
затем:
items.filter((x, i) => i !== index);
урожайность:
[1, 2, 4]
можно использовать Бабель и обслуживание polyfill чтобы убедиться, что это хорошо поддерживается в браузерах.
вот несколько способов, чтобы удалить элемент из массива с помощью 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/)
Я знаю, что уже есть много ответов, но многие из них, похоже, усложняют проблему. Вот простой рекурсивный способ удаления всех экземпляров self - вызовов ключей, пока индекс не будет найден. Да, он работает только в браузерах с indexOf
, но это просто и может быть легко polyfilled.
автономная функция
function removeAll(array, key){
var index = array.indexOf(key);
if(index === -1) return;
array.splice(index, 1);
removeAll(array,key);
}
способ-прототип
Array.prototype.removeAll = function(key){
var index = this.indexOf(key);
if(index === -1) return;
this.splice(index, 1);
this.removeAll(key);
}
У меня есть еще одно хорошее решение для удаления из массива:
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
вы можете сделать обратный цикл, чтобы не испортить индексы, если есть несколько экземпляров элемента.
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
на основе всех ответов, которые были в основном правильными и с учетом наилучшей практики (особенно не используя массив.прототип напрямую), я придумал следующий код:
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;
}
рассматривая вышеуказанную функцию, несмотря на то, что она работает нормально, я понял, что может быть некоторое улучшение производительности. Также использование ES6 вместо ES5-гораздо лучший подход. С этой целью это улучшенный код:
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;
})();
как использовать:
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)
в настоящее время я пишу сообщение в блоге, в котором я без проблем сравнил несколько решений для Array и сравнил время, необходимое для запуска. Я обновлю этот ответ ссылкой, Как только закончу этот пост. Чтобы вы знали, я сравнил вышеизложенное с lodash без и в случае, если браузер поддерживает Map
, это бьет лодаш! Обратите внимание, что я не использую Array.prototype.indexOf
или Array.prototype.includes
как обертывание exlcudeValues в Map
или Object
делает запрос быстрее! (https://jsperf.com/array-without-benchmark-against-lodash)
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');
у вас есть массив от 1 до 9, и вы хотите удалить 5 ниже кода.
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);
Если вы хотите несколько значений 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);
Если вы хотите удалить значение массива в массиве ex : - [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);
включает в себя поддерживаемый браузер ссылке