Как удалить определенный элемент из массива в JavaScript?


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

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

Мне нужно использовать базовый JavaScript - никаких фреймворков не разрешено.

6633
javascriptarrays
опубликован 24 апр. '11 в 1:17 2011-04-24 01:17
источник
72 ответов

Найдите 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. Найти более подробную информацию об этом 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
});
9577
ответ дан 24 апр. '11 в 1:23
источник

Я не знаю, как вы ожидаете, что 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);
    }
}

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

delete array[i];
973
ответ дан 24 апр. '11 в 1:20
источник

Отредактировано 2016 октября

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

В этом примере кода я использую функцию array.filter(...) " для удаления ненужных элементов из массива, эта функция не меняет исходный массив и создает новый. Если ваш браузер не поддерживает эту функцию (например, 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 вообще, 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 ]

ВАЖНО "array.includes(...)" не поддерживается в IE вообще, Chrome до версии 47, Firefox до версии 43, Safari до версии 9 и Edge до 14 версии, так что вот полипол от 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 ]

50&builtIns=false&code= function remove(...forDeletion) { return this.filter(item => !forDeletion.includes(item)) } let arr = [1, 2, 3, 4, 5, 3] //:: This-Binding Syntax Proposal //using remove function as "virtual method" arr = arr::remove(2, 3, 5) console.log(arr) //[ 1, 4 ] rel=noreferrer> Попробуйте сами в BabelJS :)

Справка

788
ответ дан 19 дек. '13 в 22:54
источник

В зависимости от того, хотите ли вы сохранить пустое место или нет.

Если вам нужен пустой слот, удаление будет прекрасным:

delete array[ index ];

Если вы этого не сделаете, вы должны использовать метод splice:

array.splice( index, 1 );

И если вам нужно значение этого элемента, вы можете просто сохранить возвращаемый элемент массива:

var value = array.splice( index, 1 )[0];

Если вы хотите сделать это в определенном порядке, вы можете использовать array.pop() для последнего или array.shift() для первого (и оба возвращают значение элемента тоже).

И если вы не знаете индекс элемента, вы можете использовать array.indexOf( item ), чтобы получить его (в if(), чтобы получить один элемент или в while(), чтобы получить все из них). array.indexOf( item ) возвращает либо индекс, либо -1, если не найден.  

378
ответ дан 24 апр. '11 в 1:32
источник

У друга возникли проблемы в Internet Explorer 8, и он показал мне, что он сделал. Я сказал ему, что это неправильно, и он сказал мне, что получил ответ здесь. Текущий верхний ответ не будет работать во всех браузерах (например, Internet Explorer 8), и он удалит только первое вхождение элемента.

Удалить ВСЕ экземпляры из массива

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

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

247
ответ дан 10 авг. '13 в 22:21
источник

Существует два основных подхода:

  • splice(): anArray.splice(index, 1);

  • удалить: delete anArray[index];

Будьте осторожны, когда вы используете delete для массива. Он хорош для удаления атрибутов объектов, но не так хорош для массивов. Лучше использовать splice для массивов.

Имейте в виду, что когда вы используете delete для массива, вы можете получить неправильные результаты для anArray.length. Другими словами, delete удалит элемент, но не обновит значение свойства length.

Вы также можете ожидать наличия отверстий в индексных номерах после использования удаления, например. вы могли бы получить индексы 1,3,4,8,9,11 и длину, как это было до использования удаления. В этом случае все индексированные циклы for будут разбиваться, поскольку индексы больше не являются последовательными.

Если вы по какой-то причине вынуждены использовать delete, тогда вам нужно использовать петли for each, когда вам нужно перебирать массивы. По сути дела, всегда избегайте использования индексированных для петель, если это возможно. Таким образом, код будет более надежным и менее подверженным проблемам с индексами.

140
ответ дан 21 дек. '12 в 14:32
источник
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)
114
ответ дан 24 апр. '11 в 1:20
источник

Нет необходимости использовать 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 прогонов):

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
86
ответ дан 19 сент. '13 в 4:53
источник

Самый простой способ:

