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

avatar
Walker
23 апреля 2011 в 22:17
8858396
132
9873

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

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

Я ищу эквивалент чего-то вроде:

array.remove(number);

Мне нужно использовать ядро ​​ JavaScript. Фреймворки не допускаются.

Источник
Gustavo Gonçalves
24 октября 2020 в 15:51
1

array.remove (index) или array.pull (index) имели бы большой смысл. splice очень полезен, но метод remove () или pull () будет приветствоваться ... Поищите в Интернете множество вопросов «Что является противоположностью push () в JavaScript?» вопросов. Было бы здорово, если бы Answare было таким простым, как простой английский: Pull!

Andrew
23 ноября 2020 в 22:49
0

Для тех, кто не хочет indexOf() + splice(): developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… developer.mozilla.org/en -US / docs / Web / JavaScript / Reference /…

EnderShadow8
27 марта 2021 в 05:14
2

Противоположность толчка - поп

Ali NajafZadeh
3 августа 2021 в 16:57
0

константный массив = [2, 5, 9]; console.log (массив); const index = array.indexOf (5); если (индекс> -1) {array.splice (индекс, 1); } // массив = [2, 9] console.log (массив);

Brackets
12 сентября 2021 в 15:56
1

Почему это не встроено в javascript? Как может столь широко используемый язык не иметь этой базовой, но важной функции для массивов?

Ответы (132)

avatar
Justin Liu
31 июля 2021 в 04:05
14308

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

Метод 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 изменяет массив на месте и возвращает новый массив, содержащий элементы, которые были удалены.


Для полноты здесь представлены функции. Первая функция удаляет только одно вхождение (т.е. удаляет первое совпадение 5 из [2,5,9,1,5,8,5]), а вторая функция удаляет все вхождения:

