Mam tablicę liczb i używam metody .push(), aby dodać do niego elementy.

Czy istnieje prosty sposób na usunięcie określonego elementu z tablicy?

Odpowiednik czegoś podobnego do -

array.remove(number);

Muszę użyć rdzeń javascript - ramy nie są dozwolone.

9110
Walker 24 kwiecień 2011, 02:17

26 odpowiedzi

Wiem, że już jest wiele odpowiedzi, ale wielu z nich wydaje się komplikować problem. Oto prosty, rekurencyjny sposób usunięcia wszystkich wystąpień klucza - wzywa do siebie, dopóki indeks nie zostanie znaleziony. Tak, działa tylko w przeglądarkach z {x0}}, ale jest proste i może być łatwo polowane.

funkcja samodzielna

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

Metoda prototypu

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}
18
wharding28 19 luty 2014, 22:20

Na podstawie wszystkich odpowiedzi, które były głównie poprawne i biorąc pod uwagę najlepsze praktyki sugerowane (zwłaszcza nie korzystanie z array.prototypu bezpośrednio), wymyśliłem poniższy kod:

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

Przegląd powyższej funkcji, pomimo faktu, że działa dobrze, zdałem sobie sprawę, że może być pewna poprawa wydajności. Również za pomocą ES6 zamiast ES5 jest znacznie lepszym podejściem. W tym celu jest to ulepszony kod:

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

Jak używać:

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)

Obecnie piszę piszę na blogu, w którym mam benchmarked kilka rozwiązań dla tablicy bez problemu i porównał czas, jaki zajmuje bieg. Zaktualizuję tę odpowiedź z linkiem, gdy skończę ten post. Aby powiadomić Cię, porównałem powyższe przeciwko Lodashowi bez i na wypadek, gdyby przeglądarka obsługuje Map, bije Lodash! Zauważ, że nie używam Array.prototype.indexOf lub Array.prototype.includes jako Array.prototype.includes jako owijanie egzlcudevalues w {x3}} lub Object sprawia, że zapytanie szybciej!

18
Ardi 19 listopad 2018, 23:02

Nie wiem, jak się spodziewasz array.remove(int), aby zachowywać się. Istnieją trzy możliwości, jakie mogę wymyślić, że możesz chcieć.

Aby usunąć element tablicy w indeksie i:

array.splice(i, 1);

Jeśli chcesz usunąć każdy element za pomocą wartości {x0}} z tablicy:

for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
        array.splice(i, 1);
    }
}

Jeśli chcesz, aby element w indeksie i nie istnieje, ale nie chcesz, aby indeksy innych elementów do zmiany:

delete array[i];
1422
Lioness100 24 wrzesień 2020, 14:33

To zależy od tego, czy chcesz zachować puste miejsce, czy nie.

Jeśli chcesz pusty gniazdo, usuń delikatnie:

delete array[index];

Jeśli nie, powinieneś użyć Splice Metoda:

array.splice(index, 1);

A jeśli potrzebujesz wartości tego elementu, możesz wystomować element zwróconych array:

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

W przypadku, gdy chcesz to zrobić w jakimś kolejności, możesz użyć array.pop() dla ostatniego lub array.shift() dla pierwszego (a oba zwrócili również wartość przedmiotu).

A jeśli nie znasz indeksu elementu, możesz użyć array.indexOf(item), aby go zdobyć (w if(), aby uzyskać jeden element lub w {x2}}, aby uzyskać wszystkie) . array.indexOf(item) zwraca indeks lub -1, jeśli nie znaleziono.

513
Andrew 16 czerwiec 2020, 04:51

Przyjaciel miał problemy w Internet Explorer 8 i pokazał mi to, co zrobił. Powiedziałem mu, że to się nie tak, a on mi powiedział, że ma tutaj odpowiedź. Aktualna najlepsza odpowiedź nie będzie działać we wszystkich przeglądarkach (na przykład Internet Explorer 8), a także usunie tylko pierwsze wystąpienie elementu.

Usuń wszystkie instancje z tablicy

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

