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

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

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

Я должен использовать основной JavaScript - не допускается никаких структур.

159 ответов

Я только что создал полифилл на 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://stackru.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}]

Удалить отдельный элемент

function removeSingle(array, element) {
    const index = array.indexOf(element)
    if (index >= 0) {
        array.splice(index, 1)
    }
}

Удаление нескольких элементов на месте

Это более сложно, чтобы гарантировать, что алгоритм работает за время O(N).

function removeAll(array, element) {
    let newLength = 0
    for (const elem of array) {
        if (elem !== number) {
            array[newLength++] = elem
        }
    }
    array.length = newLength
}

Удалите несколько элементов, создав новый объект

array.filter(elem => elem !== number)

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

Array.prototype.removeItem = function(array,val) {
    array.forEach((arrayItem,index) => {
        if (arrayItem == val) {
            array.splice(index, 1);
        }
    });
    return array;
}
var DummyArray = [1, 2, 3, 4, 5, 6];
console.log(DummyArray.removeItem(DummyArray, 3));

  • pop - удаляет из конца массива
  • shift - удаляет из начала массива
  • splice - удаляет из определенного индекса массива
  • фильтр - позволяет программно удалять элементы из массива
      const arr = [1, 2, 3, 4, 5]
console.log(arr) // [ 1, 2, 3, 4, 5 ]

Предположим, вы хотите удалить номер 3 из обр.

      const newArr = arr.filter(w => w !==3)
console.log(newArr) // [ 1, 2, 4, 5 ]

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

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

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

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

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

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

Удалить определенный элемент из массива можно в одной строке с помощью параметра фильтра, и он поддерживается всеми браузерами: https://caniuse.com/

function removeValueFromArray(array, value) {
    return array.filter(e => e != value)
}

Я тестировал эту функцию здесь: https://bit.dev/joshk/jotils/remove-value-from-array/~code

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;

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

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

array.key = null;

есть несколько способов сделать это, и вам решать, как вы хотите, чтобы это действовало

один из подходов заключается в использовании spliceметод и удалить элемент из массива

      let array = [1,2,3]
array.splice(1,1);
console.log(array)

// return [1,3]

но убедитесь, что вы передаете второй аргумент, иначе вы удалите весь массив после индекса

второй подход заключается в использовании filterметод, и преимущество в том, что он неизменяем, что означает, что ваш основной массив не манипулируется

      const array = [1,2,3];
const newArray = array.filter(item => item !== 2)
console.log(newArray)

// return [1,3]

это мой простой код для удаления конкретных данных в массиве с использованием метода сращивания. метод splice будет иметь 2 параметра, первый параметр — начальный номер, а второй параметр — deleteCount. Второй параметр используется для удаления некоторого элемента, начиная со значения первого параметра.

      let arr = [1,3,5,6,9];

arr.splice(0,2);

console.log(arr);

Вы можете добавить функцию-прототип для «удаления» элемента из массива. В следующем примере показано, как просто удалить элемент из массива, когда мы знаем индекс элемента. Мы используем в немArray.filter метод.

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

         function removeArrayItem(index, array) {
 array.splice(index, 1);
 return array;
}

let array = [1,2,3,4];
let index = 2;
array = removeArrayItem(index, array);
console.log(array);

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

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

Вам просто нужен фильтр по элементу или индексу:

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

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>

Определите метод с именем 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 ]

Примечание. Ниже приведен полный пример кода, выполняемого в REPL Node.js, в котором описано использование методов 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
>

Благодарю.

Самый чистый из всех:

Это также удалит дубликаты (если они есть).

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

Синтаксис: array.splice (index, deleteCount, item1,....., itemX)

Вот index является обязательным, а остальные аргументы необязательны.

Например:

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