function removeItemOnce(arr, value) {
  var index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

function removeItemAll(arr, value) {
  var i = 0;
  while (i < arr.length) {
    if (arr[i] === value) {
      arr.splice(i, 1);
    } else {
      ++i;
    }
  }
  return arr;
}
// Usage
console.log(removeItemOnce([2,5,9,1,5,8,5], 5))
console.log(removeItemAll([2,5,9,1,5,8,5], 5))

В TypeScript эти функции могут оставаться типобезопасными с параметром типа:

function removeItem<T>(arr: Array<T>  value: T): Array<T> { 
  const index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

default123
10 сентября 2020 в 00:16
308

Серьезный вопрос: почему JavaScript не позволяет использовать простой и интуитивно понятный метод удаления элемента по индексу? Простой и элегантный myArray.remove(index); кажется лучшим решением и реализован на многих других языках (многие из них старше JavaScript).

Stefan Fabian
1 декабря 2020 в 09:44
9

Наборы и массивы @Andrew - это два совершенно разных типа коллекций.

Andrew
1 декабря 2020 в 21:08
0

@StefanFabian Да, но во многих случаях они будут взаимозаменяемыми.

Luke Dupin
8 декабря 2020 в 22:30
3

Вы можете упростить это решение, начав обратный отсчет вместо увеличения: for (var i = ary.length - 1; i> = 0; i--) {if (ary [i] === value) {ary.remove (i )}}

Rashid Iqbal
7 января 2021 в 16:04
2

функция remove (item, array) {var new_array = [] new_ array = array.filter ((ar) => ar! = item) return new_array}

mikep
23 марта 2021 в 12:08
0

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

a2br
8 апреля 2021 в 16:03
0

Array.pull() это то, что человечеству нужно больше всего.

OOPS Studio
15 апреля 2021 в 09:12
7

Я немного опоздал на вечеринку, но вот мои два цента: @ a2br: Array.unshift() - это то, чем был бы pull(), если бы он существовал! @ Боб: Лично я считаю, что ничего похожего на Array.remove() не существует. Мы же не хотим, чтобы JavaScript превратился в PHP, не так ли? xD

a2br
15 апреля 2021 в 12:22
0

@OOPSStudio О да, ты прав! Я не выбрал правильное имя, я забыл о деструктивном поведении push. Ненавижу деструктивные методы при удалении вещей.

iheathers
18 июня 2021 в 08:22
0

Как упоминал @RashidIqbal, гораздо проще использовать метод filter для удаления определенного элемента, который соответствует определенному условию. Например, let array = [1, 2, 3, 5, 7]; const SOME_NUMBER = 5 (say); array = array.filter(num => num !== SOME_NUMBER). Конечно, он создаст новую копию массива. Но это хорошо читается. Но если исходный массив необходимо сохранить без обновления каких-либо элементов, обязательно сделайте еще одну копию.

user3132457
24 августа 2021 в 08:32
1

из любопытства, в чем причина использования index > -1 вместо index !== -1? indexOf() вернет либо значение из диапазона 0..n, либо -1, но никогда ничего МЕНЬШЕ -1 (developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…), поэтому я думаю, что !== более интуитивно понятный и двоичный выбор.

CodeNinja
17 сентября 2021 в 10:08
0

Я всегда делаю это как arrayWithoutRemovedItem = array.filter((item) => { return item != itemToRemove });, который отлично работает. Вы также можете удалять элементы с помощью клавиши типа arrayWithoutRemovedItem = array.filter((item) => { return item.key != itemToRemove.key });

avatar
Jose Pedro Febian
10 мая 2022 в 15:57
1

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

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

arr.splice(0,2);

console.log(arr);
avatar
Artur Müller Romanov
10 мая 2022 в 08:36
0

Если вы хотите удалить несколько элементов, я нашел это самым простым:

const oldArray = [1, 2, 3, 4, 5]
const removeItems = [1, 3, 5]

const newArray = oldArray.filter((value) => {
    return !removeItems.includes(value)
})

console.log(newArray)

выход:

[2, 4]
avatar
Weilory
9 мая 2022 в 12:28
0

удаление только первых 34 из возрастов, а не всех возрастов 34

ages.splice(ages.indexOf(34), 1);

для удаления всех возрастов 34

ages = ages.filter(a => a != 34);
avatar
Navid Barsalari
3 мая 2022 в 14:38
0
function removeArrValue(arr, item)
{ 
   return arr.filter(x => x !== item)
}
avatar
Vihan Gammanpila
23 апреля 2022 в 10:32
3

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

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

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

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

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

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

var ar = ['zero', 'one', 'two', 'three'];
    
ar.shift(); // returns "zero"
    
console.log( ar ); // ["one", "two", "three"]

Способ 2. Удаление элементов с конца массива JavaScript

var ar = [1, 2, 3, 4, 5, 6];
    
ar.length = 4; // set length to remove elements
console.log( ar ); // [1, 2, 3, 4]


var ar = [1, 2, 3, 4, 5, 6];
    
ar.pop(); // returns 6
console.log( ar ); // [1, 2, 3, 4, 5]

Способ 3: Использование объединения для удаления элементов массива в JavaScript

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

var removed = arr.splice(2,2);
console.log(arr);


var list = ["bar", "baz", "foo", "qux"];
    
list.splice(0, 2);
console.log(list);

Метод 4: Удаление элементов массива по значению с помощью объединения

var arr = [1, 2, 6, 3, 2, 6, 7, 8, 9, 10];

for (var i = 0; i < arr.length; i++) {

  if (arr[i] === 6) {

    var removed = arr.splice(i, 1);
    i--;
  }

}

console.log(arr); // 6 is removed

Метод 5: Использование метода фильтра массива для удаления элементов по значению

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

var filtered = array.filter(function(value, index, arr) {
  return value != 6 ;
});

console.log(filtered); // 6 is removed

Метод 6: Метод удаления массива Lodash

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

var removeElement = _.remove(array, function(n) {
  return n === 6;
});

console.log(array); // 6 is removed
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

Способ 7: Создание метода удаления

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

function arrayRemove(arr, value) {

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

console.log(arrayRemove(array, 6)); // 6 is removed

Способ 8: Явное удаление элементов массива с помощью оператора удаления

var ar = [1, 2, 3, 4, 5, 6];
    
delete ar[4]; // delete element with index 4
    
console.log( ar ); // [1, 2, 3, 4, undefined, 6]
    
alert( ar ); // 1,2,3,4, 6

Способ 9. Очистка или сброс массива JavaScript

var ar = [1, 2, 3, 4, 5, 6];
//do stuffar = [];
//a new, empty array!

var arr1 = [1, 2, 3, 4, 5, 6];
var arr2 = arr1; 
// Reference arr1 by another variable arr1 = [];
    
console.log(arr2); 
// Output [1, 2, 3, 4, 5, 6]

var arr1 = [1, 2, 3, 4, 5, 6];
var arr2 = arr1; 
// Reference arr1 by another variable arr1 = [];
    
console.log(arr2); 
// Output [1, 2, 3, 4, 5, 6]

Сводка:

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

avatar
amir yeganeh
11 марта 2022 в 15:44
1

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

один из подходов заключается в использовании метода 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]
avatar
Sahil Thummar
3 марта 2022 в 06:33
4
  1. Используя indexOf, можно найти определенный индекс числа из массива
    • используя объединение, можно удалить определенный индекс из массива.

const array = [1,2,3,4,5,6,7,8,9,0];
const index = array.indexOf(5);
// find Index of specific number
if(index != -1){
    array.splice(index, 1); // remove number using index
}
console.log(array);
  1. Чтобы удалить все вхождения.

let array = [1, 2, 3, 4, 5, 1, 7, 8, 9, 2, 3, 4, 5, 6];
array = array.filter(number=> number !== 5);
console.log(array);
  1. Использование соединения и разделения

    let array = [1, 2, 3, 4, 5, 1, 7, 8, 9, 2, 3, 4, 5, 6]
    array = Array.from(array.join("-").split("-5-").join("-").split("-"),Number)
    console.log(array)
avatar
Aayush Bhattacharya
18 февраля 2022 в 05:57
0

Фильтр с различными типами массивов

    **simple array**
    const arr = ['1','2','3'];
    const updatedArr = arr.filter(e => e !== '3');
    console.warn(updatedArr);

    **array of object**
    const newArr = [{id:1,name:'a'},{id:2,name:'b'},{id:3,name:'c'}]
    const updatedNewArr = newArr.filter(e => e.id !== 3);
    console.warn(updatedNewArr);

    **array of object with different parameter name**
    const newArr = [{SINGLE_MDMC:{id:1,cout:10}},{BULK_MDMC:{id:1,cout:15}},{WPS_MDMC:{id:2,cout:10}},]
    const newArray = newArr.filter((item) => !Object.keys(item).includes('SINGLE_MDMC'));
    console.log(newArray)
avatar
Mohammed Shabeer k
5 февраля 2022 в 10:22
0
function array_remove(arr, index) {
    for (let i = index; i < arr.length - 1; i++) {
        arr[i] = arr[i + 1];
    }
    arr.length -= 1;
    return arr;
}
my_arr = ['A', 'B', 'C', 'D'];
console.log(array_remove(my_arr, 0));
avatar
MuhammadAliDEV
4 февраля 2022 в 03:38
1

Поймите это:

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

Различные способы сделать это:

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

1-pop: Удаляет с конца массива.

2-shift: Удаляет с начала массива.

3-splice: удаляет из определенного индекса массива.

4- filter: позволяет программно удалять элементы из массива.


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

 var ar = ['zero', 'one', 'two', 'three'];
    
    ar.shift(); // returns "zero"
    
    console.log( ar ); // ["one", "two", "three"]

Способ 2: Удаление элементов с конца массива JavaScript

var ar = [1, 2, 3, 4, 5, 6];
    
    ar.length = 4; // set length to remove elements
    console.log( ar ); // [1, 2, 3, 4]
    
    var ar = [1, 2, 3, 4, 5, 6];
    
    ar.pop(); // returns 6
    
    console.log( ar ); // [1, 2, 3, 4, 5]

Способ 3: Использование объединения для удаления элементов массива в JavaScript

  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
    var removed = arr.splice(2,2);
    
     
    var list = ["bar", "baz", "foo", "qux"];
    
    list.splice(0, 2); 
    // Starting at index position 0, remove two elements ["bar", "baz"] and retains ["foo", "qux"].

Метод 4: перемещение элементов массива по значению с использованием объединения

 var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
    
    for( var i = 0; i < arr.length; i++){ 
    
        if ( arr[i] === 5) { 
    
            arr.splice(i, 1); 
        }
    
    }
    
    //=> [1, 2, 3, 4, 6, 7, 8, 9, 0]


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

for( var i = 0; i < arr.length; i++){ 
                               
    if ( arr[i] === 5) { 
        arr.splice(i, 1); 
        i--; 
    }
}

//=> [1, 2, 3, 4, 6, 7, 8, 9, 0]

Метод 5: Использование метода фильтра массива для удаления элементов по значению

  var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
    var filtered = array.filter(function(value, index, arr){ 
        return value > 5;
    });
    //filtered => [6, 7, 8, 9]
    //array => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

Метод 6: Метод удаления массива Lodash

var array = [1, 2, 3, 4];

var evens = _.remove(array, function(n) { return n % 2 === 0;});

console.log(array);// => [1, 3]

console.log(evens);// => [2, 4]

Способ 7: Создание метода удаления

   function arrayRemove(arr, value) { 
    
        return arr.filter(function(ele){ 
            return ele != value; 
        });
    }
    
    var result = arrayRemove(array, 6);
    // result = [1, 2, 3, 4, 5, 7, 8, 9, 0]

способ 8: Явное удаление элементов массива с помощью оператора удаления

 var ar = [1, 2, 3, 4, 5, 6];
    
    delete ar[4]; // delete element with index 4
    
    console.log( ar ); 
    
    // [1, 2, 3, 4, undefined, 6]
    
    alert( ar ); 
    
    // 1,2,3,4, 6

Способ 9: Очистить или сбросить массив JavaScript

var ar = [1, 2, 3, 4, 5, 6];
//do stuffar = [];
//a new, empty array!

var arr1 = [1, 2, 3, 4, 5, 6];
var arr2 = arr1; 
    // Reference arr1 by another variable arr1 = [];
    
console.log(arr2); 
// Output [1, 2, 3, 4, 5, 6]

var arr1 = [1, 2, 3, 4, 5, 6];
var arr2 = arr1; 
    // Reference arr1 by another variable arr1 = [];
    
console.log(arr2); 
// Output [1, 2, 3, 4, 5, 6]

Сводка:

Очень важно управлять своими данными, удаляя элементы массива JavaScript. Хотя единой функции «удаления» не существует, вы можете очистить ненужные элементы массива, используя различные способы и стратегии.

avatar
Hangover Sound Sound
2 февраля 2022 в 11:52
0

Помимо всех этих решений это также можно сделать с помощью array.reduce...

const removeItem = 
    idx => 
    arr => 
    arr.reduce((acc, a, i) =>  idx === i ? acc : acc.concat(a), [])

const array = [1, 2, 3]
const index = 1

const newArray = removeItem(index)(array) 

console.log(newArray) // logs the following array to the console : [1, 3]

... или рекурсивная функция (которая, честно говоря, не такая элегантная... может быть, у кого-то есть лучшее рекурсивное решение??)...

const removeItemPrep = 
    acc => 
    i => 
    idx => 
    arr => 

    // If the index equals i, just feed in the unchanged accumulator(acc) else...
    i === idx ? removeItemPrep(acc)(i + 1)(idx)(arr) :

    // If the array length + 1 of the accumulator is smaller than the array length of the original array concatenate the array element at index i else... 
    acc.length + 1 < arr.length ? removeItemPrep(acc.concat(arr[i]))(i + 1)(idx)(arr) : 

    // return the accumulator
    acc 

const removeItem = removeItemPrep([])(0)

const array = [1, 2, 3]
const index = 1

const newArray = removeItem(index)(array) 

console.log(newArray) // logs the following array to the console : [1, 3]
avatar
Ali Raza
25 января 2022 в 14:10
1

Лучший способ удалить элемент из массива — использовать метод пользовательского фильтра. .filter() возвращает новый массив без отфильтрованного элемента.

items = items.filter(e => e.id !== item.id);

Этот метод .filter() сопоставляется с полным массивом, и когда я возвращаю истинное условие, он помещает текущий элемент в отфильтрованный массив. подробнее о фильтре ЗДЕСЬ

avatar
Rahul Daksh
21 января 2022 в 17:49
-1

Попробуйте удалить элемент массива с помощью оператора удаления

Например:

const arr = [10, 20, 30, 40, 50, 60];
delete arr[2]; // It will Delete element present at index 2
console.log( arr ); // [10, 20, undefined , 40, 50, 60]

Примечание: Использование оператора удаления оставит пустые места/отверстия в массиве. Он не будет предупреждать о длине массива. Чтобы изменить длину массива при удалении из него элемента, используйте вместо этого метод splice.

Надеюсь, это решит все ваши проблемы.

avatar
shekhar chander
12 января 2022 в 06:47
1

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

var arr = ['1','2','3'];
arr = arr.filter(e => e !== '3');
console.warn(arr);

Это также приведет к удалению дубликатов (если они есть).

avatar
Enripro
5 января 2022 в 15:40
0

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

array.key = null;
avatar
Erçin Dedeoğlu
27 декабря 2021 в 13:25
0

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

function RemoveEmptyItems(arr) {
  var result = [];
  for (var i = 0; i < arr.length; i++) if (arr[i] != null && arr[i].length > 0) result.push(arr[i]);
  return result;
}

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

var arr = [1,2,3, "", null, 444];
arr = RemoveEmptyItems(arr);
console.log(arr);
avatar
guogangj
22 декабря 2021 в 08:54
1

Лодаш:

let a1 = {name:'a1'}
let a2 = {name:'a2'}
let a3 = {name:'a3'}
let list = [a1, a2, a3]
_.remove(list, a2)
//list now is [{name: "a1"}, {name: "a3"}]

Подробнее см. Здесь: .remove (array, [predicate = .identity])

avatar
Enripro
14 декабря 2021 в 13:36
2

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

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

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, если не найден.

avatar
user17401373
13 ноября 2021 в 07:04
3
  1. Получить массив и индекс
  2. Из arrayylist с элементами массива
  3. Удалите определенный элемент индекса, используя remove() метод
  4. Из нового массива списка массивов с использованием maptoint() и toarray() метода
  5. Вернуть форматированный массив
avatar
k26dr
4 ноября 2021 в 03:10
5

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

const s = Set;
s.add('hello');
s.add('goodbye');
s.delete('hello');
avatar
Emmanuel Onah
24 сентября 2021 в 08:41
10
 (function removeFromArrayPolyfill() {
      if (window.Array.prototype.remove) return;
    
      Array.prototype.remove = function (value) {
        if (!this.length || !value) return;
    
        const indexOfValue = this.indexOf(value);
    
        if (indexOfValue >= 0) {
          this.splice(indexOfValue, 1);
        }
      };
    })();
    
    // testing polyfill
    const nums = [10, 20, 30];
    nums.remove(20);
    console.log(nums);//[10,30]
Emmanuel Onah
24 сентября 2021 в 08:48
0

Документы: removeFromArrayPolyfill: это метод массива polyfill, который принимает значение, которое нужно удалить из массива. Примечание. Это решение не должно быть полифилом, потому что первое правило создания полифила - «Создавайте полифил только тогда, когда эта функция является выпущенной, но не была полностью синхронизирована разработчиками браузера». Таким образом, вы можете сделать это обычной функцией, которая принимает массив и значение, которое нужно удалить. Причина этого решения: причина, по которой я сделал это полифиллом, связана с тем, как вы вызвали удаление.

Peter Mortensen
2 января 2022 в 16:09
0

Объяснение было бы в порядке. Например. в чем идея / суть? Чем он отличается от остальных 136 ответов? Пожалуйста, ответьте, изменив свой ответ, а не здесь, в комментариях ( без «Изменить:», «Обновить:» или аналогичный - ответ должен выглядеть так, как если бы он был написан сегодня).

avatar
jnbm
20 сентября 2021 в 14:32
6

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

В следующем примере показано, как просто удалить элемент из массива, если нам известен индекс элемента. Мы используем его в методе Array.filter.

Array.prototype.removeByIndex = function(i) {
    if(!Number.isInteger(i) || i < 0) {
        // i must be an integer
        return this;
    }

    return this.filter((f, indx) => indx !== i)
}
var a = [5, -89, (2 * 2), "some string", null, false, undefined, 20, null, 5];

var b = a.removeByIndex(2);
console.log(a);
console.log(b);

Иногда мы не знаем индекс элемента.

Array.prototype.remove = function(i) {
    return this.filter(f => f !== i)
}
var a = [5, -89, (2 * 2), "some string", null, false, undefined, 20, null, 5];

var b = a.remove(5).remove(null);
console.log(a);
console.log(b);

// It removes all occurrences of searched value

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

Array.prototype.removeFirst = function(i) {
    i = this.indexOf(i);

    if(!Number.isInteger(i) || i < 0) {
        return this;
    }

    return this.filter((f, indx) => indx !== i)
}
var a = [5, -89, (2 * 2), "some string", null, false, undefined, 20, null, 5];

var b = a.removeFirst(5).removeFirst(null);
console.log(a);
console.log(b);
avatar
Julio Vinachi
25 июня 2021 в 04:39
8

Вы можете использовать стандартный __proto__ JavaScript и определить эту функцию. Например,

let data = [];
data.__proto__.remove = (n) => { data = data.flatMap((v) => { return v !== n ? v : []; }) };

data = [1, 2, 3];
data.remove(2);
console.log(data); // [1,3]

data = ['a','b','c'];
data.remove('b');
console.log(data); // [a,c]
avatar
shweta ghanate
24 апреля 2021 в 19:03
21

Использование метода массива фильтра :

let array = [1, 2, 3, 4, 511, 34, 511, 78, 88];

let value = 511;
array = array.filter(element => element !== value);
console.log(array)
Larphoid
1 мая 2021 в 22:31
0

Очень элегантное решение! Даже работает, если элементы массива являются объектами со свойствами, поэтому вы можете сделать element.property !== value

Peter Mortensen
2 января 2022 в 16:16
0

Можете ли вы дать ссылку на документацию для filter? (Но без «Изменить:», «Обновить:» и т.п. - ответ должен выглядеть так, как если бы он был написан сегодня.)

avatar
Force Bolt
19 апреля 2021 в 08:10
8

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

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
function removeItem(arr, value) {
  return arr.filter(function (ele) {
    return ele !== value;
  });
}
console.log(removeItem(arr, 6));
avatar
Asker
6 апреля 2021 в 22:55
20

Я тестировал splice и filter, чтобы увидеть, что быстрее:

let someArr = [...Array(99999).keys()] 

console.time('filter')
someArr.filter(x => x !== 6666)
console.timeEnd('filter')

console.time('splice by indexOf')
someArr.splice(someArr.indexOf(6666), 1)
console.timeEnd('splice by indexOf')

На моем компьютере splice работает быстрее. Это имеет смысл, поскольку splice просто редактирует существующий массив, тогда как filter создает новый массив.

При этом filter логически чище (легче читается) и лучше вписывается в стиль кодирования, использующий неизменяемое состояние. Так что вам решать, хотите ли вы пойти на этот компромисс.

andras
16 июня 2021 в 07:15
0

Это НЕ одно и то же , только в этом случае. filter удаляет каждый экземпляр , splice с indexOf удаляет только первый .

Asker
17 июня 2021 в 08:21
0

@andras Я никогда не утверждал, что они такие же. Вы пытались ответить на другой ответ?

Asker
17 июня 2021 в 08:25
1

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

andras
17 июня 2021 в 09:00
0

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

Asker
17 июня 2021 в 20:05
0

@andras Спасибо за разъяснение ваших намерений, но я не понимаю, как я «сделал их похожими на одно и то же», когда я прямо сказал в своем ответе: «splice просто редактирует существующий массив, тогда как filter создает новый массив . " Я также связал документы для обеих функций в начале. То, что они занимаются разными вещами, также должно быть очевидно из их имен.

Asker
17 июня 2021 в 20:07
0

@andras Кроме того, ваше утверждение о том, что «filter удаляет все экземпляры» неверно. filter не удаляет никаких экземпляров - вместо этого он полностью создает новый массив.

Peter Mortensen
2 января 2022 в 16:18
0

По «сварка выполняется быстрее» : Вы можете это количественно определить? Во сколько раз быстрее? При каких условиях (например, длина / размер материала. И в какой системе? Тепло / холодно? И т. Д.)? (Но без «Изменить:», «Обновить:» и т.п. - ответ должен выглядеть так, как если бы он был написан сегодня.)

avatar
oriadam
5 апреля 2021 в 16:16
22

Мне нравится этот однострочник:

arr.includes(val) && arr.splice(arr.indexOf(val), 1)
  • ES6 (без поддержки Internet Explorer)
  • Удаление выполнено на месте.
  • Быстро: без лишних итераций или дублирований.
  • Поддержка удаления таких значений, как null или undefined

В качестве прототипа

// remove by value. return true if value found and removed, false otherwise
Array.prototype.remove = function(val)
{
    return this.includes(val) && !!this.splice(this.indexOf(val), 1);
}

(Да, я прочитал все остальные ответы и не смог найти тот, который объединяет includes и splice в одной строке.)

Victor Gavro
28 апреля 2021 в 16:17
0

"неизменяемый" означает "не измененный" (т.е. возвращаемое значение не меняет исходное значение), в вашем случае массив фактически изменен.

oriadam
8 июня 2021 в 12:20
0

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

avatar
Dishant Chanchad
26 марта 2021 в 09:26
8

Если вы используете современный браузер, вы можете использовать .filter.

Array.prototype.remove = function(x){
    return this.filter(function(v){
        return v !== x;
    });
};

var a = ["a","b","c"];
var b = a.remove('a');
Peter Mortensen
2 января 2022 в 16:21
0

Можно ссылку на документацию для filter? Как реальная ссылка , а не голая ссылка. (Но без «Изменить:», «Обновить:» и т.п. - ответ должен выглядеть так, как если бы он был написан сегодня).

avatar
Pawara Siriwardhane
9 марта 2021 в 13:32
6

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

1. Непосредственное использование метода splice ()

В следующем сегменте кода элементы в конкретном заранее определенном месте удаляются из массива.

  • синтаксис: имя_массива.splice (begin_index, number_of_elements_remove);
  • приложение:

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

console.log("Original array: " + arr);

var removed = arr.splice(4, 2);

console.log("Modified array: " + arr);

console.log("Elements removed: " + removed);

2. Удалите элементы по значению с помощью метода splice ()

В следующем сегменте кода мы можем удалить все элементы, равные заранее определенному значению (например, все элементы, равные значению 6), используя условие if внутри цикла для .

var arr = [1, 2, 6, 3, 2, 6, 7, 8, 9, 10];

console.log("Original array: " + arr);

for (var i = 0; i < arr.length; i++) {

  if (arr[i] === 6) {

    var removed = arr.splice(i, 1);
    i--;
  }

}

console.log("Modified array: " + arr); // 6 is removed
console.log("Removed elements: " + removed);

3. Используя метод filter (), удалите элементы, выбранные по значению

Аналогично реализации с использованием метода splice (), но вместо изменения существующего массива создается новый массив элементов, удаляя ненужный элемент.

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

var filtered = array.filter(function(value, index, arr) {
  return value != 6 ;
});

console.log("Original array: "+array);

console.log("New array created: "+filtered); // 6 is removed

4. Использование метода remove () в библиотеке JavaScript Lodash

В следующем сегменте кода в библиотеке JavaScript есть метод remove () под названием Lodash. Этот метод также похож на метод фильтрации.

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log("Original array: " + array);

var removeElement = _.remove(array, function(n) {
  return n === 6;
});

console.log("Modified array: " + array);
console.log("Removed elements: " + removeElement); // 6 is removed
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

5. создание пользовательского метода удаления

В JavaScript нет собственного метода array.remove, но мы можем создать его, используя указанные выше методы, реализованные в следующем фрагменте кода.

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

function arrayRemove(arr, value) {

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

console.log("Original array: " + array);
console.log("Modified array: " + arrayRemove(array, 6)); // 6 is removed

Последний метод (номер 5) больше подходит для решения указанной выше проблемы.

avatar
Ran Turner
19 февраля 2021 в 15:17
14

Вы можете использовать фильтр для этого

const removeNumber = (arr, num) => arr.filter(el => el !== num);

let numbers = [1,2,3,4];
numbers = removeNumber(numbers, 3);
console.log(numbers); // [1,2,4]
Peter Mortensen
2 января 2022 в 16:26
0

Можете ли вы дать ссылку на документацию для filter? (Но без «Изменить:», «Обновить:» и т.п. - ответ должен выглядеть так, как если бы он был написан сегодня.)

avatar
Masoud Aghaei
27 января 2021 в 20:10
5

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

var num = [5, 6, 5, 4, 5, 1, 5];

var result1 = num.filter((el, index) => el != 5) // for remove all 5
var result2 = num.filter((el, index) => index != 5) // for remove item with index == 5

console.log(result1);
console.log(result2);
avatar
Giacomo Casadei
16 января 2021 в 21:55
9

Эта функция удаляет элемент из массива с определенной позиции.

array.remove(position);

Array.prototype.remove = function (pos) {
    this.splice(pos, 1);
}

var arr = ["a", "b", "c", "d", "e"];
arr.remove(2); // remove "c"
console.log(arr);

Если вы не знаете, где находится удаляемый элемент, используйте это:

array.erase(element);

Array.prototype.erase = function(el) {
    let p = this.indexOf(el); // indexOf use strict equality (===)
    if(p != -1) {
        this.splice(p, 1);
    }
}

var arr = ["a", "b", "c", "d", "e"];
arr.erase("c");
console.log(arr);
avatar
Tom Smykowski
2 декабря 2020 в 11:21
23

enter image description here

ОБНОВЛЕНИЕ 2021 ГОДА

Ваш вопрос касается того, как удалить определенный элемент из массива. Под конкретным элементом вы имеете в виду число, например. удалить число 5 из массива. Насколько я понимаю, вы ищете что-то вроде:

// PSEUDOCODE, SCROLL FOR COPY-PASTE CODE
[1,2,3,4,5,6,8,5].remove(5) // result: [1,2,3,4,6,8]

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

const input = [1,2,3,4,5,6,8,5];
const removeNumber = 5;
const result = input.filter(
    item => item != removeNumber
);

В приведенном выше примере используется функция array.prototype.filter. Он выполняет итерацию по всем элементам массива и возвращает только те, которые удовлетворяют стрелочной функции. В результате старый массив остается неизменным, а новый массив с именем result содержит все элементы, не равные пяти. Вы можете проверить это сами онлайн.

Вы можете представить себе, как array.prototype.filter вот так:

enter image description here

Соображения

Качество кода

Array.filter.prototype - далеко не самый читаемый метод удаления числа в этом случае. Он оставляет мало места для ошибок и использует основные функции JS.

Почему не array.prototype.map?

Array.prototype.map иногда рассматривается как альтернатива array.prototype.filter для этого варианта использования. Но его нельзя использовать. Причина в том, что array.prototype.filter концептуально используется для элементов фильтрации , которые удовлетворяют стрелочной функции (именно то, что нам нужно), в то время как array.prototype.map < используется для преобразования элементов. Поскольку мы не меняем элементы во время итерации по ним, лучше всего использовать функцию array.prototype.filter.

Поддержка

На сегодняшний день (2.12.2020) 97,05% интернет-пользователей браузеры поддерживают array.prototype.filter. Так что вообще безопасно использовать. Однако IE6 - 8 его не поддерживает. Так что, если ваш вариант использования требует поддержки этих браузеров, есть хороший полифилл , сделанный Крисом Фердинанти.

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

Array.prototype.filter отлично подходит для большинства случаев использования. Однако, если вы ищете некоторые улучшения производительности для расширенной обработки данных, вы можете изучить некоторые другие варианты, такие как использование pure for. Еще один отличный вариант - переосмыслить, действительно ли массив, который вы обрабатываете, должен быть настолько большим, что это может быть признаком того, что JavaScript должен получить уменьшенный массив для обработки из источника данных.

Dan
13 января 2021 в 01:55
0

Это не «лучший способ удалить определенный элемент из массива». Во-первых, .filter () удаляет ВСЕ вхождения removeNumber, а не конкретную запись. Итак, в вашем примере, если бы были другие элементы 5, они также были бы удалены, а это не то, что нужно. Во-вторых, и он тесно связан с первой точкой, он оценивает КАЖДЫЙ элемент в массиве, поэтому очень неэффективно, если мы уже знаем индекс. .filter () оценивает каждый элемент массива с этим условием.

avatar
Tijo John
25 ноября 2020 в 14:27
7
  • pop - удаляет с конца массива
  • shift - удаляет с начала массива
  • splice - удаляет из определенного массива индекс
  • фильтр - позволяет программно удалять элементы из массива
avatar
MSA
8 ноября 2020 в 13:50
6

Функция 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);
Peter Mortensen
2 января 2022 в 16:28
0

Можете ли вы дать ссылку на документацию для splice? (Но без «Изменить:», «Обновить:» и т.п. - ответ должен выглядеть так, как если бы он был написан сегодня.)

avatar
Coding
3 ноября 2020 в 01:21
10

Самый простой способ сделать это, вероятно, - использовать функцию фильтрации. Вот пример:

let array = ["hello", "world"]
let newarray = array.filter(item => item !== "hello");
console.log(newarray);
// ["world"]
avatar
Abdelrhman Arnos
14 августа 2020 в 19:11
10

В ES6 коллекция Set предоставляет метод delete для удаления определенного значения из массива, а затем преобразования коллекции Set в массив с помощью оператора распространения <497636311 >.

function deleteItem(list, val) {
    const set = new Set(list);
    set.delete(val);
    
    return [...set];
}

const letters = ['A', 'B', 'C', 'D', 'E'];
console.log(deleteItem(letters, 'C')); // ['A', 'B', 'D', 'E']
avatar
karthicvel
25 июля 2020 в 08:50
6

Использование .indexOf () и .splice () - Мутабельный шаблон

Здесь есть два сценария:

  1. нам известен индекс

const drinks = [ 'Tea', 'Coffee', 'Milk'];
const id = 1;
const removedDrink = drinks.splice(id,  1);
console.log(removedDrink)
  1. мы не знаем индекс, но знаем его значение.
    const drinks =  ['Tea','Coffee', 'Milk'];
    const id = drinks.indexOf('Coffee'); // 1
    const removedDrink = drinks.splice(id,  1);
    // ["Coffee"]
    console.log(removedDrink);
    // ["Tea", "Milk"]
    console.log(drinks);

Использование .filter () - неизменяемый шаблон

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

const drinks = ['Tea','Coffee', 'Milk'];
const id = 'Coffee';
const idx = drinks.indexOf(id);
const removedDrink = drinks[idx];
const filteredDrinks = drinks.filter((drink, index) => drink == removedDrink);

console.log("Filtered Drinks Array:"+ filteredDrinks);
console.log("Original Drinks Array:"+ drinks);
avatar
katma
2 июня 2020 в 16:18
23

Неизменяемый однострочный способ:

const newArr = targetArr.filter(e => e !== elementToDelete);
Daniel Waltrip
7 июля 2020 в 00:20
0

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

avatar
Ahmad
31 мая 2020 в 11:58
17

Неизменяемый способ удаления элемента из массива с помощью ES6 оператора распространения.

Допустим, вы хотите удалить 4.

let array = [1,2,3,4,5]
const index = array.indexOf(4)
let new_array = [...array.slice(0,index), ...array.slice(index+1, array.length)]
console.log(new_array)
=> [1, 2, 3, 5]
Daniel Waltrip
7 июля 2020 в 00:21
7

Важное уточнение для начинающих программистов: этот не удаляет целевой элемент из массива. Он создает полностью новый массив, который является копией исходного массива, за исключением удаленного целевого элемента. Слово «удалить» подразумевает, что мы что-то изменяем на месте, а не делаем измененную копию.

avatar
M. Twarog
2 апреля 2020 в 10:15
39

Обновление ES10

В этом сообщении обобщены общие подходы к удалению элементов из массива в ECMAScript 2019 (ES10).

1. Общие случаи

1.1. Удаление элемента массива по значению с помощью .splice()

| На месте : Да |
| Удаляет дубликаты : Да (цикл), Нет (indexOf) |
| По значению / индексу : По индексу |

Если вы знаете значение, которое хотите удалить из массива, вы можете использовать метод splice. Во-первых, вы должны определить индекс целевого элемента. Затем вы используете индекс в качестве начального элемента и удаляете только один элемент.

// With a 'for' loop
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for( let i = 0; i < arr.length; i++){
  if ( arr[i] === 5) {
    arr.splice(i, 1);
  }
} // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

// With the .indexOf() method
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf(5);
arr.splice(i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

1.2. Удаление элемента массива с помощью метода .filter()

| На месте : Нет |
| Удаляет дубликаты : Да |
| По значению / индексу : По значению |

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

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

1.3. Удаление элемента массива путем расширения Array.prototype

| На месте : Да / Нет (зависит от реализации) |
| Удаляет дубликаты : Да / Нет (зависит от реализации) |
| По значению / индексу : По индексу / по значению (зависит от реализации) |

Прототип Array можно расширить с помощью дополнительных методов. После этого такие методы будут доступны для использования в созданных массивах.

Примечание: Расширение прототипов объектов из стандартной библиотеки JavaScript (например, Array) некоторыми рассматривается как антипаттерн.

// In-place, removes all, by value implementation
Array.prototype.remove = function(item) {
    for (let i = 0; i < this.length; i++) {
        if (this[i] === item) {
            this.splice(i, 1);
        }
    }
}
const arr1 = [1,2,3,1];
arr1.remove(1) // arr1 equals [2,3]

// Non-stationary, removes first, by value implementation
Array.prototype.remove = function(item) {
    const arr = this.slice();
    for (let i = 0; i < this.length; i++) {
        if (arr[i] === item) {
            arr.splice(i, 1);
            return arr;
        }
    }
    return arr;
}
let arr2 = [1,2,3,1];
arr2 = arr2.remove(1) // arr2 equals [2,3,1]

1.4. Удаление элемента массива с помощью оператора delete

| На месте : Да |
| Удаляет дубликаты : Нет |
| По значению / индексу : По индексу |

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

const arr = [1, 2, 3, 4, 5, 6];
delete arr[4]; // Delete element with index 4
console.log( arr ); // [1, 2, 3, 4, undefined, 6]

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

1.5. Удаление элемента массива с помощью Object утилит (> = ES10)

| На месте : Нет |
| Удаляет дубликаты : Да |
| По значению / индексу : По значению |

В ES10 введен Object.fromEntries, который можно использовать для создания желаемого массива из любого объекта, подобного массиву, и фильтрации нежелательных элементов во время процесса.

const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values(Object.fromEntries(
  Object.entries(object)
  .filter(([ key, val ]) => val !== valueToRemove)
));
console.log(arr); // [1,2,4]

2. Особые случаи

2.1 Удаление элемента, если он находится в конце массива

2.1.1. Изменение массива length

| На месте : Да |
| Удаляет дубликаты : Нет |
| По значению / индексу : Н / Д |

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

const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Set length to remove element
console.log( arr ); // [1, 2, 3, 4, 5]
2.1.2. Используя .pop() метод

| На месте : Да |
| Удаляет дубликаты : Нет |
| По значению / индексу : Н / Д |

Метод pop удаляет последний элемент массива, возвращает этот элемент и обновляет свойство length. Метод pop изменяет массив, для которого он вызывается. Это означает, что в отличие от использования delete последний элемент полностью удаляется, а длина массива уменьшается.

const arr = [1, 2, 3, 4, 5, 6];
arr.pop(); // returns 6
console.log( arr ); // [1, 2, 3, 4, 5]

2.2. Удаление элемента, если он находится в начале массива

| На месте : Да |
| Удаляет дубликаты : Нет |
| По значению / индексу : Н / Д |

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

const arr = [1, 2, 3, 4];
arr.shift(); // returns 1
console.log( arr ); // [2, 3, 4]

2.3. Удаление элемента, если это единственный элемент в массиве

| На месте : Да |
| Удаляет дубликаты : N / A |
| По значению / индексу : Н / Д |

Самый быстрый способ - присвоить переменной массива пустой массив.

let arr = [1];
arr = []; //empty array

В качестве альтернативы можно использовать технику из 2.1.1, установив длину на 0.

avatar
ifelse.codes
31 января 2020 в 19:56
8

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

let data = [2, 5, 9, 2, 8, 5, 9, 5];
let target = 5;
data = data.filter(da => da !== target);

Примечание: - фильтр не меняет исходный массив; вместо этого он создает новый массив.

Поэтому повторное присвоение важно.

Это привело к другой проблеме. Вы не можете сделать переменную const. Это должно быть let или var.

avatar
Janardan Prajapati
28 января 2020 в 12:04
-2

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

Array.splice(index);
majid savalanpour
14 июня 2020 в 09:47
1

Ваш код удаляет все элементы после index. Для удаления 1 элемента с индексом 3 вы можете использовать Array.splice (index, 1).

Masoud Aghaei
2 февраля 2021 в 19:47
0

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

avatar
Ravi Makwana
9 января 2020 в 09:54
10

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

9 способов удаления элементов из массива JavaScript - плюс как безопасно очистить массивы JavaScript

Я предпочитаю использовать filter():

var filtered_arr = arr.filter(function(ele){
   return ele != value;
})
Daniel Waltrip
23 января 2020 в 02:09
0

Это не удаляет элемент из массива. Он создает новый массив с отфильтрованными элементами из исходного массива.

Ravi Makwana
23 января 2020 в 04:30
0

Да, он вернет новый отфильтрованный массив. позвольте мне обновить код

avatar
Arun s
27 декабря 2019 в 10:58
8

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

Рассмотрим массив длиной 5 со значениями 10, 20, 30, 40, 50 5, чтобы удалить значение , и значение > 30 из него.

var array = [10,20,30,40,50];
if (array.indexOf(30) > -1) {
   array.splice(array.indexOf(30), 1);
}
console.log(array); // [10,20,40,50]
avatar
Josh
19 декабря 2019 в 09:05
6

Удалить определенный элемент из массива можно в одной строке с параметром фильтра, и он поддерживается всеми браузерами: https://caniuse.com/#search=filter%20array

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

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

Peter Mortensen
8 марта 2020 в 17:25
0

Может быть, квалифицировать "все браузеры" ?

avatar
Kamil Kiełczewski
9 декабря 2019 в 16:04
54

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

Сегодня (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

avatar
Taylor Hawkes
6 ноября 2019 в 20:25
11

Чтобы найти и удалить конкретную строку из массива строк:

var colors = ["red","blue","car","green"];
var carIndex = colors.indexOf("car"); // Get "car" index
// Remove car from the colors array
colors.splice(carIndex, 1); // colors = ["red", "blue", "green"]

Источник: https://www.codegrepper.com/?search_term=remove+a+particular+element+from+array

avatar
Ajay Thakur
4 ноября 2019 в 05:10
8

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

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));
avatar
pritam
2 октября 2019 в 07:36
9

Большинство ответов здесь дают решение с использованием -

  1. indexOf and splice
  2. удалить
  3. фильтр
  4. обычный for loop

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

Обратите внимание на это решение -

  1. Это оставит дыры в данных (их можно удалить с помощью дополнительного фильтра)
  2. Это решение работает не только с примитивными значениями поиска, но и с объектами .

Уловка в том, чтобы -

  1. stringify набор входных данных и значение поиска
  2. заменить значение поиска во входном наборе данных пустой строкой
  3. вернуть split данные по разделителю ,.
    remove = (input, value) => {
        const stringVal = JSON.stringify(value);
        const result = JSON.stringify(input)

        return result.replace(stringVal, "").split(",");
    }

Здесь создается JSFiddle с тестами для объектов и чисел - https://jsfiddle.net/4t7zhkce/33/

Проверьте метод remove в скрипте.

Stefan Fabian
13 марта 2020 в 13:38
2

Итак, в чем именно преимущество этого метода? Я вижу, что это ужасно неэффективный и подверженный ошибкам метод выполнения простой задачи. Результат не анализируется снова, поэтому вместо типа ввода возвращается массив строк. Даже если бы он был проанализирован, на массивах объектов он удалял бы все члены-функции. Я не вижу веских причин, чтобы когда-либо делать что-то подобное, но, учитывая, что есть два человека, которые думали, что это хорошая идея, должно быть что-то мне не хватает.

mausworks
24 марта 2021 в 15:38
0

Я согласен с @StefanFabian, это ужасная идея. Что, если моя строка похожа на ",", которая заменит все запятые в строковой версии массива. Это ужасная идея, и вам не следует этого делать.

avatar
Yohannes Kristiawan
18 сентября 2019 в 10:57
3

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

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]

console.log(arr)

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

avatar
Dandev
17 сентября 2019 в 22:49
9

Вы можете создать индекс с примером всех методов доступа:

<div >
</div>

function getIndex($id){
  return (
    this.removeIndex($id)
    alert("This element was removed")
  )
}


function removeIndex(){
   const index = $id;
   this.accesor.id.splice(index.id) // You can use splice for slice index on
                                    // accessor id and return with message
}
<div>
    <fromList>
        <ul>
            {...this.array.map( accesors => {
                <li type="hidden"></li>
                <li>{...accesors}</li>
            })

            }
        </ul>
    </fromList>

    <form id="form" method="post">
        <input  id="{this.accesors.id}">
        <input type="submit" callbackforApplySend...getIndex({this.accesors.id}) name="sendendform" value="removeIndex" >
    </form>
</div>
avatar
Konrad Borowski
1 сентября 2019 в 09:42
6

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

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)
avatar
Kamil Kiełczewski
28 августа 2019 в 04:24
10