Pętle przez tablicę do tyłu (ponieważ wskaźniki i długość zmieni się, ponieważ elementy są usuwane) i usuwa element, jeśli zostanie znaleziony. Działa we wszystkich przeglądarkach.

304
John 7 wrzesień 2020, 11:01

Istnieją dwa główne podejścia:

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

  2. Usuń : delete anArray[index];

Bądź ostrożny, gdy używasz usuwania dla tablicy. Dobrze jest usunąć atrybuty obiektów, ale nie tak dobre dla tablic. Lepiej jest użyć splice dla tablic.

Należy pamiętać, że kiedy używasz delete dla tablicy, możesz uzyskać złe wyniki dla anArray.length. Innymi słowy, delete usunęła element, ale nie zaktualizowałoby wartości nieruchomości.

Możesz również spodziewać się otworów w numerach indeksów po użyciu DELETE, np. Możesz skończyć z posiadaniem indeksów 1, 3, 4, 8, 9 i 11 i długości, ponieważ przed użyciem usunięcie. W takim przypadku all indeksed for pętle awaryjne, ponieważ indeksy nie są już sekwencyjne.

Jeśli z jakiegoś powodu zostaniesz zmuszony do użycia delete > for each pętle, gdy potrzebujesz pętli przez tablice. W rzeczywistości zawsze należy unikać za pomocą indeksowanych pętli for, jeśli to możliwe. W ten sposób kod byłby bardziej wytrzymały i mniej podatny na problemy z indeksami.

201
Ammar 26 styczeń 2021, 08:49
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)
172
Lioness100 24 wrzesień 2020, 14:35

Nie ma potrzeby używania indexOf lub splice. Jednak działa lepiej, jeśli chcesz usunąć tylko jedno wystąpienie elementu.

Znajdź i ruszaj (ruch):

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

Użyj indexOf i splice (indexof):

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

Używaj tylko splice (Splice):

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

Czas pracy w NodeJs do tablicy z 1000 elementów (średnio ponad 10000 biegów):

indexof jest około 10x wolniejszy niż przenieś . Nawet jeśli jest to ulepszone, usuwanie połączenia do {X0}} w Splice wykonuje znacznie gorsze niż przenieś .

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
125
slosd 11 wrzesień 2015, 12:47

Zapewnia to predykat zamiast wartości.

Uwaga: Zaktualizuje podaną tablicę i zwróci rzędami dotkniętymi.

Stosowanie

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

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

Definicja

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;
    }
};
94
amd 3 luty 2021, 13:45

Możesz to zrobić łatwo z filtra Metoda:

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

Usuwa to wszystkie elementy z tablicy, a także działa szybciej niż kombinacja slice i indexOf.

88
Masoud Aghaei 31 styczeń 2021, 11:47

John Resig Wysłany jest dobra realizacja:

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

Jeśli nie chcesz rozszerzyć globalnego obiektu, możesz zrobić coś w rodzaju następującego, zamiast tego:

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

Ale głównym powodem, dla którego opublikuję, jest ostrzeganie użytkowników przed alternatywnym wdrożeniem sugerowanym w uwagach na temat tej strony (14 grudnia 2007 r.):

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

Na początku działa dobrze, ale dzięki bolesnym procesie odkryłem, że nie udaje się, że próbowałem usunąć drugi do ostatniego elementu w tablicy. Na przykład, jeśli masz tablicę 10-elementową i spróbujesz usunąć z tym elementem 9.

myArray.remove(8);

Skończysz z 8-elementową tablicą. Nie wiem dlaczego, ale potwierdziłem oryginalną implementację Johna, nie ma tego problemu.

85
magiccrafter 16 luty 2015, 12:51

UnderCorore.js może być używany do rozwiązywania problemów z wieloma przeglądarem. Wykorzystuje metody przeglądarki w budowaniu, jeśli są obecne. Jeśli są nieobecne w przypadku starszych wersji programu Internet Explorer wykorzystuje własne metody niestandardowe.

Prosty przykład usuwania elementów z tablicy (z witryny):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
83
Peter Mortensen 21 maj 2017, 11:29

Możesz użyć ES6. Na przykład, aby usunąć wartość "3" w tym przypadku:

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

Wynik :

