Javascript - элементов - удалить определенный элемент массива js. JavaScript Удаление элементов из массива Js удаление элемента массива по индексу

У меня есть массив целых чисел, и я использую метод.push() для добавления к нему элементов.

Есть ли простой способ удалить определенный элемент из массива? Эквивалент чего-то типа array.remove(int); ,

Я должен использовать базовый JavaScript - никакие рамки не разрешены.

RemoveByIndex(,1) //=>

• Сделайте это простым, интуитивным и явным (https://en.wikipedia.org/wiki/Occam%27s_razor)
• Сделайте это неизменным (исходный массив останется без изменений)
• Сделайте это со стандартными функциями JS, если ваш браузер их не поддерживает - используйте polyfill

В этом примере кода я использую функцию array.filter (...) " для удаления ненужных элементов из массива, эта функция не меняет исходный массив и создает новый. Если ваш браузер не поддерживает эту функцию (например, IE до версии 9 или Firefox до версии 1.5), подумайте об использовании фильтра polyfill из Mozilla .

ВАЖНО ES2015 "() => {}" синтаксис функции стрелки не поддерживается в IE вообще, Chrome до версии 45, Firefox до версии 22, Safari до 10 версии. Чтобы использовать синтаксис ES2015 в старых браузерах, вы можете использовать BabelJS

Дополнительным преимуществом этого метода является то, что вы можете удалить несколько элементов

Let forDeletion = let arr = arr = arr.filter(item => !forDeletion.includes(item)) // !!! Read below about array.includes(...) support !!! console.log(arr) // [ 1, 4 ]

ВАЖНО "array.includes (...)" не поддерживается в IE вообще, Chrome до версии 47, Firefox до версии 43, Safari до версии 9 и Edge до 14 версии, так что

Вот несколько способов удалить элемент из массива с помощью 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()) мутирует исходный массив и его следует избегать.

Вы можете использовать ES6.

Var array=["1","2","3","4","5","6"] var index = array.filter((value)=>value!="3");

["1", "2", "4", "5", "6"]

Вы можете сделать это легко с помощью метода filter :

Function remove(arrOriginal, elementToRemove){ return arrOriginal.filter(function(el){return el !== elementToRemove}); } console.log(remove(, 1));

Это удаляет все элементы из массива, а также работает быстрее, чем комбинация среза и indexOf

Вы никогда не должны мутировать массив массива. Поскольку это противоречит функциональному шаблону программирования. Вы можете создать новый массив без ссылки на массив, который вы хотите изменить, используя фильтр метода es6;

Var myArray = ;

Предположим, вы хотите удалить 5 из массива, вы можете просто сделать это так.

MyArray = myArray.filter(value => value !== 5);

Это даст вам новый массив без значения, которое вы хотите удалить. Таким образом, результат будет

; // 5 has been removed from this array

Для дальнейшего понимания вы можете прочитать документацию MDN на Array.filter filter

Если вы хотите, чтобы новый массив с удаленными позициями удален, вы всегда можете удалить определенный элемент и отфильтровать массив. Возможно, потребуется расширение объекта массива для браузеров, которые не реализуют метод фильтрации, но в долгосрочной перспективе это проще, поскольку все, что вы делаете, это следующее:

Var my_array = ; delete my_array; console.log(my_array.filter(function(a){return typeof a !== "undefined";}));

Должны отображаться

Если у вас есть сложные объекты в массиве, вы можете использовать фильтры? В ситуациях, когда $ .inArray или array.splice не так просты в использовании. Особенно, если объекты, возможно, мелкие в массиве.

Например, если у вас есть объект с полем Id и вы хотите, чтобы объект был удален из массива:

This.array = this.array.filter(function(element, i) { return element.id !== idToRemove; });

Найдите index элемента массива, который вы хотите удалить, затем удалите этот индекс с помощью splice .

Метод splice () изменяет содержимое массива путем удаления существующих элементов и / или добавления новых элементов.

var array = ; console.log(array) var index = array.indexOf(5); if (index > -1) { array.splice(index, 1); } // array = console.log(array);

Второй параметр splice - это количество элементов для удаления. Обратите внимание, что splice изменяет массив на месте и возвращает новый массив, содержащий удаленные элементы.