Решение не на месте

arr.slice(0,i).concat(arr.slice(i+1));

let arr = [10, 20, 30, 40, 50]

let i = 2 ; // position to remove (starting from 0)
let r = arr.slice(0,i).concat(arr.slice(i+1));

console.log(r);
Peter Mortensen
12 апреля 2020 в 01:20
0

В чем преимущество этого?

avatar
mekbib.awoke
23 августа 2019 в 12:20
3

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

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
Heretic Monkey
7 июля 2020 в 17:29
0

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

avatar
Atchutha rama reddy Karri
24 апреля 2019 в 04:32
12
[2,3,5].filter(i => ![5].includes(i))
avatar
codepleb
13 апреля 2019 в 08:51
15

Часто лучше просто создать новый массив с помощью функции filter.

let array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]

Это тоже улучшает читаемость ИМХО. Я не фанат slice, хотя знаю, что иногда стоит пойти на это.

MHOOS
20 июня 2019 в 09:47
0

@codepleb, не могли бы вы пояснить, почему вы предпочитаете фильтр, а не сращивание, и почему, по вашему мнению, фильтр более читабелен?

eightyfive
20 июня 2019 в 10:07
0

Хотя это не рекомендуется для длинных массивов.

codepleb
26 июня 2019 в 16:12
1

