Как удалить элемент из массива по значению?

Ответ 1

Это может быть глобальная функция или метод настраиваемого объекта, если вам не разрешено добавлять в собственные прототипы. Он удаляет все элементы из массива, которые соответствуют любому из аргументов.

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

Ответ 2

Вы можете использовать метод 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)

Ответ 3

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

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).

Ответ 4

Вы можете использовать underscore.js. Это действительно упрощает процесс.

Например, при этом:

var result = _.without(['three','seven','eleven'], 'seven');

И result будет ['three','eleven'].

В вашем случае код, который вам нужно написать:

ary = _.without(ary, 'seven')

Он уменьшает код, который вы пишете.

Ответ 5

Проверьте этот способ:

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

Ответ 6

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

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

Ответ 7

Вы можете сделать это двумя способами:

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')

Ответ 8

var index = array.indexOf('item');

if(index!=-1){

   array.splice(index, 1);
}

Ответ 9

Что вам нужно, так это фильтр

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/...

Ответ 10

Просто

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

Ответ 11

Самое простое решение:

массив - массив для удаления некоторого элемента 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)
}

Ответ 12

Видя, что там не очень красиво, вот простая и многоразовая функция ES6.

const removeArrayItem = (arr, itemToRemove) => {
  return arr.filter(item => item !== itemToRemove)
}

Использование:

const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange']
removeArrayItem(items, 'orange')

Ответ 13

ES6 путь.

const commentsWithoutDeletedArray = commentsArray.filter(comment => comment.Id !== commentId);

Ответ 14

На самом деле, я не понимаю, почему это не может быть решено с помощью

arr = arr.filter(value => value !== 'seven');

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

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

Ответ 15

Если у вас есть уникальные значения в вашем массиве и порядок не имеет значения, вы можете использовать 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.

Ответ 16

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

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

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

Ответ 17

Когда вам нужно удалить значение, присутствующее несколько раз в массиве (например, [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]

Ответ 18

очень чистое решение, работающее во всех браузерах и без каких-либо фреймворков, - это присвоить новый массив и просто вернуть его без элемента, который вы хотите удалить:

/**
 * @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;
}

Ответ 19

Во всех уникальных значениях вы можете:

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]

Ответ 20

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

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

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

var index={'three':0, 'seven':1, 'eleven':2};

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

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

Ответ 21

Вы можете добиться этого, используя функцию 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>

Ответ 22

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

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 теперь [ "красный", "черный", "белый" ]

Ответ 23

Вы можете использовать without или pull из Lodash:

const _ = require('lodash');
_.without([1, 2, 3, 2], 2); // -> [1, 3]

Ответ 24

Неразрушающее удаление:

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

Ответ 25

Пожалуйста, не используйте вариант с 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' ]

Ответ 26

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

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)

Ответ 27

Вы можете решить эту проблему с помощью метода 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. Пожалуйста, проверьте здесь

Ответ 28

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]

Ответ 29

В глобальной функции мы не можем передать пользовательское значение напрямую, но есть много способов, как показано ниже

 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

Ответ 30

var remove = function(array, value) {
    var index = null;

    while ((index = array.indexOf(value)) !== -1)
        array.splice(index, 1);

    return array;
};