Есть ли способ удалить элемент из массива JavaScript?
Учитывая массив:
var ary = ['three', 'seven', 'eleven'];
Я хотел бы сделать что-то вроде:
removeItem('seven', ary);
Я просмотрел splice(), но это только удаляет номер позиции, тогда как мне нужно что-то, чтобы удалить элемент по его значению.
Это может быть глобальная функция или метод настраиваемого объекта, если вам не разрешено добавлять в собственные прототипы. Он удаляет все элементы из массива, которые соответствуют любому из аргументов.
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');
/* returned value: (Array)
three,eleven
*/
Чтобы сделать его глобальным -
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');
/* returned value: (Array)
three,eleven
*/
И позаботиться о 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;
};
}
Вы можете использовать метод indexOf следующим образом:
var index = array.indexOf(item);
if (index !== -1) array.splice(index, 1);
Примечание: Вам нужно закрепить его для IE8 и ниже
var array = [1,2,3,4]
var item = 3
var index = array.indexOf(item);
if (index !== -1) array.splice(index, 1);
console.log(array)Один лайнер сделает это,
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 и выше.
Что он делает (из ссылки doc)
filter() вызывает предоставленную функцию обратного вызова один раз для каждого элемента в массиве и создает новый массив из всех значений, для которых обратный вызов возвращает значение, которое приводит к истинному. callback вызывается только для индексов массива, которым присвоены значения; он не вызывается для индексов, которые были удалены или которые никогда не были присвоены значениям. Элементы массива, которые не проходят тест обратного вызова, просто пропускаются и не включаются в новый массив.
В принципе, это то же самое, что и все другие решения for (var key in ary) { ... }, за исключением того, что конструкция for in поддерживается как IE6.
В принципе, фильтр - это метод удобства, который выглядит намного приятнее (и является цепным), в отличие от конструкции for in (AFAIK).
Вы можете использовать underscore.js. Это действительно упрощает процесс.
Например, при этом:
var result = _.without(['three','seven','eleven'], 'seven');
И result будет ['three','eleven'].
В вашем случае код, который вам нужно написать:
ary = _.without(ary, 'seven')
Он уменьшает код, который вы пишете.
Проверьте этот способ:
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');
Здесь версия, в которой используется функция jQuery inArray:
var index = $.inArray(item, array);
if (index != -1) {
array.splice(index, 1);
}
Вы можете сделать это двумя способами:
var arr = ["1","2","3","4"] // we wanna delete number "3"
первый:
arr.indexOf('3') !== -1 && arr.splice(arr.indexOf('3'), 1)
секунда (ES6):
arr = arr.filter(e => e !== '3')
var index = array.indexOf('item');
if(index!=-1){
array.splice(index, 1);
}
Что вам нужно, так это фильтр
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
Это позволит вам сделать следующее:
var ary = ['three', 'seven', 'eleven'];
var aryWithoutSeven = ary.filter(function(value) { return value != 'seven' });
console.log(aryWithoutSeven); // returns ['three', 'eleven']
Это также было отмечено в этой теме где-то еще: fooobar.com/questions/14237/...
Просто
var ary = ['three', 'seven', 'eleven'];
var index = ary.indexOf('seven'); // get index if value found otherwise -1
if (index > -1) { //if found
ary.splice(index, 1);
}
Самое простое решение:
массив - массив для удаления некоторого элемента valueForRemove; valueForRemove - элемент для удаления;
array.filter(arrayItem => !array.includes(valueForRemove));
Более просто:
array.filter(arrayItem => arrayItem !== valueForRemove);
Не красиво, но работает:
array.filter(arrayItem => array.indexOf(arrayItem) != array.indexOf(valueForRemove))
Не красиво, но работает:
while(array.indexOf(valueForRemove) !== -1) {
array.splice(array.indexOf(valueForRemove), 1)
}
Видя, что там не очень красиво, вот простая и многоразовая функция ES6.
const removeArrayItem = (arr, itemToRemove) => {
return arr.filter(item => item !== itemToRemove)
}
Использование:
const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange']
removeArrayItem(items, 'orange')
ES6 путь.
const commentsWithoutDeletedArray = commentsArray.filter(comment => comment.Id !== commentId);
На самом деле, я не понимаю, почему это не может быть решено с помощью
arr = arr.filter(value => value !== 'seven');
Или, может быть, вы хотите использовать ванильный JS
arr = arr.filter(function(value) { return value !== 'seven' });
Если у вас есть уникальные значения в вашем массиве и порядок не имеет значения, вы можете использовать Set, и он имеет delete:
var mySet = new Set(['foo']);
mySet.delete('foo'); // Returns true. Successfully removed.
mySet.has('foo'); // Returns false. The "foo" element is no longer present.
Удаление всех совпадающих элементов из массива (а не только первый, как представляется, наиболее общий ответ здесь):
while ($.inArray(item, array) > -1) {
array.splice( $.inArray(item, array), 1 );
}
Я использовал jQuery для тяжелой работы, но вы поняли, хотите ли вы пойти на родной язык.
Когда вам нужно удалить значение, присутствующее несколько раз в массиве (например, [1,2,2,2, 4, 5,6]).
function removeFrmArr(array, element) {
return array.filter(e => e !== element);
};
var exampleArray = [1,2,3,4,5];
removeFrmArr(exampleArray, 3);
// return value like this
//[1, 2, 4, 5]
Вы можете использовать splice для удаления одного элемента из массива, но splice не может удалить несколько похожих элементов из массива.
function singleArrayRemove(array, value){
var index = array.indexOf(value);
if (index > -1) array.splice(index, 1);
return array;
}
var exampleArray = [1,2,3,4,5,5];
singleArrayRemove(exampleArray, 5);
// return value like this
//[1, 2, 3, 4, 5]
очень чистое решение, работающее во всех браузерах и без каких-либо фреймворков, - это присвоить новый массив и просто вернуть его без элемента, который вы хотите удалить:
/**
* @param {Array} array the original array with all items
* @param {any} item the time you want to remove
* @returns {Array} a new Array without the item
*/
var removeItemFromArray = function(array, item){
/* assign a empty array */
var tmp = [];
/* loop over all array items */
for(var index in array){
if(array[index] !== item){
/* push to temporary array if not like item */
tmp.push(array[index]);
}
}
/* return the temporary array */
return tmp;
}
Во всех уникальных значениях вы можете:
a = new Set([1,2,3,4,5]) // a = Set(5) {1, 2, 3, 4, 5}
a.delete(3) // a = Set(5) {1, 2, 4, 5}
[...a] // [1, 2, 4, 5]
indexOf - вариант, но реализация в основном ищет весь массив для значения, поэтому время выполнения растет с размером массива. (так что это в каждом браузере, я думаю, я только проверял Firefox).
У меня нет IE6 для проверки, но я бы назвал его безопасной ставкой, чтобы вы могли проверять хотя бы миллион элементов массива в секунду таким образом практически на любой клиентской машине. Если [размер массива] * [поисковые запросы в секунду] может вырасти больше миллиона, вы должны рассмотреть другую реализацию.
В принципе вы можете использовать объект для создания индекса для своего массива, например:
var index={'three':0, 'seven':1, 'eleven':2};
Любая нормальная среда JavaScript создаст индекс поиска для таких объектов, чтобы вы могли быстро перевести ключ в значение, независимо от того, сколько свойств имеет объект.
Это всего лишь базовый метод, в зависимости от вашей потребности вы можете объединить несколько объектов и/или массивов, чтобы сделать те же данные быстро доступными для поиска для разных свойств. Если вы укажете свои конкретные потребности, я могу предложить более конкретную структуру данных.
Вы можете добиться этого, используя функцию Lodash _.remove.
var array = ['three', 'seven', 'eleven'];
var evens = _.remove(array, function(e) {
return e !== 'seven';
});
console.log(evens);<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js"></script>Трюк состоит в том, чтобы пройти через массив от начала до начала, поэтому вы не испортите индексы при удалении элементов.
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 теперь [ "красный", "черный", "белый" ]
Вы можете использовать without или pull из Lodash:
const _ = require('lodash');
_.without([1, 2, 3, 2], 2); // -> [1, 3]
Неразрушающее удаление:
function removeArrayValue(array, value)
{
var thisArray = array.slice(0); // copy the array so method is non-destructive
var idx = thisArray.indexOf(value); // initialise idx
while(idx != -1)
{
thisArray.splice(idx, 1); // chop out element at idx
idx = thisArray.indexOf(value); // look for next ocurrence of 'value'
}
return thisArray;
}
Пожалуйста, не используйте вариант с delete - он делает отверстие в массиве, так как он не переиндексирует элементы после удаляемого элемента.
> Array.prototype.remove=function(v){
... delete this[this.indexOf(v)]
... };
[Function]
> var myarray=["3","24","55","2"];
undefined
> myarray.remove("55");
undefined
> myarray
[ '3', '24', , '2' ]
Я использовал самый проголосовавший вариант и создал функцию, которая очистила бы один массив слов, используя другой массив нежелательных слов:
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)
Вы можете решить эту проблему с помощью метода indexOf.
Сначала найдите индекс элемента, который вы хотите удалить:
var ary = ['three', 'seven', 'eleven'];
var index = ary.indexOf('seven');
Затем удалите его с помощью метода splice:
if (index > -1) {
ary.splice(index, 1);
}
N.B: поддержка браузера для indexOf ограничена; он не поддерживается в Internet Explorer 7 и 8. Пожалуйста, проверьте здесь
let arr = [5, 15, 25, 30, 35];
console.log(arr); //result [5, 15, 25, 30, 35]
let index = arr.indexOf(30);
if (index > -1) {
arr.splice(index, 1);
}
console.log(arr); //result [5, 15, 25, 35]
В глобальной функции мы не можем передать пользовательское значение напрямую, но есть много способов, как показано ниже
var ary = ['three', 'seven', 'eleven'];
var index = ary.indexOf(item);//item: the value which you want to remove
//Method 1
ary.splice(index,1);
//Method 2
delete ary[index]; //in this method the deleted element will be undefined
var remove = function(array, value) {
var index = null;
while ((index = array.indexOf(value)) !== -1)
array.splice(index, 1);
return array;
};