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

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

Эквивалент чего-то вроде -

array.remove(number);

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

9110
Walker 24 Апр 2011 в 02:17

29 ответов

Лучший ответ

Найдите index элемента массива, который вы хотите удалить, используя indexOf, а затем удалите этот индекс с помощью splice.

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

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

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

11527
laurent 29 Дек 2019 в 19:33

Я не знаю, как вы ожидаете 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];
1218
Peter Mortensen 8 Мар 2020 в 17:09

Это легко сделать с помощью фильтра метод:

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

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

66
Peter Mortensen 1 Сен 2019 в 22:16

У вас есть от 1 до 9 в массиве, и вы хотите удалить 5. Используйте следующий код:

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);

Если вы хотите несколько значений. Пример: - 1,7,8

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 1,7 and 8 removed", newNumberArray);

Если вы хотите удалить значение массива в массиве. Пример: [3,4,5]

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

Включает поддерживаемый браузер по ссылке.

20
Thilina Sampath 2 Сен 2019 в 04:01
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)
141
Anthony 25 Сен 2017 в 04:56

Я довольно новичок в 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"]

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

29
yckart 30 Дек 2014 в 16:17

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

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]

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

26
Peter Mortensen 1 Сен 2019 в 22:59

Удаление определенного элемента / строки из массива можно выполнить в одну строку:

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

Где:

theArray : массив, из которого вы хотите удалить что-то конкретное

stringToRemoveFromArray : строка, которую вы хотите удалить, а 1 - это количество элементов, которые вы хотите удалить.

ПРИМЕЧАНИЕ : если "stringToRemoveFromArray" не находится в вашем массиве, это удалит последний элемент массива.

Хорошей практикой является проверка наличия элемента в вашем массиве перед его удалением.

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

Если у вас есть доступ к более новым версиям Ecmascript на компьютерах вашего клиента (ВНИМАНИЕ, может не работать на старых станциях):

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

Где «3» - это значение, которое вы хотите удалить из массива. Массив станет: ['1','2','4','5','6']

30
Max Alexander Hanna 3 Апр 2020 в 01:58

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

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)
34
Dipen 10 Фев 2020 в 07:37

Джон Ресиг опубликовал хорошую реализацию:

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

64
magiccrafter 16 Фев 2015 в 12:51

Вот несколько способов удалить элемент из массива с помощью JavaScript .

Все описанные методы не изменяют исходный массив , а вместо этого создают новый.

Если вы знаете индекс предмета

Предположим, у вас есть массив, и вы хотите удалить элемент в позиции i.

Один из методов - использовать slice():

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, 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- пункт - с - массив / )

34
Flavio Copes 14 Апр 2019 в 16:39

Вы можете использовать ES6. Например, чтобы удалить значение «3» в этом случае:

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

Выход :

["1", "2", "4", "5", "6"]
62
darmis 1 Окт 2019 в 22:13

Вы никогда не должны изменять свой массив. Как это против функционального шаблона программирования. Вы можете создать новый массив, не ссылаясь на массив, для которого вы хотите изменить данные, используя метод ECMAScript 6 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.

23
Peter Mortensen 1 Сен 2019 в 22:41

Основываясь на всех ответах, которые были в основном правильными, и с учетом лучших рекомендаций (особенно без непосредственного использования 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 ускоряет выполнение запросов!

18
Ardi 19 Ноя 2018 в 23:02

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

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

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
27
Anik Islam Abhi 10 Ноя 2015 в 04:20

Обновление . Этот метод рекомендуется, только если вы не можете использовать 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]
25
zykadelic 1 Сен 2017 в 22:41

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

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

52
Peter Mortensen 1 Сен 2019 в 20:30

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

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

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

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

268
Peter Mortensen 1 Сен 2019 в 21:54

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

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

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
63
Peter Mortensen 21 Май 2017 в 11:29

Производительность

Сегодня (2019-12-09) я провожу тесты производительности на macOS v10.13.6 (High Sierra) для выбранных решений. Я показываю delete (A), но я не использую его по сравнению с другими методами, потому что он оставил пустое место в массиве.

Выводы

  • самое быстрое решение - array.splice (C) (за исключением Safari для небольших массивов, где он второй раз)
  • для больших массивов array.slice+splice (H) - самое быстрое неизменное решение для Firefox и Safari; Array.from (B) самый быстрый в Chrome
  • изменяемые решения обычно в 1,5-6 раз быстрее, чем неизменяемые
  • для небольших таблиц в Safari неожиданно изменяемое решение (C) медленнее, чем неизменяемое решение (G)

Детали

В тестах я удаляю средний элемент из массива разными способами. Решения A, C на месте. Решения B, D, E, F, G, H являются неизменными.

Результаты для массива из 10 элементов

Enter image description here

В Chrome array.splice (C) - самое быстрое решение на месте. array.filter (D) является самым быстрым неизменным решением. Самый медленный - array.slice (F). Вы можете выполнить тест на своем компьютере здесь.

Результаты для массива с 1.000.000 элементов

Enter image description here

В Chrome array.splice (C) - самое быстрое решение на месте (delete (C) - аналогично быстро - но оно оставило пустую ячейку в массиве (поэтому не выполняет 'полный') Удалить')). array.slice-splice (H) является самым быстрым неизменным решением. Самый медленный - array.filter (D и E). Вы можете выполнить тест на своем компьютере здесь.

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);
This snippet only presents code used in performance tests - it does not perform tests itself.

Сравнение для браузеров: Chrome v78.0.0, Safari v13.0.4 и Firefox v71.0.0

Enter image description here

20
Peter Mortensen 8 Мар 2020 в 17:33

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

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);
43
Ekramul Hoque 24 Май 2014 в 07:02

Нет необходимости использовать 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 раз медленнее, чем move . Даже если его улучшить, удалив вызов indexOf в splice , он работает намного хуже, чем move .

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
103
slosd 11 Сен 2015 в 12:47

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

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

Применение

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;
    }
};
71
Peter Mortensen 1 Сен 2019 в 22:18

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

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']
41
Chun Yang 25 Авг 2015 в 21:19

Я знаю, что ответов уже много, но многие из них, кажется, слишком усложняют проблему. Вот простой, рекурсивный способ удаления всех экземпляров ключа - вызывает 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);
}
18
wharding28 19 Фев 2014 в 22:20

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

22
Peter Mortensen 25 Июн 2016 в 13:01

Есть два основных подхода:

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

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

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

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

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

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

166
Peter Mortensen 1 Сен 2019 в 21:51

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

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

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

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

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

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] в массиве?

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.

34
Peter Mortensen 1 Сен 2019 в 22:33

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

Если вам нужен пустой слот, удаление возможно:

delete array[index];

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

array.splice(index, 1);

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

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

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

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

440
Peter Mortensen 1 Сен 2019 в 20:29