["1", "2", "4", "5", "6"]
82
darmis 1 październik 2019, 22:13

Jeśli chcesz, usunięto nową tablicę z usuniętymi pozycjami, zawsze możesz usunąć określony element i odfiltruj tablicę. Może potrzebować przedłużenia obiekt tablicy dla przeglądarek, które nie wdrażają metody filtra , ale w dłuższej perspektywie jest łatwiej, ponieważ wszystko, co robisz, to:

var my_array = [1, 2, 3, 4, 5, 6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));

Powinien wyświetlić [1, 2, 3, 4, 6].

72
Peter Mortensen 1 wrzesień 2019, 20:30

Sprawdź ten kod. Działa w każdej głównej przeglądarce .

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

Zadzwoń do tej funkcji

remove_item(array,value);
65
Masoud Aghaei 2 luty 2021, 23:45

ES6 & AMP; Bez mutacji: (Październik 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)
57
dipenparmar12 10 luty 2020, 07:37

Możesz użyć Lodash _.pull (Mutate Array), _. Pultat (Mutate Array) lub _.without (czyta tablicy),

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']
55
Chun Yang 25 sierpień 2015, 21:19

Wyjmowanie określonego elementu / łańcucha z tablicy można wykonać w jednym wykładzinie:

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

Gdzie:

thearray : tablica, którą chcesz usunąć coś konkretnego

stringToremoveFromarray : Ciąg, który chcesz usunięty, a 1 jest ilością elementów, które chcesz usunąć.

Uwaga : Jeśli "StringToremoveFromarray" nie znajduje się w tablicy, to usunie ostatni element tablicy.

To zawsze dobre praktyki, aby sprawdzić, czy element istnieje w twojej tablicy, przed wyjmowaniem.

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

Jeśli masz dostęp do nowszych wersji ECMASCRESS na komputerach klienta (ostrzeżenie, może nie działać na starszych stacjach):

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

Gdzie "3" to wartość, którą chcesz usunięty z tablicy. Tablica stała się wtedy: ['1','2','4','5','6']

54
Max Alexander Hanna 29 styczeń 2021, 21:55

Wydajność

Dzisiaj (2019-12-09) przeprowadzam testy wydajności na MacOS V10.13.6 (High Sierra) dla wybranych rozwiązań. Pokażę delete (a), ale nie używam go w porównaniu z innymi metodami, ponieważ pozostawiono pustą przestrzeń w tablicy.

Wnioski

  • Najszybszym rozwiązaniem jest array.splice (c) (z wyjątkiem safari dla małych tablic, gdzie ma drugi raz)
  • Dla dużych tablic, array.slice+splice (h) jest najszybszym niezmiennym rozwiązaniem dla Firefoksa i Safari; Array.from (b) jest najszybszy w chromie
  • Zmienne rozwiązania są zwykle 1,5x-6x szybciej niż niezmienne
  • W przypadku małych tabel na Safari, zaskakująco, które jest wolniejsze niż niezmienne roztwór (G)

Detale

W testach usunąłem środkowy element z tablicy na różne sposoby. Rozwiązania A, C są na miejscu. Rozwiązania B, D, E, F, G, H są niezmienne.

Wyniki dla tablicy z 10 elementami

Enter image description here

W chromie array.splice (c) jest najszybszym rozwiązaniem w miejscu. array.filter (D) jest najszybszym niezmiennym rozwiązaniem. Najwolniejsze jest array.slice (f). Możesz wykonać test na swoim komputerze Oto.

Wyniki dla tablicy z elementami 1.000.000

Enter image description here