var index = array.indexOf(item);
if(index != -1)
    array.splice( index, 1 );
81
ответ дан 02 дек. '17 в 20:42

Слишком старый, чтобы ответить, но может ли он помочь кому-то, предоставив предикат вместо значения.

ПРИМЕЧАНИЕ: он обновит данный массив и вернет затронутые строки

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

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;
    }
};
58
ответ дан 02 мая '14 в 15:00
источник

John Resig опубликовал хорошую реализацию:

// 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-элементный массив. Не знаю, почему, но я подтвердил, что первоначальная реализация John не имеет этой проблемы.

55
ответ дан 30 авг. '13 в 22:07
источник

Underscore.js можно использовать для решения проблем с несколькими браузерами. Он использует встроенные методы браузера, если они есть. Если они отсутствуют, как в случае с более старыми версиями Internet Explorer, он использует свои собственные методы.

Простой пример для удаления элементов из массива (с веб-сайта):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
53
ответ дан 30 мая '14 в 12:57
источник

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

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) );

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

52
ответ дан 11 февр. '14 в 1:06
источник

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

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]

40
ответ дан 18 окт. '12 в 13:13
источник

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

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

Выход:

["1", "2", "4", "5", "6"]
37
ответ дан 04 окт. '16 в 11:07
источник

Проверьте этот код. Он работает в каждом главном браузере .

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);
34
ответ дан 02 апр. '13 в 13:56
источник

Вы можете использовать lodash _. pull (mutate array), _.pullAt (мутировать массив) или _. без (не мутирует массив),

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']
32
ответ дан 25 авг. '15 в 22:34
источник

ОК, например, у вас есть массив ниже:

var num = [1, 2, 3, 4, 5];

И мы хотим удалить номер 4, вы можете просто сделать следующий код:

num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5];

Если вы повторно используете эту функцию, вы пишете функцию повторного использования, которая будет привязана к функции Native array, как показано ниже:

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 _.pull, _.pullAt или _.without.

31
ответ дан 10 мая '17 в 12:39
источник

Я новичок в JavaScript и нуждаюсь в этой функции. Я просто написал это:

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

Выход - как и ожидалось. [ "item1", "item1" ]

У вас могут быть разные потребности, чем у меня, поэтому вы можете легко изменить их в соответствии с ними. Надеюсь, это поможет кому-то.

27
ответ дан 16 янв. '14 в 14:27
источник

ES6 и без мутации: (октябрь 2016 г.)

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

Тогда:

removeByIndex([33,22,11,44],1) //=> [33,11,44]
24
ответ дан 07 окт. '16 в 22:42
источник

Обновление: этот метод рекомендуется использовать, только если вы не можете использовать 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]
21
ответ дан 13 марта '13 в 12:28
источник

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

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

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
20
ответ дан 09 апр. '15 в 13:00
источник

Вот несколько способов удалить элемент из массива с помощью 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/)

20
ответ дан 04 мая '18 в 8:17
источник

Вы никогда не должны мутировать массив массива. Поскольку это противоречит функциональному шаблону программирования. Что вы можете сделать, это создать новый массив без ссылки на массив, который вы хотите изменить данные с помощью метода 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.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

19
ответ дан 26 дек. '17 в 22:32
источник

Более современный, ECMAScript 2015 (ранее известный как Harmony или ES 6). Дано:

const items = [1, 2, 3, 4];
const index = 2;

Тогда:

items.filter((x, i) => i !== index);

Уступка:

[1, 2, 4]

Вы можете использовать Babel и службу polyfill, чтобы это было хорошо браузеры.

18
ответ дан 25 апр. '16 в 13:21
источник

Я знаю, что уже есть много ответов, но многие из них, похоже, усложняют проблему. Вот простой, рекурсивный способ удаления всех экземпляров ключа - вызывает 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);
}
16
ответ дан 03 февр. '14 в 18:41
источник

У меня есть еще одно хорошее решение для удаления из массива:

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

15
ответ дан 05 июня '18 в 17:47
источник

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

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

15
ответ дан 12 авг. '13 в 20:56
источник