У вас есть от 1 до 9 массивов, и вы хотите удалить 5, используя код ниже.

var numberArray = ; var newNumberArray = numberArray.filter(m => { return m !== 5; }); console.log("new Array, 5 removed", newNumberArray);

Если вы хотите использовать несколько значений ex: - 1,7,8

var numberArray = ; var newNumberArray = numberArray.filter(m => { return (m !== 1) && (m !== 7) && (m !== 8); }); console.log("new Array, 5 removed", newNumberArray);

Если вы хотите удалить значение массива в массиве ex: -

var numberArray = ; var removebleArray = ; var newNumberArray = numberArray.filter(m => { return !removebleArray.includes(m); }); console.log("new Array, removed", newNumberArray);

включает поддерживаемый браузер - link

Я знаю, что уже есть много ответов, но многие из них, похоже, усложняют проблему. Вот простой, рекурсивный способ удаления всех экземпляров ключа - вызывает self, пока индекс не будет найден. Да, он работает только в браузерах indexOf , но он прост и может быть легко заполнен.

Автономная функция

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); }

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 = this; } this.length = this.length - 1 return; } } } var recentMovies = ["Iron Man", "Batman", "Superman", "Spiderman"]; recentMovies.removeItem("Superman");

Используйте.shift для удаления первого элемента массива.

Например:

Var array = ; array.shift();

массив приводит к:

Например:

Var array = ; array.pop();

массив приводит к:

Оба метода возвращают удаленный элемент;

Используйте.splice() чтобы удалить ряд элементов из массива. .splice() принимает два параметра, начальный индекс и необязательное количество элементов для удаления. Если второй параметр не.splice() удалит все элементы из начального индекса через конец массива.

Например:

Var array = ; array.splice(1, 2);

оставляет array , содержащий:

Возврат array.splice() - это новый массив, содержащий удаленные элементы. В приведенном выше примере возврат будет следующим:

Таким образом, опускание второго параметра эффективно разбивает массив на два массива с исходным окончанием до указанного индекса:

Var array = ; array.splice(2);

Оставляет array содержащий и возвращает .

Используйте delete для удаления элемента из массива без изменения длины массива:

Var array = ; console.log(array.length); // 5 delete array; console.log(array); // console.log(array.length); // 5

Присвоение значения length массива изменяет длину на заданное значение. Если новое значение меньше длины массива, элементы будут удалены с конца значения.

Array = ; array.length = 2; console.log(array); //

// отредактировал спасибо MarcoCI за советы

попробуй это:

