У мене є масив чисел і я використовую .push()метод для додавання до нього елементів.

Чи є простий спосіб видалити певний елемент із масиву?

Я шукаю еквівалент чогось типу:

array.remove(number);

Я повинен використовувати основний JavaScript. Кадри не дозволені.

Знайдіть indexелемент масиву, який ви хочете видалити indexOf, та видаліть цей індекс за допомогою splice.

Метод splice () змінює вміст масиву, видаляючи існуючі елементи та / або додаючи нові елементи.

const array = [2, 5, 9];

console.log(array);

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

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

Другий параметр splice- кількість елементів, які потрібно видалити. Зверніть увагу, що spliceмодифікує масив на місці і повертає новий масив, що містить елементи, які були видалені.

З метою повноти ось функції. Перша функція видаляє лише один випадок (тобто видалення першого збігу 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;
}

Я не знаю, як ви розраховуєте 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];

Відредаговано 2016 жовтня

• Робіть це просто, інтуїтивно та зрозуміло ( бритви Оккама )
• Зробити це незмінним (оригінальний масив залишається незмінним)
• Робіть це за допомогою стандартних функцій JavaScript, якщо ваш браузер їх не підтримує - використовуйте polyfill

У цьому прикладі коду я використовую функцію "array.filter (...)" для видалення небажаних елементів з масиву. Ця функція не змінює вихідний масив і створює новий. Якщо ваш веб-переглядач не підтримує цю функцію (наприклад, Internet Explorer перед версією 9, або Firefox до версії 1.5), спробуйте скористатися поліфільтруванням від Mozilla .

Видалення елемента (код ECMA-262 видання 5, також aka oldstyle 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 :)

Довідково

• Array.prototype.includes
• Функціональний склад

Це залежить від того, хочете ви зберегти порожнє місце чи ні.

Якщо ви хочете порожній слот, видалення добре:

delete array[index];

Якщо цього немає, слід скористатися методом зрощення :

array.splice(index, 1);

І якщо вам потрібне значення цього елемента, ви можете просто зберігати повернутий елемент масиву:

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

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

І якщо ви не знаєте індексу товару, ви можете використовувати його array.indexOf(item)для отримання (в, if()щоб отримати один предмет або в а, while()щоб отримати їх усі). array.indexOf(item)повертає або індекс, або -1, якщо його не знайдено. 

У друга виникли проблеми в Internet Explorer 8 і показав мені, що він робив. Я сказав йому, що це неправильно, і він сказав мені, що отримав відповідь тут. Поточна відповідь не буде працювати у всіх веб-переглядачах (наприклад, Internet Explorer 8), і вона видалить лише перший елемент цього пункту.

Видаліть ВСІ екземпляри з масиву

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

Він проходить через масив назад (оскільки показники та довжина змінюватимуться в міру видалення елементів) та вилучають елемент, якщо він знайдений. Він працює у всіх браузерах.

Є два основні підходи:

1. сплайс () :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циклів, якщо це можливо. Таким чином код був би більш надійним і менш схильним до проблем з індексами.

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)

Не потрібно використовувати indexOfабо splice. Однак вона працює краще, якщо ви хочете видалити лише одне виникнення елемента.

Пошук і переміщення (переміщення):

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

Використання indexOfта splice(indexof):

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

Використовуйте лише splice(зрощення):

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

Часи запуску на nodejs для масиву з 1000 елементами (в середньому понад 10000 запусків):

indexof приблизно в 10 разів повільніше, ніж переміщення . Навіть якщо вдосконалено, видаливши виклик indexOfв сплайс, він виконує набагато гірше, ніж переміщення .

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms

Це забезпечує присудок замість значення.

ПРИМІТКА: він оновить заданий масив і поверне постраждалі рядки.

Використання

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

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

Визначення

var helper = {

    // Remove and return the first occurrence

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences

    remove: function(array, predicate) {
        var removed = [];

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

            if (predicate(array[i])) {
                removed.push(array.splice(i, 1));
                continue;
            }
            i++;
        }
        return removed;
    }
};

Ви можете легко це зробити методом фільтра :

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.

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

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

