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

Я не совсем понимаю, как вы ожидаете, что будет работать 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];

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

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

Если вы хотите оставить пустое место:

array[index] = undefined;

Если вы не хотите оставлять пустое место:

// Чтобы сохранить оригинальный массив:
// oldArray = [...array];

// Это изменяет массив.
array.splice(index, 1);

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

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

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

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

Вопрос: Как можно удалить элемент из массива на основе его значения в JavaScript?

Ответ:

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

Array.prototype.removeByValue = function (val) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] === val) {
      this.splice(i, 1); // Удаляем элемент
      i--; // Уменьшаем индекс, чтобы проверить следующий элемент
    }
  }
  return this; // Возвращаем измененный массив
}

var fruits = ['apple', 'banana', 'carrot', 'orange'];
fruits.removeByValue('banana');

console.log(fruits);
// -> ['apple', 'carrot', 'orange']

В этом примере метод removeByValue проходит по массиву, сравнивает каждый элемент с указанным значением val, и если находит совпадение, удаляет его с помощью splice. Обратите внимание, что мы уменьшаем индекс i после удаления элемента, чтобы корректно проверить следующий элемент, поскольку длина массива уменьшается.

В данном случае нет необходимости использовать indexOf или splice, если требуется удалить только одно вхождение элемента. Однако, если вы хотите удалить все вхождения элемента из массива, подход с использованием move показывает лучшую производительность.

Нахождение и перемещение (move):

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

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

Использование только splice (splice):

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

Хотя здесь не используется indexOf, производительность всё равно уступает варианту с move, поскольку splice также приводит к сдвигу элементов массива при каждом удалении.

Время выполнения на Node.js для массива из 1000 элементов (среднее по 10,000 запусков):

indexof работает примерно в 10 раз медленнее, чем move. Даже если мы устраним вызов indexOf в реализации splice, он все равно будет значительно медленнее, чем move.

Удаление всех вхождений:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Удаление первого вхождения:
    move_one 0.0041 ms
    indexof_one 0.0021 ms

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

Это предоставляет предикат вместо значения.

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

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

var removed = helper.remove(arr, row => row.id === 5);

var removed = helper.removeAll(arr, row => row.name.startsWith('BMW'));

Определение

var helper = {
  // Удалить и вернуть первое вхождение
  remove: function(array, predicate) {
    for (var i = 0; i < array.length; i++) {
      if (predicate(array[i])) {
        return array.splice(i, 1);
      }
    }
  },

  // Удалить и вернуть все вхождения
  removeAll: 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;
  },
};

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