@MHOOS Slice имеет множество опций, и ИМХО они сбивают с толку. Вы можете, если хотите, передать начальную и конечную переменные, и, хотя начальный индекс включен, конечный индекс нет и т. Д. Труднее читать код, играющий со срезом. Если вы не используете это слишком часто, вы часто в конечном итоге проверяете документацию во время проверки, чтобы проверить, правильно ли что-то. Документы: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

avatar
Ashish
5 февраля 2019 в 05:34
11

Объединение, фильтрация и удаление для удаления элемента из массива

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

Метод splice ()

array.splice(index, 1);    

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

Итак, для одного элемента мы используем 1.

Метод удаления

delete array[index]

Метод filter ()

Если вы хотите удалить элемент, который повторяется в массиве, отфильтруйте массив:

removeAll = array.filter(e => e != elem);

где elem - это элемент, который вы хотите удалить из массива, а array - имя вашего массива.

avatar
alejoko
2 февраля 2019 в 14:41
2

Получите прибыль методом уменьшения следующим образом:

Случай а) если вам нужно удалить элемент по индексу:

function remove(arr, index) {
  return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}

случай б) если вам нужно удалить элемент по значению элемента (int):

function remove(arr, value) {
  return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}

Таким образом, мы можем вернуть новый массив (будет классным функциональным способом - намного лучше, чем использование push или splice) с удаленным элементом.