Function wantDelete(item, arr){ for (var i=0;i !(comment.Id === commentId));

Вот версия, в которой используется функция inArray jQuery:

Var index = $.inArray(item, array); if (index != -1) { array.splice(index, 1); }

Вы можете добиться этого, используя функцию Lodash _.remove .

var array = ["three", "seven", "eleven"]; var evens = _.remove(array, function(e) { return e !== "seven"; }); console.log(evens);

Const _ = require("lodash"); _.without(, 2); // ->

Действительно, я не понимаю, почему это невозможно решить с помощью

Arr = arr.filter(value => value !== "seven");

Или, может быть, вы хотите использовать vanilla JS

Arr = arr.filter(function(value) { return value !== "seven" });

Другой вариант:

If (!Array.prototype.removeArr) { Array.prototype.removeArr = function(arr) { if(!Array.isArray(arr)) arr=;//let"s be nice to people who put a non-array value here.. that could be me! var that = this; if(arr.length){ var i=0; while(i-1){ that.splice(i,1); }else i++; } } return that; } }

Это indexOf () внутри цикла снова, но в предположении, что массив для удаления является малым относительно массива, который нужно очистить; каждое удаление сокращает цикл while.

Это позволит вам сделать следующее:

Var ary = ["three", "seven", "eleven"]; var aryWithoutSeven = ary.filter(function(value) { return value != "seven" }); console.log(aryWithoutSeven); // returns ["three", "eleven"]

Это также было отмечено в этой теме где-то еще: https://.com/a/20827100/293492

Не используйте вариант с delete - он делает отверстие в массиве, так как он не переиндексирует элементы после удаленного элемента.

> Array.prototype.remove=function(v){ ... delete this ... }; > var myarray=["3","24","55","2"]; undefined > myarray.remove("55"); undefined > myarray [ "3", "24", "2" ]

Один лайнер сделает это,

Var ary = ["three", "seven", "eleven"]; // Remove item "seven" from array var filteredAry = ary.filter(function(e) { return e !== "seven" }) //=> ["three", "eleven"] // In ECMA6 (arrow function syntax): var filteredAry = ary.filter(e => e !== "seven")

Это использует функцию filter в JS. Он поддерживается в IE9 и выше.

filter () вызывает предоставленную функцию обратного вызова один раз для каждого элемента в массиве и создает новый массив из всех значений, для которых обратный вызов возвращает значение, которое приводит к истинному. callback вызывается только для индексов массива, которым присвоены значения; он не вызывается для индексов, которые были удалены или которые никогда не были присвоены значениям. Элементы массива, которые не проходят тест обратного вызова, просто пропускаются и не включаются в новый массив.

Таким образом, в основном, это то же самое, что и все остальные for (var key in ary) { ... } решений, за исключением того, что for in поддерживается как IE6.

В принципе, фильтр - это метод удобства, который выглядит намного лучше (и является цепным), в отличие от конструктора for in (AFAIK).

Проверьте это:

For(var i in array){ if(array[i]=="seven"){ array.splice(i,1); break; } }

и в функции:

Function removeItem(array, item){ for(var i in array){ if(array[i]==item){ array.splice(i,1); break; } } } removeItem(array, "seven");

Удаление всех совпадающих элементов из массива (а не только первый, как кажется, самый общий ответ здесь):

While ($.inArray(item, array) > -1) { array.splice($.inArray(item, array), 1); }

Я использовал jQuery для тяжелой работы, но вы поняли, хотите ли вы поехать на родной язык.

Хитрость заключается в том, чтобы пройти через массив от начала до начала, поэтому вы не испортите индексы при удалении элементов.

Var deleteMe = function(arr, me){ var i = arr.length; while(i--) if(arr[i] === me) arr.splice(i,1); } var arr = ["orange","red","black", "orange", "white" , "orange" ]; deleteMe(arr , "orange");

arr теперь ["красный", "черный", "белый"]

Function cleanArrayOfSpecificTerms(array,unwantedTermsArray) { $.each(unwantedTermsArray, function(index, value) { var index = array.indexOf(value); if (index > -1) { array.splice(index, 1); } }); return array; }

Чтобы использовать, выполните следующие действия:

Var notInclude = ["Not","No","First","Last","Prior","Next", "dogs","cats"]; var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"]; cleanArrayOfSpecificTerms(splitTerms,notInclude)

Я попытался использовать метод функции из jbaron выше, но обнаружил, что мне нужно сохранить исходный массив без изменений для использования позже и создать новый массив следующим образом:

Var newArray = referenceArray;

Function newArrRemoveItem(array, item, newArray){ for(var i = 0; i < array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Затем я использую его так:

Var vesselID = record.get("VesselID"); var otherVessels = new Array(); newArrRemoveItem(vesselArr,vesselID,otherVessels);

Теперь судноArr остается неповрежденным, и каждый раз, когда я выполняю приведенный выше код, массив otherVessels включает в себя все, кроме последнего элемента CAID.

indexOf - это вариант, но его реализация в основном ищет весь массив для значения, поэтому время выполнения растет с размером массива. (так что это в каждом браузере, я думаю, я только проверял Firefox).

У меня нет IE6 для проверки, но я бы назвал это безопасной ставкой, что вы можете проверить по крайней мере миллион элементов массива в секунду таким образом практически на любой клиентской машине. Если [размер массива] * [поисковые запросы в секунду] может вырасти больше миллиона, вы должны рассмотреть другую реализацию.

В основном вы можете использовать объект для создания индекса для вашего массива, например:

Var index={"three":0, "seven":1, "eleven":2};

Любая нормальная среда JavaScript создаст индекс поиска для таких объектов, чтобы вы могли быстро перевести ключ в значение, независимо от того, сколько свойств имеет объект.

Это всего лишь базовый метод, в зависимости от ваших потребностей вы можете объединить несколько объектов и / или массивов, чтобы сделать те же данные быстро доступными для поиска для разных свойств. Если вы укажете свои конкретные потребности, я могу предложить более конкретную структуру данных.

//This function allows remove even array from array var removeFromArr = function(arr, elem) { var i, len = arr.length, new_arr = , sort_fn = function (a, b) { return a - b; }; for (i = 0; i < len; i += 1) { if (typeof elem === "object" && typeof arr[i] === "object") { if (arr[i].toString() === elem.toString()) { continue; } else { if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) { continue; } } } if (arr[i] !== elem) { new_arr.push(arr[i]); } } return new_arr; }

Пример использования

Var arr = , "abc", 1, "1", 1]; removeFromArr(arr, 1); //["2", , "abc", "1"] var arr = [ , 2, "a", , ]; removeFromArr(arr, ); //]

Let arr = ; console.log(arr); //result let index = arr.indexOf(30); if (index > -1) { arr.splice(index, 1); } console.log(arr); //result

Var index = array.indexOf("item"); if(index!=-1){ array.splice(index, 1); }

Есть ли способ удалить элемент из массива JavaScript?

Учитывая массив:

Var ary = ["three", "seven", "eleven"];

Я хотел бы сделать что-то вроде:

RemoveItem("seven", ary);

Я просмотрел splice() но это только удаляет номер позиции, тогда как мне нужно что-то, чтобы удалить элемент по его значению.

// отредактировал спасибо MarcoCI за советы

попробуй это:

Function wantDelete(item, arr){ for (var i=0;i !(comment.Id === commentId));

Вот версия, в которой используется функция inArray jQuery:

Var index = $.inArray(item, array); if (index != -1) { array.splice(index, 1); }

Вы можете добиться этого, используя функцию Lodash _.remove .

var array = ["three", "seven", "eleven"]; var evens = _.remove(array, function(e) { return e !== "seven"; }); console.log(evens);

Const _ = require("lodash"); _.without(, 2); // ->

Действительно, я не понимаю, почему это невозможно решить с помощью

Arr = arr.filter(value => value !== "seven");

Или, может быть, вы хотите использовать vanilla JS

Arr = arr.filter(function(value) { return value !== "seven" });

Другой вариант:

If (!Array.prototype.removeArr) { Array.prototype.removeArr = function(arr) { if(!Array.isArray(arr)) arr=;//let"s be nice to people who put a non-array value here.. that could be me! var that = this; if(arr.length){ var i=0; while(i-1){ that.splice(i,1); }else i++; } } return that; } }

Это indexOf () внутри цикла снова, но в предположении, что массив для удаления является малым относительно массива, который нужно очистить; каждое удаление сокращает цикл while.

Это позволит вам сделать следующее:

Var ary = ["three", "seven", "eleven"]; var aryWithoutSeven = ary.filter(function(value) { return value != "seven" }); console.log(aryWithoutSeven); // returns ["three", "eleven"]

Это также было отмечено в этой теме где-то еще: https://.com/a/20827100/293492

Не используйте вариант с delete - он делает отверстие в массиве, так как он не переиндексирует элементы после удаленного элемента.

> Array.prototype.remove=function(v){ ... delete this ... }; > var myarray=["3","24","55","2"]; undefined > myarray.remove("55"); undefined > myarray [ "3", "24", "2" ]

Один лайнер сделает это,

Var ary = ["three", "seven", "eleven"]; // Remove item "seven" from array var filteredAry = ary.filter(function(e) { return e !== "seven" }) //=> ["three", "eleven"] // In ECMA6 (arrow function syntax): var filteredAry = ary.filter(e => e !== "seven")

Это использует функцию filter в JS. Он поддерживается в IE9 и выше.

filter () вызывает предоставленную функцию обратного вызова один раз для каждого элемента в массиве и создает новый массив из всех значений, для которых обратный вызов возвращает значение, которое приводит к истинному. callback вызывается только для индексов массива, которым присвоены значения; он не вызывается для индексов, которые были удалены или которые никогда не были присвоены значениям. Элементы массива, которые не проходят тест обратного вызова, просто пропускаются и не включаются в новый массив.

Таким образом, в основном, это то же самое, что и все остальные for (var key in ary) { ... } решений, за исключением того, что for in поддерживается как IE6.

В принципе, фильтр - это метод удобства, который выглядит намного лучше (и является цепным), в отличие от конструктора for in (AFAIK).

Проверьте это:

For(var i in array){ if(array[i]=="seven"){ array.splice(i,1); break; } }

и в функции:

Function removeItem(array, item){ for(var i in array){ if(array[i]==item){ array.splice(i,1); break; } } } removeItem(array, "seven");

Удаление всех совпадающих элементов из массива (а не только первый, как кажется, самый общий ответ здесь):

While ($.inArray(item, array) > -1) { array.splice($.inArray(item, array), 1); }

Я использовал jQuery для тяжелой работы, но вы поняли, хотите ли вы поехать на родной язык.

Хитрость заключается в том, чтобы пройти через массив от начала до начала, поэтому вы не испортите индексы при удалении элементов.

Var deleteMe = function(arr, me){ var i = arr.length; while(i--) if(arr[i] === me) arr.splice(i,1); } var arr = ["orange","red","black", "orange", "white" , "orange" ]; deleteMe(arr , "orange");

arr теперь ["красный", "черный", "белый"]

Function cleanArrayOfSpecificTerms(array,unwantedTermsArray) { $.each(unwantedTermsArray, function(index, value) { var index = array.indexOf(value); if (index > -1) { array.splice(index, 1); } }); return array; }

Чтобы использовать, выполните следующие действия:

Var notInclude = ["Not","No","First","Last","Prior","Next", "dogs","cats"]; var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"]; cleanArrayOfSpecificTerms(splitTerms,notInclude)

Я попытался использовать метод функции из jbaron выше, но обнаружил, что мне нужно сохранить исходный массив без изменений для использования позже и создать новый массив следующим образом:

Var newArray = referenceArray;

Function newArrRemoveItem(array, item, newArray){ for(var i = 0; i < array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

Затем я использую его так:

Var vesselID = record.get("VesselID"); var otherVessels = new Array(); newArrRemoveItem(vesselArr,vesselID,otherVessels);

Теперь судноArr остается неповрежденным, и каждый раз, когда я выполняю приведенный выше код, массив otherVessels включает в себя все, кроме последнего элемента CAID.

indexOf - это вариант, но его реализация в основном ищет весь массив для значения, поэтому время выполнения растет с размером массива. (так что это в каждом браузере, я думаю, я только проверял Firefox).

У меня нет IE6 для проверки, но я бы назвал это безопасной ставкой, что вы можете проверить по крайней мере миллион элементов массива в секунду таким образом практически на любой клиентской машине. Если [размер массива] * [поисковые запросы в секунду] может вырасти больше миллиона, вы должны рассмотреть другую реализацию.

В основном вы можете использовать объект для создания индекса для вашего массива, например:

Var index={"three":0, "seven":1, "eleven":2};

Любая нормальная среда JavaScript создаст индекс поиска для таких объектов, чтобы вы могли быстро перевести ключ в значение, независимо от того, сколько свойств имеет объект.

Это всего лишь базовый метод, в зависимости от ваших потребностей вы можете объединить несколько объектов и / или массивов, чтобы сделать те же данные быстро доступными для поиска для разных свойств. Если вы укажете свои конкретные потребности, я могу предложить более конкретную структуру данных.

//This function allows remove even array from array var removeFromArr = function(arr, elem) { var i, len = arr.length, new_arr = , sort_fn = function (a, b) { return a - b; }; for (i = 0; i < len; i += 1) { if (typeof elem === "object" && typeof arr[i] === "object") { if (arr[i].toString() === elem.toString()) { continue; } else { if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) { continue; } } } if (arr[i] !== elem) { new_arr.push(arr[i]); } } return new_arr; }

Пример использования

Var arr = , "abc", 1, "1", 1]; removeFromArr(arr, 1); //["2", , "abc", "1"] var arr = [ , 2, "a", , ]; removeFromArr(arr, ); //]

Let arr = ; console.log(arr); //result let index = arr.indexOf(30); if (index > -1) { arr.splice(index, 1); } console.log(arr); //result

Var index = array.indexOf("item"); if(index!=-1){ array.splice(index, 1); }