W chromie array.splice (c) jest najszybszym roztworem w miejscu (delete (c) jest podobny szybki - ale pozostawił pustą szczelinę w tablicy (dlatego nie działa "pełny usunąć')). array.slice-splice (h) jest najszybszym niezmiennym rozwiązaniem. Najwolniejszy jest array.filter (d i e). Możesz wykonać test na swoim komputerze Oto.

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.

Porównanie przeglądarek: Chrome V78.0.0, Safari V13.0.4 i Firefox V71.0.0

Enter image description here

46
Ammar 26 styczeń 2021, 09:12

OK, Na przykład masz tablicę poniżej:

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

Chcemy usunąć numer 4. Możesz po prostu użyć poniższego kodu:

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

Jeśli ponowne wykorzystujesz tę funkcję, napiszesz funkcję wielokrotnego użytku, który zostanie podłączony do funkcji tablicy , jak poniżej:

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

Ale a więc, jeśli masz tablicę poniżej kilku [5] s w tablicy?

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

Potrzebujemy pętli, aby sprawdzić je wszystkie, ale łatwiejsze i bardziej wydajny sposób używa wbudowanych funkcji JavaScript, więc piszemy funkcję, która używa filtra jak poniżej:

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]

Istnieją również biblioteki osób trzecich, które pomagają ci to zrobić, jak Lodash lub podkreślenie. Aby uzyskać więcej informacji, spójrz na Lodash _.Pull, _.pullat lub _.without.

42
Peter Mortensen 1 wrzesień 2019, 22:33

Jeśli masz złożone obiekty w tablicy, możesz użyć filtrów? W sytuacjach, w których $ .Inarray lub array.splice nie jest tak łatwy w użyciu. Zwłaszcza jeśli obiekty są być może płytkie w tablicy.

Na przykład. Jeśli masz obiekt z polem ID i chcesz obiekt usunięty z tablicy:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
34
Anik Islam Abhi 10 listopad 2015, 04:20

Chcę odpowiedzieć na podstawie ECMAScript 6. Załóżmy, masz tablicę jak poniżej:

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

Jeśli chcesz usunąć w specjalnym indeksie, takim jak 2, napisz poniżej kod:

arr.splice(2, 1); //=> arr became [1,2,4]

Ale jeśli chcesz usunąć specjalny przedmiot, taki jak 3 i nie znasz jego indeksu, lubisz poniżej:

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

WSKAZÓWKA : Użyj funkcji strzałek do filtrowania wywołuwania wygody, chyba że otrzymasz pustą tablicę.

34
Peter Mortensen 1 wrzesień 2019, 22:59

Aktualizacja: Ta metoda jest zalecana tylko wtedy, gdy nie możesz użyć ECMAScript 2015 (dawniej znany jako ES6). Jeśli go użyjesz, inne odpowiedzi zapewniają tu wiele implementacji NEATER.


Ten gist tutaj rozwiąże problem, a także usuwa wszystkie zdarzenia argumentu zamiast tylko 1 ( lub określona wartość).

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

Stosowanie:

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]
32
zykadelic 1 wrzesień 2017, 22:41

Nigdy nie powinieneś mututować swojej tablicy. Ponieważ jest to w stosunku do funkcjonalnego wzoru programowania. Możesz utworzyć nową tablicę bez odniesienia do tablicy, którą chcesz zmienić dane za pomocą metody ECMAScript 6 filter;

var myArray = [1, 2, 3, 4, 5, 6];

Załóżmy, że chcesz usunąć 5 z tablicy, możesz po prostu to zrobić:

myArray = myArray.filter(value => value !== 5);

Daje to nową tablicę bez wartości, którą chcesz usunąć. Więc wynik będzie:

 [1, 2, 3, 4, 6]; // 5 has been removed from this array

Aby uzyskać dalsze zrozumienie, możesz przeczytać dokumentację MDN na Array.filter.

29
Peter Mortensen 1 wrzesień 2019, 22:41

Więcej nowoczesnych, ECMascript 2015 (dawniej znany jako Harmony lub ES 6) podejście. Dany:

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

Następnie:

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

Wydajność:

[1, 2, 4]

Możesz użyć Babel i a Serwisowo Polyfill Aby zapewnić, że jest to dobrze wspierane przez przeglądarek.

27
Peter Mortensen 25 czerwiec 2016, 13:01

Masz 1 do 9 w tablicy, a chcesz usunąć 5. Użyj poniższego kodu:

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

Jeśli chcesz wiele wartości. Przykład: - 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);

Jeśli chcesz usunąć wartość tablicy w tablicy. Przykład: [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);

Obejmuje obsługiwana przeglądarka jest link.

25
Thilina Sampath 2 wrzesień 2019, 04:01