Underscore.js можна використовувати для вирішення проблем із кількома браузерами. Він використовує вбудовані методи браузера, якщо вони є. Якщо вони відсутні, як у випадку з більш старими версіями Internet Explorer, він використовує свої власні методи.

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

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]

Можна використовувати 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"]

Якщо ви хочете, щоб новий масив із видаленими позиціями був видалений, ви завжди можете видалити конкретний елемент і відфільтрувати масив. Може знадобитися розширення об’єкта масиву для браузерів, які не реалізують метод фільтра, але в перспективі це простіше, оскільки все, що ви робите, це:

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

Перевірте цей код. Він працює у кожному великому браузері .

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

Викличте цю функцію

remove_item(array,value);

Ви можете використовувати lodash _.pull (мутаційний масив), _.pullAt (мутаційний масив) або _.without (не мутує масив),

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

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)

Видалення конкретного елемента / рядка з масиву можна виконати в одній вкладиші:

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

де:

theArray : масив, з якого потрібно видалити щось конкретне

stringToRemoveFromArray : рядок, який потрібно видалити, і 1 - кількість елементів, які ви хочете видалити.

ПРИМІТКА : Якщо "stringToRemoveFromArray" не знаходиться у вашому масиві, це видалить останній елемент масиву.

Завжди корисною практикою перевірити, чи існує елемент у вашому масиві, перш ніж видаляти його.

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

Якщо у вас є доступ до новіших версій Ecmascript на комп'ютерах вашого клієнта (ПОПЕРЕДЖЕННЯ, можливо, не працює на старих станціях):

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

Де '3' - це значення, яке ви хочете видалити з масиву. Потім масив стане:['1','2','4','5','6']

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

Добре, наприклад, у вас є масив нижче:

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 _.pull, _.pullAt або _.without.

Я досить новачок у JavaScript і мені потрібна ця функціональність. Я просто написав це:

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

Тоді, коли я хочу його використовувати:

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

Вихід - Як очікувалося. ["item1", "item1"]

У вас можуть бути інші потреби, ніж у мене, тому ви можете легко модифікувати це відповідно до них. Я сподіваюся, що це комусь допоможе.

Якщо у масиві є складні об'єкти, ви можете використовувати фільтри? У ситуаціях, коли $ .inArray або array.splice використовувати не так просто. Особливо, якщо об'єкти, можливо, дрібні в масиві.

Наприклад, якщо у вас є об'єкт із полем Id і ви хочете, щоб об’єкт був видалений з масиву:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});

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

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

Оновлення: Цей метод рекомендується використовувати лише в тому випадку, якщо ви не можете використовувати 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]

Продуктивність

Сьогодні (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,5x-6x швидші, ніж незмінні
• для невеликих таблиць на Safari напрочуд змінне рішення (C) повільніше, ніж незмінний розчин (G)

Деталі

У тестах я видаляю середній елемент з масиву різними способами. Рішення A, C є на місці. В, D, Е, F, G, H розчини є незмінними.

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

У Chrome array.splice(C) - це найшвидше рішення на місці. array.filter(D) , є самим незаперечним рішенням. Найповільніший - array.slice(F). Ви можете виконати тест на своїй машині тут .

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

У Chrome array.splice(C) - це найшвидший на місці рішення ( delete(C) схожий швидко - але він залишив порожній проріз у масиві (тому він не виконує "повне видалення")). array.slice-splice(Н) є самим незаперечним рішенням. Найповільніший - 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

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

Більш сучасний підхід ECMAScript 2015 (раніше відомий як Harmony або ES 6). Подано:

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

Тоді:

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

Вихід:

[1, 2, 4]

Ви можете використовувати Babel та послугу поліфункції, щоб переконатися, що це добре підтримується у веб-переглядачах.

У вас в масиві від 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);

Включає підтримуваний браузер посилання .

Я знаю, що відповідей вже багато, але, здається, багато з них ускладнюють проблему. Ось простий, рекурсивний спосіб видалення всіх екземплярів ключа - виклику самостійно, поки індекс не знайдеться. Так, він працює лише в браузерах 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);
}

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

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

Демонстраційна демонстрація