avatar
Ashish
28 января 2019 в 10:47
2

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

array.splice (start [, deleteCount [, item1 [, item2 [, ...]]]]]

начало

Индекс, с которого начинается изменение массива (с началом 0). Если больше, чем длина массива, фактический начальный индекс будет установлен на длину массива. Если отрицательное значение, оно будет начинать такое количество элементов с конца массива (с источником -1) и будет установлено в 0, если абсолютное значение больше, чем длина массива.

deleteCount Необязательно

Целое число, указывающее количество старых элементов массива, которые необходимо удалить.

Если deleteCount опущен или его значение больше, чем array.length - start (то есть, если оно больше, чем количество элементов, оставшихся в массиве, начиная с начала), то все элементы с начала через конец массива будет удален. Если deleteCount равно 0 или отрицательно, элементы не удаляются. В этом случае вы должны указать хотя бы один новый элемент (см. Ниже).

элемент1, элемент2, ... Необязательно

Элементы, добавляемые в массив, начиная с начального индекса. Если вы не укажете никаких элементов, splice () удалит только элементы из массива.

Для получения дополнительных ссылок просмотрите:

Array.prototype.splice ()

avatar
Chang
27 января 2019 в 16:55
5

Чтобы удалить конкретный элемент или последующие элементы, хорошо работает метод 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 из массива arr:

    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);
        }
    }
    
  4. Если вам известен только элемент, но не позиция (или индекс) элемента, и вы хотите удалить только самый первый совпадающий элемент с помощью метода 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]
    