Основываясь на всех ответах, которые были в основном правильными, и с учетом лучших рекомендаций (особенно без непосредственного использования Array.prototype), я пришел к следующему коду:

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, он превосходит lodash! Обратите внимание, что я не использую Array.prototype.indexOf или Array.prototype.includes поскольку обертывание exlcudeValues в Map или Object ускоряет выполнение запросов!

15
ответ дан 28 янв. '14 в 17:44
источник
  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');
13
ответ дан 26 сент. '13 в 3:12
источник
  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');
13
ответ дан 26 сент. '13 в 3:12
источник

Удалить по индексу

Функция, возвращающая копию массива без элемента в индексе.

/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
    return array.filter(function(elem, _index){
        return index != _index;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));

$> [ 1, 4, 5, 6, 7 ]

Удалить по значению

Функция, возвращающая копию массива без значения.

/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
    return array.filter(function(elem, _index){
        return value != elem;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));

$> [ 1, 3, 4, 6, 7]
12
ответ дан 12 мая '17 в 5:00
источник

Создать новый массив:

var my_array = new Array();

Добавить элементы в этот массив:

my_array.push("element1");

Функция indexOf (возвращает индекс или -1, если не найден):

var indexOf = function(needle) 
{
    if(typeof Array.prototype.indexOf === 'function') // newer browsers
    {
        indexOf = Array.prototype.indexOf;
    } 
    else // older browsers
    {
        indexOf = function(needle) 
        {
            var index = -1;

            for(var i = 0; i < this.length; i++) 
            {
                if(this[i] === needle) 
                {
                    index = i;
                    break;
                }
            }
            return index;
        };
    }

    return indexOf.call(this, needle);
};

Проверить индекс этого элемента (проверено с помощью firefox и IE8 +):

var index = indexOf.call(my_array, "element1");

Удалить 1 элемент, расположенный по индексу из массива

my_array.splice(index, 1);
11
ответ дан 07 авг. '13 в 15:57
источник

Я также столкнулся с ситуацией, когда мне пришлось удалить элемент из Array. .indexOf не работал в IE*, поэтому делился моим рабочим решением jQuery.inArray().

var index = jQuery.inArray(val,arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}
10
ответ дан 08 окт. '13 в 13:09
источник

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

Представьте, что вы выполняете рекурсивный вызов и должны передавать массив с одним меньшим элементом, возможно, без текущего индексированного элемента. Или представьте, что вы выполняете другой рекурсивный вызов и должны передать массив с нажатым элементом.

В любом из этих случаев вы не можете сделать myRecursiveFunction(myArr.push(c)) или myRecursiveFunction(myArr.splice(i,1)). Первый идиот фактически передаст длину массива, а второй идиот передаст удаленный элемент в качестве параметра.

Итак, что я делаю на самом деле... Для удаления элемента массива и передачи результата в функцию в качестве параметра в то же время я делаю следующее:

myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

Когда дело доходит до того, что это глупо... Мне нравится,

myRecursiveFunction((myArr.push(c),myArr))

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

9
ответ дан 07 мая '16 в 23:10
источник

2017-05-08

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

const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a            // Non-primitive object that reference the same object as "a"

assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)

//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
   return  JSON.stringify(x) === JSON.stringify(y)
}


//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
    return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}

const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);

//resultArray = [{'field':90}]

Существуют альтернативные/более быстрые реализации для значенийAreEqual, но это делает работу. Вы также можете использовать пользовательский компаратор, если у вас есть определенное поле для проверки (например, некоторые извлеченные UUID и локальный UUID).

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

9
ответ дан 08 мая '17 в 20:58
источник

Я хочу ответить на основе ES6. Предположим, у вас есть массив, как показано ниже:

let arr = [1,2,3,4];

Если вы хотите удалить специальный индекс, например, 2, напишите код ниже:

arr.splice(2, 1); //=> arr became [1,2,4]

Но если вы хотите удалить специальный элемент, такой как 3 и не знаете его индекс, сделайте, как показано ниже:

arr = arr.filter(e => e !== 3) //=> arr became [1,2,4]

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