Примечание. Метод Array.splice() можно использовать, если вы знаете индекс элемента, который хотите удалить. Но у нас может быть еще несколько случаев, как указано ниже:

  1. Если вы хотите удалить только последний элемент, вы можете использовать Array.pop ()

  2. Если вы хотите удалить только первый элемент, вы можете использовать Array.shift ()

  3. Если вы знаете только один элемент, но не знаете его позицию (или индекс) и хотите удалить все соответствующие элементы с помощью метода Array.filter ():

    let arr = [1, 2, 1, 3, 4, 1, 5, 1];
    
    let newArr = arr.filter(function(val){
        return val !== 1;
     });
     //newArr => [2, 3, 4, 5]
    

ИЛИ используя метод splice () как

let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    for( let i = 0; i < arr.length-1; i++){
       if ( arr[i] === 11) {
         arr.splice(i, 1); 
       }
    }
    console.log(arr);
    // [1, 2, 3, 4, 5, 6]

ИЛИ предположим, что мы хотим удалить del из массива обр:

let arr = [1, 2, 3, 4, 5, 6];
let del = 4;
if(arr.indexOf(4) >= 0) {
arr.splice(arr.indexOf(4), 1)
}

ИЛИ ЖЕ

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}
  1. Если вы знаете только один элемент, но не знаете его позицию (или индекс) и хотите удалить только самый первый соответствующий элемент, используя метод splice ():

    let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    
    for( let i = 0; i < arr.length-1; i++){
      if ( arr[i] === 11) {
        arr.splice(i, 1);
        break;
      }
    }
    console.log(arr);
    // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
    

Вы можете использовать Set вместо этого и используйте delete функция:

      const s = Set;
s.add('hello');
s.add('goodbye');
s.delete('hello');

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

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

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

      const newArray = oldArray.filter(item => item !== removeItem);

Я хотел бы предложить удалить один элемент массива с помощью удаления и фильтрации:

var arr = [1,2,3,4,5,5,6,7,8,9];
delete arr[5];
arr = arr.filter(function(item){ return item != undefined; });
//result: [1,2,3,4,5,6,7,8,9]

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

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

let numbers = [1,2,4,4,5,3,45,9];

numbers.delete = function(value){
    var indexOfTarget = this.indexOf(value)

    if(indexOfTarget !== -1)
    {
        console.log("array before delete " + this)
        this.splice(indexOfTarget, 1)
        console.log("array after delete " + this)
    }else{
        console.error("element " + value + " not found")
    }
}
numbers.delete(888)
//expected output:
//element 888 not found
numbers.delete(1)

//expected output;
//array before delete 1,2,4,4,5,3,45,9
//array after delete 2,4,4,5,3,45,9

Надеюсь, это поможет

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

  1. Удалите только первый элемент, используяspliceметод
  2. Удалите все элементы, которые совпадают в массиве, используяforпетля

Вы можете прочитать подробный пост в блоге Самый быстрый способ удалить определенный элемент из массива в JavaScript .

Определение:

Массивы JavaScript позволяют группировать значения и перебирать их. Вы можете добавлять и удалять элементы массива разными способами. К сожалению, простого метода Array.remove не существует. Всего есть 9 способов (используйте любой из них, который вам подходит). Вместо метода удаления в массиве JavaScript есть множество способов очистки значений массива.

Существуют различные методы и техники, которые вы можете использовать для удаления элементов из массивов JavaScript:

вы можете использовать его для удаления элементов из массивов JavaScript следующими способами:

  • pop - Удаляет с конца массива
  • shift - Удаляет с начала массива
  • splice — удаляет из определенного индекса массива
  • фильтр — позволяет программно удалять элементы из массива

Способ 1: удаление элементов из начала массива JavaScript

Резюме:

Важно удалить элементы массива JavaScript для управления вашими данными. Не существует единого метода «удаления», но есть различные методы и приемы, которые вы можете использовать для очистки ненужных элементов массива.

  1. Получить массив и индекс
  2. Из массива с элементами массива
  3. Удалите определенный элемент индекса, используя remove()метод
  4. Из нового массива списка массивов с помощью maptoint()а также toarray()метод
  5. Вернуть отформатированный массив

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

что-то вроде этого :

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

Простой. Просто сделай это:

      var arr = [1,2,4,5];
arr.splice(arr.indexOf(5), 1);
console.log(arr); // [1,2,4];
Другие вопросы по тегам