Chang
27 января 2019 в 19:46
0

Примечание. Array.prototype.filter - это ECMAScript 5.1 (без IE8)

Little Brain
30 мая 2019 в 14:31
0

Для варианта 4 должен ли цикл быть «i <arr.length», а не «i <arr.length-1»?

avatar
Max Alexander Hanna
8 января 2019 в 14:34
61

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

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

ИЛИ

var array = ['1','2','3','4','5','6'];
var newArray = array.filter(function(item){ return item !== '3' });

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

jdavid05
3 апреля 2019 в 11:52
1

Это ответ, который сработал для меня при попытке обновить массив на основе переключения переключателя.

Fusion
6 апреля 2019 в 23:35
6

Остерегайтесь, если "stringToRemoveFromArray" не находится в вашем массиве, это приведет к удалению последнего элемента массива.

avatar
Shahriar Ahmad
31 декабря 2018 в 23:33
2
var arr =[1,2,3,4,5];

arr.splice(0,1)

console.log(arr)

Вывод [2, 3, 4, 5];

avatar
Sebastien H.
21 декабря 2018 в 15:10
5

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

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

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

[1,2,3].remove(2).sort()
avatar
AmerllicA
30 октября 2018 в 17:37
38

Я хочу ответить на основе 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]

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

avatar
Phil
12 сентября 2018 в 09:16
5

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

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

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

Phil
18 сентября 2019 в 05:18
1

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

avatar
Thilina Sampath
7 августа 2018 в 09:37
28

У вас есть от 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);

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

avatar
Zibri
22 июля 2018 в 04:42
2
    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)
    }

start и end могут быть отрицательными. В этом случае они считаются с конца массива.

Если указан только start, удаляется только один элемент.

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

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]

mekbib.awoke
23 августа 2019 в 12:23
0

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

avatar
Srikrushna
28 июня 2018 в 17:48
8

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

arrName.pop();

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

arrName.shift();

Удалить с середины

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

Example: arrName.splice(1, 1);

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

arrName.splice(-1);

Удалить, используя номер индекса массива

 delete arrName[1];
avatar
Aram Grigoryan
5 июня 2018 в 14:47
20

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

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

avatar
hygull
13 мая 2018 в 07:41
5

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

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

Обратите внимание на код ниже.

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

    if (index > -1) {
        // The splice() method is used to add/remove items(s) in the 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 beginning 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 (temporarily) 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
>
avatar
Flavio Copes
4 мая 2018 в 05:17
84

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

avatar
Steven Spungin
27 апреля 2018 в 00:07
8

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

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

var aSet = new Set();

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

aSet.delete(2);
ArtOfWarfare
4 октября 2021 в 02:21
0

Недооцененный ответ. Я собирался опубликовать это сам, но мне пришлось просмотреть существующие 132 ответа, чтобы узнать, сказал ли кто это уже. Если вы хотите удалить элементы из коллекции по значению, а не по позиции, то эта коллекция, вероятно, должна быть Set, а не Array.

avatar
Sanya Kravchuk
13 апреля 2018 в 11:31
-18
let array = [5,5,4,4,2,3,4]    
let newArray = array.join(',').replace('5','').split(',')

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

Masoud Aghaei
2 февраля 2021 в 19:41
0

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

Masoud Aghaei
2 февраля 2021 в 19:43
1

и что вы хотите сделать, если у нас есть 55 или что-то подобное в массиве, и мы хотим сохранить этот элемент?

Olavo Mello
3 декабря 2021 в 14:29
0

Именно Масаунд!

avatar
Gaurang Patel
9 марта 2018 в 05:40
6

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

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

avatar
Victor
8 марта 2018 в 18:35
8

Я только что создал полифилл на 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://coderhelper.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}]
avatar
Sujith S
15 февраля 2018 в 08:14
12

var array = [2, 5, 9];
var res = array.splice(array.findIndex(x => x==5), 1);

console.log(res)

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

developer.mozilla.org

pwilcox
29 июля 2018 в 14:44
2

Вам лучше убедиться, что вы знаете, что элемент находится в массиве, иначе findindex вернет -1 и, следовательно, удалит 9.

avatar
Adeel Imran
26 декабря 2017 в 19:32
33

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

avatar
mike rodent
24 ноября 2017 в 19:17
12

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

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

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

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

Итак, вы можете сделать:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =    function( acc, val, currIndex ){
    // We have not seen this value before: make a bucket... NB: although val's 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, , пустые места> еще 46…]

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

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

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

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

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

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

Звучит очень сложно и требует много времени ... но, очевидно, все зависит от обстоятельств и желаемого использования. Насколько я понимаю, все версии и контексты JavaScript работают только в одном потоке, и поток не «отпускает», поэтому может возникнуть ужасная перегрузка с помощью метода «грубой силы»: не столько из-за 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 ...)

avatar
cjjenkinson
18 сентября 2017 в 13:17
7

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

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;
}
avatar
hailong
30 июля 2017 в 22:55
11

Я публикую свой код, который удаляет элемент массива на месте, а также уменьшает длину массива.

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();
}
avatar
Partial Science
14 июля 2017 в 23:58
3

Ответов уже много, но поскольку никто еще не делал этого с одним лайнером, я решил, что покажу свой метод. Он использует тот факт, что функция 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);
Partial Science
20 июля 2017 в 19:33
1

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

CPHPython
19 февраля 2018 в 16:25
0

Интересный метод, вместо этого вы можете использовать символы Unicode для разделения (например, '\uD842'). Чтобы сделать его понятнее и короче для других, я бы просто добавил еще несколько строк к элементам массива (включая '4') и вынул первый фрагмент / пример (люди могли проголосовать против, потому что они даже не прочитали второй часть).

avatar
nsantana
12 мая 2017 в 02:00
18

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

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

/**
* 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]
Buffalo
24 июля 2017 в 11:59
0

Являются ли избыточные конструкции нормой для веб-разработчиков? У меня на работе есть кто-то, кто распыляет подобные вещи повсюду. Почему не просто return value != elem ?!

avatar
Alireza
10 мая 2017 в 09:39
47

Хорошо, например, у вас есть массив ниже:

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

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

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

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

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.

avatar
Aidan Hoolachan
8 мая 2017 в 17:58
13

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

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

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

Adriano Spadoni
25 июля 2017 в 08:56
1

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

Aidan Hoolachan
7 октября 2017 в 20:33
0

Спасибо, я добавил правку, чтобы уточнить, что valuesAreEqual можно заменить. Я согласен с тем, что подход JSON медленный, но он всегда будет работать. Определенно следует использовать лучшее сравнение, когда это возможно.

avatar
alejandro
5 мая 2017 в 01:32
12

Удалить элемент с индексом 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);
}
avatar
mpen
9 апреля 2017 в 20:09
9

Удалите одно значение, используя свободное сравнение, без изменения исходного массива, 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;
}
darmis
1 октября 2019 в 21:04
0

export const arrayRemove = (array, value) => [...array.filter(item => item !== value)]; Возможно, это могло быть проще.

mpen
1 октября 2019 в 23:05
0

@darmis Проще, да, но не то же самое. Также не думайте, что вам нужен [... - .filter уже должен вернуть копию.

darmis
2 октября 2019 в 07:21
0

@mpem Мое первое впечатление заключалось в том, что это мог бы быть более простой способ сделать это, но я согласен, что это не то же самое. И да, [... он не нужен в этом случае, так что даже проще :) Спасибо за это.

avatar
Ali Akram
20 марта 2017 в 11:16
8

Я выполнил функцию:

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

И использовал это так:

pop(valuetoremove, myarray);
Jamiec
28 марта 2017 в 14:06
1

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

avatar
Stelios Voskos
29 ноября 2016 в 20:54
8

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

avatar
Abdennour TOUMI
7 октября 2016 в 19:42
63

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)
Sebastian Simon
7 апреля 2020 в 18:30
2

Почему бы тогда просто не использовать filter? array.filter((_, index) => index !== removedIndex);.

Abdennour TOUMI
7 апреля 2020 в 20:37
0

@ user4642212 ты прав! также мне понравилось подчеркивание стиля Голанг

avatar
rajat44
4 октября 2016 в 08:07
97

Вы можете использовать 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"]
Claudio Holanda
16 марта 2017 в 15:27
7

Этот ответ хорош, потому что он создает копию исходного массива вместо непосредственного изменения оригинала.

Chang
27 января 2019 в 19:45
0

Примечание. Array.prototype.filter - это ECMAScript 5.1 (без IE8). для более конкретных решений: coderhelper.com/a/54390552/8958729

avatar
Shawn Deprey
12 августа 2016 в 17:59
9

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

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};
ankhzet
19 июня 2018 в 09:01
0

Кроме того, в стандарте ES нет removeAt. Я полагаю, это что-то только для IE? Об этом следует упомянуть в ответе.

avatar
Mahendra Kulkarni
28 июня 2016 в 09:13
7

Используйте 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>
codingsplash
6 августа 2016 в 09:56
6

В ОП конкретно сказано, что никаких фреймворков. Отсюда и голос против.

avatar
user4109793
21 мая 2016 в 04:08
2
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;
}
Peter Mortensen
12 апреля 2020 в 01:09
0

Объяснение было бы в порядке.

Heretic Monkey
7 июля 2020 в 17:26
0

@PeterMortensen Но вряд ли, так как OP был удален :).

avatar
Redu
7 мая 2016 в 20:10
13

Я думаю, что многие инструкции 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))

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

avatar
bjfletcher
25 апреля 2016 в 10:21
29

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

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

Затем:

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

Результат:

[1, 2, 4]

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

CodeOcelot
6 мая 2016 в 18:58
4

Обратите внимание, что .filter возвращает новый массив, что не совсем то же самое, что удаление элемента из того же массива. Преимущество этого подхода в том, что вы можете объединить методы массива в цепочку. например: [1,2,3].filter(n => n%2).map(n => n*n) === [ 1, 9 ]

dev1223
30 мая 2016 в 15:11
0

Отлично, если у меня 600k элементов в массиве и я хочу удалить первые 50k, вы можете себе представить эту медлительность? Это не решение, нужна функция, которая просто удаляет элементы и ничего не возвращает.

bjfletcher
31 мая 2016 в 22:04
0

@Seraph Для этого вы, вероятно, захотите использовать splice или slice.

dev1223
31 мая 2016 в 23:06
0

@bjfletcher Вот еще лучше, в процессе удаления просто выделите 50К элементов и куда-нибудь их закиньте. (с нарезкой 550К элементов, но не выкидывая их из окна).

runsun
27 августа 2016 в 01:55
0

Я бы предпочел ответ bjfletcher, который может быть таким коротким, как items= items.filter(x=>x!=3). Кроме того, в ОП не указывалось, что требуется большой набор данных.

avatar
Lars Gyrup Brink Nielsen
11 апреля 2016 в 05:47
9

Стандартный 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;
}
avatar
Kamuran Sönecek
29 января 2016 в 08:53
9

По моему решению вы можете удалить один или несколько элементов в массиве благодаря чистому 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]
avatar
MEC
10 января 2016 в 13:36
7

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

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
  }
}
avatar
Eugene Tiurin
15 ноября 2015 в 11:09
5

Следующий метод удалит все записи заданного значения из массива без создания нового массива и только с одной итерацией, которая является сверхбыстрой . И это работает в древнем браузере 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>
Ankur Loriya
17 декабря 2015 в 14:22
0

Что означает этот код, я не мог понять.

Eugene Tiurin
25 декабря 2015 в 19:16
0

@AnkurLoriya Этот код удаляет все нули из данного массива

avatar
Chun Yang
25 августа 2015 в 19:34
63
some-non-descript-user
24 сентября 2015 в 21:01
3

Это не основной JS, как запрашивал OP, не так ли?

Chun Yang
1 октября 2015 в 03:38
13

@ some-non-descript-user Вы правы. Но многие пользователи, подобные мне, приходят сюда в поисках общего ответа не только для OP.

int-i
8 июня 2018 в 21:48
0

@ChunYang Вы абсолютно правы. Я уже использую lodash, почему бы просто не использовать его, если это экономит время.

avatar
flurdy
9 апреля 2015 в 10:00
39

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

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

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
joeytwiddle
29 июля 2016 в 08:50
0

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

avatar
Ryan
7 января 2015 в 19:53
5

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

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

array.key = null;
avatar
Matt Brock
26 ноября 2014 в 19:39
4

Если вам необходимо поддерживать старые версии 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

sampathsris
18 мая 2015 в 03:03
3

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

Matt Brock
18 мая 2015 в 13:38
1

К сожалению, Интернет (и Stack Overflow) заполнен наполовину реализованными, частично правильными версиями методов массива ES5. В этом вся суть привязки к полифиллу. Для действительно полного воспроизведения всех правильного поведения недостаточно обобщать «основные части». Вы также должны выполнить все граничные условия. Воспроизведение их содержимого полностью выходит за рамки Stack Overflow. Stack Overflow - это не GitHub.

avatar
Nejc Lepen
22 октября 2014 в 14:10
9

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

function removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}
ylerjen
22 октября 2014 в 14:43
14

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

avatar
Do Hoa Vinh
17 сентября 2014 в 10:14
10

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

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

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

CSᵠ
12 декабря 2014 в 18:51
5

но OP сказал: "старый добрый JavaScript - никакие фреймворки не разрешены"

Scott 混合理论
17 июня 2016 в 09:38
0

для Chrome 50.0, A.splice (-1, 1); удалит последний в A.

avatar
penguin
25 июня 2014 в 23:57
5
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;

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

Christophe Roussy
25 сентября 2014 в 14:40
1

Это очень неэффективно, когда массив большой.

avatar
vatsal
30 мая 2014 в 09:57
95

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

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

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
EigenFool
16 апреля 2020 в 08:56
0

хотя элегантный и лаконичный, OP четко упомянул только основной JS

avatar
amd
2 мая 2014 в 12:00
120

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

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

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

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

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

Определение

var helper = {
 // Remove and return the first occurrence

 remove: 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

 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;
 },
};
Masoud Aghaei
2 февраля 2021 в 19:55
0

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

avatar
mboeckle
20 марта 2014 в 09:56
8

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

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});
Hontoni
30 апреля 2014 в 17:05
0

Удаляет последний элемент, если искомый элемент не найден

mboeckle
1 мая 2014 в 17:00
1

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

Dughall
18 апреля 2016 в 15:31
4

Это jQuery, а не основной JavaScript.

Jignesh Vagh
14 июля 2017 в 14:22
0

любым другим способом для некоторого повторяющегося значения максимум 5 раз, затем создать новый массив и удалить это значение из массива? У МЕНЯ ЕСТЬ ВИД МАССЫ: ["info.specificAllergy", "info.specificAllergy", "info.specificAllergy", "info.specificAllergy", "info.specificAllergy", "info.existingMedicalCondition", "info.existingMedicalCondition", "info.existingMedicalCondition" "info.existingMedicalCondition", "info.existingMedicalCondition", "info.existingMedicalCondition"]

avatar
Salvador Dali
10 февраля 2014 в 22:06
106

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

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.

avatar
wharding28
3 февраля 2014 в 15:41
23

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

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

Peter Mortensen
1 сентября 2019 в 22:14
0

Но почему возврат посередине? По сути, это оператор goto.

avatar
Nigel Sheridan-Smith
30 января 2014 в 04:27
12

В CoffeeScript:

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
avatar
Ardi
28 января 2014 в 14:44
20

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

avatar
sofiax
16 января 2014 в 11:27
42

Я новичок в 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");

Вывод - как и ожидалось. ["элемент1", "элемент1"]

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

Zag
24 мая 2019 в 18:22
2

Это будет иметь ужасное поведение, если ваш массив действительно длинный и в нем есть несколько экземпляров элемента. Метод indexOf массива будет запускаться каждый раз с самого начала, поэтому ваша стоимость будет O (n ^ 2).

Peter Mortensen
1 сентября 2019 в 22:11
0

@Zag: У него есть имя: Алгоритм Шлемиэля Художника

avatar
ujeenator
19 декабря 2013 в 19:54
1799

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

  • Делайте это просто, интуитивно понятно и ясно (бритва Оккама)
  • Сделать неизменным (исходный массив останется без изменений)
  • Используйте стандартные функции JavaScript, если ваш браузер их не поддерживает - используйте полифил

В этом примере кода я использую функцию "array.filter (...)" для удаления нежелательных элементов из массива. Эта функция не изменяет исходный массив, а создает новый. Если ваш браузер не поддерживает эту функцию (например, Internet Explorer до версии 9 или Firefox до версии 1.5), рассмотрите возможность использования полифила фильтров из Mozilla .

Удаление элемента (код ECMA-262 Edition 5, также известный как JavaScript старого стиля)

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 ]

Удаление элемента (код ECMAScript 6)

let value = 3

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

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

ВАЖНО ECMAScript 6 "() => {}" синтаксис стрелочной функции вообще не поддерживается в Internet Explorer, Chrome до версии 45, Firefox до версии 22 и Safari до версии 10. Чтобы использовать синтаксис ECMAScript 6 в старых браузерах, вы можете использовать BabelJS.


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

Дополнительным преимуществом этого метода является то, что вы можете удалить несколько элементов

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 (...) вообще не поддерживается в Internet Explorer, Chrome до 47 версии, Firefox до 43 версии, Safari до 9 версии и Edge до 14 версии. Итак, вот полифилл из Mozilla .

Удаление нескольких элементов (возможно, в будущем)

Если предложение «Синтаксис этой привязки» когда-либо будет принято, вы сможете сделать следующее:

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

Попробуйте сами в BabelJS :)

Ссылка

Ranjeet Thorat
11 января 2021 в 09:51
0

что, если содержимое массива - это объекты и вложенные объекты

avatar
NullPointer
8 октября 2013 в 10:09
18

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

var index = jQuery.inArray(val, arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}
avatar
Don Vincent Preziosi
26 сентября 2013 в 00:12
27
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');
avatar
slosd
19 сентября 2013 в 01:53
146

Нет необходимости использовать 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
avatar
Roger
30 августа 2013 в 19:07
100

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

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

avatar
Jeff Noel
12 августа 2013 в 17:56
31

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

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);
}
console.log(myArray);

Живая демонстрация

avatar
Ben Lesh
10 августа 2013 в 19:21
348

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

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

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

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

avatar
Enrico
7 августа 2013 в 12:57
18

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

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 и Internet Explorer 8 (и более поздними версиями)):

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

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

my_array.splice(index, 1);
avatar
yckart
13 мая 2013 в 12:22
14

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

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}
Renze de Waal
23 января 2014 в 17:34
0

destroy ([1,2,3,3,3,4,5], 3) возвращает [1,2,3,4,5]]. i не должен увеличиваться при соединении массива.

avatar
Ekramul Hoque
2 апреля 2013 в 10:56
76

Посмотрите этот код. Он работает во всех основных браузерах .

remove_item = function(arr, value) {
 var b = '';
 for (b in arr) {
  if (arr[b] === value) {
   arr.splice(b, 1);
   break;
  }
 }
 return arr;
};

var array = [1,3,5,6,5,9,5,3,55]
var res = remove_item(array,5);
console.log(res)
yckart
30 декабря 2014 в 16:13
4

@RolandIllig За исключением использования цикла for in и того факта, что сценарий можно было остановить раньше, вернув результат из цикла напрямую. Прогнозы разумные;)

Beejor
21 августа 2016 в 23:20
1

Я также должен повторить комментарий yckart о том, что for( i = 0; i < arr.length; i++ ) будет лучшим подходом, поскольку он сохраняет точные индексы по сравнению с тем порядком, в котором браузер решает хранить элементы (с for in). Это также позволяет получить индекс массива значения, если он вам нужен.

avatar
zykadelic
13 марта 2013 в 09:28
38

Обновление: Этот метод рекомендуется только в том случае, если вы не можете использовать 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]
avatar
Saša
21 декабря 2012 в 11:32
246

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

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

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

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

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

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

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

avatar
Loupax
18 октября 2012 в 10:13
87

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

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

avatar
xavierm02
23 апреля 2011 в 22:32
556

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

Если вы действительно хотите пустой слот:

array[index] = undefined;

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

//To keep the original:
//oldArray = [...array];

//This modifies the 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, если не найден.

Teddy
25 июля 2020 в 10:55
0

Забавно, что splice возвращает другой массив, построенный из удаленных элементов. Я написал что-то, что предполагало, что splice вернет недавно измененный список (например, что будут делать неизменяемые коллекции). Таким образом, в этом конкретном случае только одного элемента в списке, и этот элемент удаляется, возвращенный список в точности идентичен исходному после объединения этого одного элемента. Итак, мое приложение зациклилось.

avatar
Peter Olson
23 апреля 2011 в 22:20
1509

Я не знаю, как вы ожидаете, что 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];
avatar
Zirak
23 апреля 2011 в 22:20
199
Array.prototype.remove_by_value = 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)
].remove_by_value(3);

Array.prototype.remove_by_value = 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.remove_by_value('hello')

console.log(rooms)
snarf
14 сентября 2020 в 22:34
2

Многие не одобряют модификацию прототипов, которые вам не принадлежат.