9
ответ дан 30 окт. '18 в 20:37
источник

В CoffeeScript:

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
8
ответ дан 30 янв. '14 в 7:27
источник

Использовать jQuery InArray:

A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`   

Примечание: inArray вернет -1, если элемент не найден.

7
ответ дан 17 сент. '14 в 13:14
источник

Вы можете перебирать каждый array -item и splice, если он существует в вашем array.

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}
6
ответ дан 13 мая '13 в 15:22
источник

Ванильный JavaScript (ES5.1) - на месте издания

Поддержка браузера: Internet Explorer 9 или более поздняя версия (подробная поддержка браузера)

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array "in place", i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

Ванильный JavaScript (ES5.1) - неизменяемое издание

Поддержка браузера: то же, что и ванильный JavaScript на месте

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 - неизменяемое издание

Поддержка браузера: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 (подробная поддержка браузера)

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}
6
ответ дан 11 апр. '16 в 8:47
источник

Удалить элемент в индексе i, не изменяя исходный массив:

/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
   return Array.from(array).splice(index, 1);
}

// Another way is
function removeElement(array, index) {
   return array.slice(0).splice(index, 1);
}
6
ответ дан 05 мая '17 в 4:32
источник

Мне нравится эта версия сращивания, удаляя элемент по его значению с помощью $.inArray:

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});
6
ответ дан 20 марта '14 в 12:56
источник

Я просто создал polyfill на Array.prototype помощью Object.defineProperty чтобы удалить нужный элемент в массиве, не приводя к ошибкам при повторении через него позже через for.. in..

if (!Array.prototype.remove) {
  // Object.definedProperty is used here to avoid problems when iterating with "for .. in .." in Arrays
  // https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
  Object.defineProperty(Array.prototype, 'remove', {
    value: function () {
      if (this == null) {
        throw new TypeError('Array.prototype.remove called on null or undefined')
      }

      for (var i = 0; i < arguments.length; i++) {
        if (typeof arguments[i] === 'object') {
          if (Object.keys(arguments[i]).length > 1) {
            throw new Error('This method does not support more than one key:value pair per object on the arguments')
          }
          var keyToCompare = Object.keys(arguments[i])[0]

          for (var j = 0; j < this.length; j++) {
            if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
              this.splice(j, 1)
              break
            }
          }
        } else {
          var index = this.indexOf(arguments[i])
          if (index !== -1) {
            this.splice(index, 1)
          }
        }
      }
      return this
    }
  })
} else {
  var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
  errorMessage += 'This may lead to unwanted results when remove() is executed.'
  console.log(errorMessage)
}

Удаление целочисленного значения

var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]

Удаление строкового значения

var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']

Удаление логического значения

var a = [true, false, true]
a.remove(false)
a // Output => [true, true]

Также можно удалить объект внутри массива с помощью этого метода Array.prototype.remove. Вам просто нужно указать значение key => value Object вы хотите удалить.

Удаление значения объекта

var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
a.remove({a: 1})
a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]
5
ответ дан 08 марта '18 в 21:35
источник

По моему решению вы можете удалить один или несколько элементов в массиве благодаря чистому JavaScript. Нет необходимости в другой библиотеке JavaScript.

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]
5
ответ дан 29 янв. '16 в 11:53
источник

Я сделал довольно эффективное расширение базового массива JavaScript:

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};
5
ответ дан 12 авг. '16 в 20:59
источник

Используйте jQuery.grep():

var y = [1, 2, 3, 9, 4]
var removeItem = 9;

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>
4
ответ дан 28 июня '16 в 12:13
источник

В то время как большинство ответов, приведенных выше, отвечают на вопрос, недостаточно ясно, почему метод slice() не использовался. Да, filter() соответствует критериям неизменяемости, но как сделать следующий сокращенный эквивалент:

const myArray = [1,2,3,4];

А теперь скажем, что мы должны удалить второй элемент из массива, мы можем просто сделать: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4)); // [1,3,4]

Этот способ удаления элемента из массива настоятельно рекомендуется сегодня в сообществе из-за его простой и неизменной природы. В общем, следует избегать методов, вызывающих мутацию. Например, вам рекомендуется заменить push() на concat() и splice() на slice()

4
ответ дан 29 нояб. '16 в 23:54
источник

Удалите одно значение, используя свободное сравнение, без изменения исходного массива, ES6

/**
 * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
 * 
 * @param {Array} array Array to remove value from
 * @param {*} value Value to remove
 * @returns {Array} Array with `value` removed
 */
export function arrayRemove(array, value) {
    for(let i=0; i<array.length; ++i) {
        if(array[i] == value) {
            let copy = [...array];
            copy.splice(i, 1);
            return copy;
        }
    }
    return array;
}
4
ответ дан 09 апр. '17 в 23:09
источник

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

function removeElement(idx, arr) {
    // check the index value
    if (idx < 0 || idx >= arr.length) {
        return;
    }
    // shift the elements
    for (var i = idx; i > 0; --i) {
        arr[i] = arr[i - 1];
    }
    // remove the first element in array
    arr.shift();
}
3
ответ дан 31 июля '17 в 1:55
источник

Я сделал функцию

function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}

И используется так.

pop(valuetoremove,myarray);

Ура!

3
ответ дан 20 марта '17 в 14:16
источник

Здесь есть много фантастических ответов, но для меня самое простое - просто не удалять мой элемент из массива, а просто устанавливать его значение в null. Это работает для большинства случаев, которые у меня есть, и это хорошее решение, так как я буду использовать переменную позже и не хочу, чтобы она ушла, просто пустая. Кроме того, этот подход полностью совместим с несколькими браузерами.

array.key = null;
3
ответ дан 07 янв. '15 в 22:53
источник

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

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.push(element);
  }

  return dupFree;
}
3
ответ дан 18 сент. '17 в 16:17
источник

Очень наивная реализация будет следующей:

Array.prototype.remove = function(data) {
    const dataIdx = this.indexOf(data)
    if(dataIdx >= 0) {
        this.splice(dataIdx ,1);
    }
    return this.length;
}

let a = [1,2,3];
// this will change arr a to [1, 3]
a.remove(2);

Я возвращаю длину массива из функции для соответствия другим методам, например Array.prototype.push().

3
ответ дан 09 марта '18 в 8:40
источник

Удалить последнее вхождение или все вхождения или первое вхождение?

var array = [2, 5, 9, 5];

// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Remove this line to remove all occurrences
  }
}

или

var array = [2, 5, 9, 5];

// Remove first occurrence
for (var i = 0; array.length; i++) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Do not remove this line
  }
}
3
ответ дан 10 янв. '16 в 16:36
источник

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

Я просмотрел много этих ответов, и все они, кажется, используют "грубую силу", насколько я могу судить. Я не изучал никого, извиняюсь, если это не так. Для небольшого массива это прекрасно, но что, если у вас есть целые числа в нем?

Исправьте меня, если я ошибаюсь, но не можем ли мы предположить, что в карте key => value, типа объекта JS, можно предположить, что механизм поиска ключей может быть сильно спроектирован и оптимизирован? (NB, если какой-то супер-эксперт говорит мне, что это не так, я могу предложить вместо этого использовать класс ES6 Map, что, безусловно, будет).

Я просто предлагаю, что в определенных обстоятельствах лучшим решением может быть преобразование вашего массива в объект... проблема состоит в том, что вы, возможно, повторяете целочисленные значения. Я предлагаю помещать их в ведра в качестве "значения" в элементах key => value. (NB, если вы уверены, что у вас нет повторяющихся элементов массива, это может быть намного проще: значения "такие же, как", и просто идут Object.values(...) чтобы вернуть ваш модифицированный массив).

Таким образом, вы можете сделать:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =   function( acc, val, currIndex ){ 
    // not seen this val before: make bucket... NB although val typeof is 'number'
    // there is seamless equivalence between the object key (always string)
    // and this variable val 
    ! ( val in acc ) ? acc[ val ] = []: 0;
    // drop another array index in the bucket
    acc[ val ].push( currIndex );
    return acc; 
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

вывод:

Объект [<1 пустой слот>, массив 1, массив [2], массив 1, массив 1, <5 пустых слотов>, еще 46...]

тогда легко удалить все числа 55

delete myIntsMapObj[ 55 ]; // again, although keys are strings this works

Вам не нужно их удалять: значения индекса вставляются в их ведра в порядке их появления, поэтому (например):

myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop(); 

будет удалять первое и последнее вхождение соответственно. Вы можете подсчитать частоту возникновения легко, замените все 55s на 3s, передав содержимое одного ведра в другое и т.д.

... возвращение вашего измененного массива int немного связано: но каждый ведро содержит индекс (в исходном массиве) значения, представленного ключом (строкой). Каждое из этих значений ведра также уникально: поэтому вы превращаете их в ключи в новом объекте, с (реальным) целым числом от "целочисленного строкового ключа" в качестве значения... затем Object.values(... ) ключи и переходите в Object.values(... ).

Это звучит очень привлекательно и требует много времени... но, очевидно, все зависит от обстоятельств и желаемого использования. Я понимаю, что все версии и контексты JS работают только в одном потоке, и нить не "отпустит", поэтому может возникнуть какая-то ужасная перегрузка с помощью метода "грубой силы", вызванного не столько операциями indexOf, но несколько повторных операций slice/splice.

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

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(да, в других ответах был Array.prototype.filter...)

2
ответ дан 24 нояб. '17 в 22:17
источник

удалить элемент из последнего

arrName.pop();

удалить элемент с первого

arrName.shift();

удалить из середины

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

удалить один элемент из последнего

arrName.splice(-1);

Удалить с помощью номера индекса массива

 delete arrName[1];
2
ответ дан 28 июня '18 в 20:48
источник

У меня была эта проблема сама (в ситуации, когда замена массива была приемлемой) и решила ее простым:

var filteredItems = this.items.filter(function (i) {
    return i !== item;
});

Чтобы дать приведенный выше фрагмент немного контекста:

self.thingWithItems = {
        items: [],
        removeItem: function (item) {
            var filteredItems = this.items.filter(function (i) {
                return i !== item;
            });

            this.items = filteredItems;
        }
    };

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

2
ответ дан 12 сент. '18 в 12:16
источник
var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);

Используя Array.findindex, мы можем уменьшить количество строк кода.

developer.mozilla.org

2
ответ дан 15 февр. '18 в 11:14
источник
var index,
    input = [1,2,3],
    indexToRemove = 1;
    integers = [];

for (index in input) {
    if (input.hasOwnProperty(index)) {
        if (index !== indexToRemove) {
            integers.push(result); 
        }
    }
}
input = integers;

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

2
ответ дан 26 июня '14 в 2:57
источник

Удаление значения с помощью индекса и сращивания!

function removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}
2
ответ дан 22 окт. '14 в 17:10
источник

Следующий метод удалит все записи заданного значения из массива без создания нового массива и только с одной итерацией, которая является сверхбыстрой. И он работает в древнем браузере Internet Explorer &:

function removeFromArray(arr, removeValue) {
  for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
    if (k > 0)
      arr[i - k] = arr[i];

    if (arr[i] === removeValue)
      k++;
  }

  for (; k--;)
    arr.pop();
}

var a = [0, 1, 0, 2, 0, 3];

document.getElementById('code').innerHTML =
  'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]

removeFromArray(a, 0);

document.getElementById('code').innerHTML +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]
<code id="code"></code>
2
ответ дан 15 нояб. '15 в 14:09
источник

Ваш вопрос не указывает, является ли заказ или отдельные значения обязательными.

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

var aSet = new Set();

aSet.add(1);
aSet.add(2);
aSet.add(3);

aSet.delete(2);
2
ответ дан 27 апр. '18 в 3:07
источник

Если вы должны поддерживать более старые версии Internet Explorer, я рекомендую использовать следующий polyfill (примечание: это не). Это 100% обратная совместимость замены всех современных методов массива (JavaScript 1.8.5/ECMAScript 5 Array Extras), который работает для Internet Explorer 6+, Firefox 1.5+, Chrome, Safari и Opera.

https://github.com/plusdude/array-generics

1
ответ дан 26 нояб. '14 в 22:39
источник

Определите метод с именем remove() для объектов массива с использованием прототипа JavaScript.

Используйте метод splice() для выполнения вашего требования.

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

Array.prototype.remove = function(item) {
    // index will have -1 if item does not exist
    // else it will have the index of 1st item found in array
    var index = this.indexOf(item); 

    if (index > -1) {
        // splice() method is used to add/remove items(s) in array
        this.splice(index, 1); 
    }

    return index;
}


var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];

// Printing array
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// Removing 67 (getting its index i.e. 2)
console.log("Removing 67")
var index = arr.remove(67)

if (index > 0){
    console.log("Item 67 found at ", index)
} else {
    console.log("Item 67 does not exist in array")
}

// Printing updated array
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// ............... Output ................................
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
// Removing 67
// Item 67 found at  2
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]

Примечание. Ниже приведен полный пример кода, выполняемого в Node.js REPL, который описывает использование методов push(), pop(), shift(), unshift() и splice().

> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> arr.push(55);
17
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
> // Popping item from array (i.e. from end)
undefined
> arr.pop()
55
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Remove item from beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
16
> arr
[ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.unshift(11, 22); // Adding 2 more items at the beginning of array
18
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
undefined
> Array.prototype.remove = function(item) {
... var index = this.indexOf(item);
... if (index > -1) {
..... this.splice(index, 1); // splice() method is used to add/remove items in array
..... }
... return index;
... }
[Function]
>
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(45);   // Remove 45 (You will get the index of removed item)
3
> arr
[ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(22)    // Remove 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67)    // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89)    // Remove 89
2
> arr
[ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(100);  // 100 doesn't exist, remove() will return -1
-1
>

Благодарю.

1
ответ дан 13 мая '18 в 10:41
источник

Еще один ответ, для меня, чем проще, тем лучше, и, поскольку мы находимся в 2018 году (около 2019 года), я даю вам этот (около) один вкладыш, чтобы ответить на первоначальный вопрос:

Array.prototype.remove = function (value) { 
    return this.filter(f => f != value) 
}

Полезно то, что вы можете использовать его в выражении карри, например:

[1,2,3].remove(2).sort()

0
ответ дан 21 дек. '18 в 18:10
источник

Есть уже много ответов, но поскольку никто не сделал это с одним лайнером, я решил, что покажу свой метод. Он использует тот факт, что функция 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 удаляются из массива ary. Однако важно отметить, что любой массив, содержащий символ "-" , вызовет проблемы с этим примером. Короче говоря, это вызовет функцию join ( "-" ), чтобы скомпоновать вашу строку. В такой ситуации все строки "-" в приведенном выше снэпе могут быть заменены любой строкой, которая не будет использоваться в исходном массиве. Вот еще один пример:

var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("!@#").split("!@#4!@#").join("!@#").split("!@#");
console.log(out);
0
ответ дан 15 июля '17 в 2:58
источник
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;
}
0
ответ дан 21 мая '16 в 7:08
источник

вы можете использовать метод.splice() для массива для удаления определенного элемента из массива.

Вы можете взять ссылку снизу. Https://www.hostingadvice.com/how-to/javascript-remove-element-array/

-1
ответ дан 11 авг. '18 в 22:11
источник
    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]

-1
ответ дан 22 июля '18 в 7:42
источник
var ar1 = [1,2,3,4,5,6,7,8,9]
var toBeRemoved = 2;
ar1.splice( (ar1.length -toBeRemoved) , toBeRemoved);
-9
ответ дан 29 окт. '17 в 12:31
источник
let array = [5,5,4,4,2,3,4]    
let newArray = array.join(',').replace('5','').split(',')

Этот пример работает, если вы хотите удалить один текущий элемент.

-11
ответ дан 13 апр. '18 в 14:31
источник

Игры в 30 строк кода:


Гонки на JS. Поехали!

Ball на JS. Поехали!

Интересные вопросы: