Hoe kan ik een specifiek item uit een array verwijderen?

Ik heb een reeks getallen en ik gebruik de methode .push()om er elementen aan toe te voegen.

Is er een eenvoudige manier om een ​​specifiek element uit een array te verwijderen?

Ik zoek het equivalent van zoiets als:

array.remove(number);

Ik moet coreJavaScript gebruiken. Kaders zijn niet toegestaan.


Antwoord 1, autoriteit 100%

Zoek de indexvan het array-element dat u wilt verwijderen met indexOfen verwijder die index met splice.

De methode splice() verandert de inhoud van een array door te verwijderen
bestaande elementen en/of het toevoegen van nieuwe elementen.

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

Antwoord 2, autoriteit 12%

Bewerkt op oktober 2016

  • Doe het eenvoudig, intuïtief en expliciet (Occam’s scheermes)
  • Doe het onveranderlijk (originele array blijft ongewijzigd)
  • Doe het met standaard JavaScript-functies, als uw browser ze niet ondersteunt – gebruik polyfill

In dit codevoorbeeld gebruik ik de functie “array.filter(…)”om ongewenste items uit een array te verwijderen. Deze functie verandert de oorspronkelijke array niet en maakt een nieuwe aan. Als uw browser deze functie niet ondersteunt (bijv. Internet Explorer vóór versie 9, of Firefox vóór versie 1.5), overweeg dan om de filterpolyfill van Mozilla.

Item verwijderen (ECMA-262 Editie 5 code oftewel 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 ]

Item verwijderen (ECMAScript 6-code)

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

BELANGRIJKECMAScript 6 “() => {}” syntaxis van de pijlfunctie wordt helemaal niet ondersteund in Internet Explorer, Chrome vóór versie 45, Firefox vóór versie 22 en Safari vóór 10 versie. Om ECMAScript 6-syntaxis in oude browsers te gebruiken, kunt u BabelJSgebruiken.


Meerdere items verwijderen (ECMAScript 7-code)

Een bijkomend voordeel van deze methode is dat je meerdere items kunt verwijderen

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 ]

BELANGRIJK“array.includes(…)”-functie wordt helemaal niet ondersteund in Internet Explorer, Chrome vóór versie 47, Firefox vóór versie 43, Safari vóór versie 9 en Edge vóór 14-versie dus hier is polyfill van Mozilla.

Meerdere items verwijderen (in de toekomst misschien)

Als het voorstel “This-Binding Syntax”ooit wordt geaccepteerd, in staat zijn om dit te doen:

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

Probeer het zelf in BabelJS 🙂

Referentie


Antwoord 3, autoriteit 11%

Ik weet niet hoe je verwacht dat array.remove(int)zich zal gedragen. Er zijn drie mogelijkheden die ik kan bedenken die je misschien wilt hebben.

Om een ​​element van een array op een index ite verwijderen:

array.splice(i, 1);

Als u elk element met de waarde numberuit de array wilt verwijderen:

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

Als je gewoon wilt dat het element op index iniet meer bestaat, maar je wilt niet dat de indexen van de andere elementen veranderen:

delete array[i];

Antwoord 4, autoriteit 4%

Het hangt ervan af of je een lege plek wilt behouden of niet.

Als je weleen lege plek wilt:

array[index] = undefined;

Als u geeneen lege ruimte wilt:

//To keep the original:
//oldArray = [...array];
//This modifies the array.
array.splice(index, 1);

En als je de waarde van dat item nodig hebt, kun je het geretourneerde element van de array gewoon opslaan:

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

Als u beide uiteinden van de array wilt verwijderen, kunt u array.pop()gebruiken voor de laatste of array.shift()voor de eerste één (beide retourneren ook de waarde van het item).

Als je de index van het item niet weet, kun je array.indexOf(item)gebruiken om het te krijgen (in een if()om er een te krijgen item of in een while()om ze allemaal te krijgen). array.indexOf(item)retourneert ofwel de index of -1indien niet gevonden. 


Antwoord 5, autoriteit 2%

Een vriend had problemen met Internet Explorer 8en liet me zien wat hij deed. Ik vertelde hem dat het verkeerd was, en hij vertelde me dat hij hier het antwoord kreeg. Het huidige topantwoord werkt niet in alle browsers (bijvoorbeeld Internet Explorer 8) en verwijdert alleen het eerste exemplaar van het item.

Verwijder ALLE instanties uit een array

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

Het loopt achteruit door de array (aangezien indices en lengte veranderen als items worden verwijderd) en verwijdert het item als het wordt gevonden. Het werkt in alle browsers.


Antwoord 6, autoriteit 2%

Er zijn twee belangrijke benaderingen:

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

  2. verwijderen: delete anArray[index];

Wees voorzichtig wanneer u de deletevoor een array gebruikt. Het is goed voor het verwijderen van attributen van objecten, maar niet zo goed voor arrays. Het is beter om splicete gebruiken voor arrays.

Houd er rekening mee dat wanneer u deletegebruikt voor een array, u verkeerde resultaten kunt krijgen voor anArray.length. Met andere woorden, deletezou het element verwijderen, maar de waarde van de eigenschap length niet bijwerken.

Je kunt ook gaten in indexnummers verwachten na het gebruik van delete, b.v. je zou kunnen eindigen met indexen 1, 3, 4, 8, 9 en 11 en lengte zoals het was voordat je delete gebruikte. In dat geval zouden alle geïndexeerde for-lussen crashen, omdat indexen niet langer opeenvolgend zijn.

Als je om de een of andere reden gedwongen bent deletete gebruiken, gebruik dan for eachlus wanneer u door arrays moet lopen. Vermijd trouwens altijd het gebruik van geïndexeerde for-lussen, indien mogelijk. Op die manier zou de code robuuster zijn en minder vatbaar voor problemen met indexen.


Antwoord 7

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)

Antwoord 8

Het is niet nodig om indexOfof splicete gebruiken. Het presteert echter beter als u slechts één exemplaar van een element wilt verwijderen.

Zoeken en verplaatsen (verplaatsen):

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

Gebruik indexOfen splice(indexof):

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

Gebruik alleen splice(splice):

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

Runtimes op nodejs voor array met 1000 elementen (gemiddeld meer dan 10.000 runs):

indexofis ongeveer 10x langzamer dan move. Zelfs als het verbeterd is door de aanroep naar indexOfin splicete verwijderen, presteert het veel slechter dan 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

Antwoord 9

Dit levert een predikaat op in plaats van een waarde.

OPMERKING:het zal de gegeven array bijwerken en de betreffende rijen retourneren.

Gebruik

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

Definitie

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

Antwoord 10

Je kunt het gemakkelijk doen met het filter methode:

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

Antwoord 11

John Resig heeft een goede implementatie gepost:

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

Als u een globaal object niet wilt uitbreiden, kunt u in plaats daarvan iets als het volgende doen:

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

Maar de belangrijkste reden dat ik dit post, is om gebruikers te waarschuwen voor de alternatieve implementatie die wordt voorgesteld in de opmerkingen op die pagina (14 december 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;
};

Het lijkt in eerste instantie goed te werken, maar door een pijnlijk proces ontdekte ik dat het faalt bij het verwijderen van het voorlaatste element in een array. Als u bijvoorbeeld een array met 10 elementen heeft en u probeert het 9e element hiermee te verwijderen:

myArray.remove(8);

Je krijgt een array van 8 elementen. Ik weet niet waarom, maar ik heb bevestigd dat de oorspronkelijke implementatie van John dit probleem niet heeft.


Antwoord 12

U kunt ES6 gebruiken. Om in dit geval bijvoorbeeld de waarde ‘3’ te verwijderen:

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

Uitvoer:

["1", "2", "4", "5", "6"]

Antwoord 13

Underscore.jskan worden gebruikt om problemen met meerdere browsers op te lossen. Het maakt gebruik van ingebouwde browsermethoden, indien aanwezig. Als ze afwezig zijn, zoals in het geval van oudere Internet Explorer-versies, gebruikt het zijn eigen aangepaste methoden.

Een eenvoudig voorbeeld om elementen uit array (van de website) te verwijderen:

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

Antwoord 14

Als u een nieuwe array wilt waarvan de verwijderde posities zijn verwijderd, kunt u altijd het specifieke element verwijderen en de array eruit filteren. Mogelijk is een extensie van het array-objectnodig voor browsers die de filtermethode niet implementeren , maar op de lange termijn is het makkelijker omdat je alleen dit doet:

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

Het zou [1, 2, 3, 4, 6]moeten weergeven.


Antwoord 15

Hier zijn een paar manieren om een item uit een array te verwijderen met JavaScript.

Alle beschreven methoden muteren de oorspronkelijke array nieten maken in plaats daarvan een nieuwe.

Als je de index van een item kent

Stel dat je een array hebt en je wilt een item op positie iverwijderen.

Eén methode is om slice()te gebruiken:

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)

Antwoord 16

Bekijk deze code. Het werkt in elke grote browser.

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)

Antwoord 17

ES6 & zonder mutatie: (oktober 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)

Antwoord 18

Je kunt lodash _.pullgebruiken (array muteren), _.pullAt(array muteren) of _.zonder(muteert array niet),

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

Antwoord 19

Het verwijderen van een bepaald element/string uit een array kan in een one-liner:

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

waar:

theArray: de array waarvan u iets specifieks wilt verwijderen

stringToRemoveFromArray: de tekenreeks die u wilt verwijderen en 1 is het aantal elementen dat u wilt verwijderen.

OPMERKING: Als “stringToRemoveFromArray” niet in de array staat, wordt het laatste element van de array verwijderd.

Het is altijd een goede gewoonte om eerst te controleren of het element in uw array bestaat, voordat u het verwijdert.

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

Afhankelijk van of u een nieuwere of oudere versie van Ecmascript op de computers van uw klant heeft:

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

OF

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

Waarbij ‘3’ de waarde is die u uit de array wilt verwijderen.
De array wordt dan: ['1','2','4','5','6']


Antwoord 20

Prestaties

Vandaag (2019-12-09) voer ik prestatietests uit op macOS v10.13.6 (High Sierra) voor gekozen oplossingen. Ik toon delete(A), maar ik gebruik het niet in vergelijking met andere methoden, omdat het lege ruimte in de array liet.

De conclusies

  • de snelste oplossing is array.splice(C) (behalve Safari voor kleine arrays waar het de tweede keer is)
  • voor grote arrays is array.slice+splice(H) de snelste onveranderlijke oplossing voor Firefox en Safari; Array.from(B) is het snelst in Chrome
  • veranderlijke oplossingen zijn meestal 1,5x-6x sneller dan onveranderlijke
  • voor kleine tabellen in Safari is verrassend genoeg de veranderlijke oplossing (C) langzamer dan de onveranderlijke oplossing (G)

Details

In tests verwijder ik het middelste element op verschillende manieren uit de array. De A, C-oplossingen zijn aanwezig. De B, D, E, F, G, Hoplossingen zijn onveranderlijk.

Resultaten voor een array met 10 elementen

Voer hier de afbeeldingsbeschrijving in

In Chrome is de array.splice(C) de snelste interne oplossing. De array.filter(D) is de snelste onveranderlijke oplossing. De langzaamste is array.slice(F). U kunt de test hieruitvoeren op uw computer.

Resultaten voor een array met 1.000.000 elementen

Voer hier de afbeeldingsbeschrijving in

In Chrome is de array.splice(C) de snelste oplossing ter plaatse (de delete(C) is even snel – maar er bleef een lege plek in de array (zodat deze geen ‘volledige verwijdering’ uitvoert)). De array.slice-splice(H) is de snelste onveranderlijke oplossing. De langzaamste is array.filter(D en E). U kunt de test hierop uw computer uitvoeren.


Antwoord 21

OK,u heeft bijvoorbeeld de onderstaande array:

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

En we willen nummer 4 verwijderen. Je kunt gewoon de onderstaande code gebruiken:

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

Als je deze functie hergebruikt, schrijf je een herbruikbare functie die wordt toegevoegd aan de nativearrayfunctie zoals hieronder:

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

Maar hoe zit het als je in plaats daarvan de onderstaande array hebt met een paar [5]en in de array?

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

We hebben een lus nodig om ze allemaal te controleren, maar een eenvoudigere en efficiëntere manier is het gebruik van ingebouwde JavaScript-functies, dus schrijven we een functie die in plaats daarvan een filter gebruikt zoals hieronder:

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]

Er zijn ook bibliotheken van derden die u hierbij helpen, zoals Lodash of Underscore. Kijk voor meer informatie op lodash _.pull, _.pullAt of _.without.


Antwoord 22

Ik ben vrij nieuw in JavaScript en had deze functionaliteit nodig. Ik schreef alleen dit:

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

En wanneer ik het wil gebruiken:

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

Uitvoer – Zoals verwacht.
[“item1”, “item1”]

Misschien heb je andere behoeften dan ik, dus je kunt ze gemakkelijk aanpassen. Ik hoop dat dit iemand helpt.


Antwoord 23

Als je complexe objecten in de array hebt, kun je dan filters gebruiken?
In situaties waar $.inArray of array.splice niet zo gemakkelijk te gebruiken is. Vooral als de objecten misschien ondiep zijn in de array.

Bijvoorbeeld als u een object heeft met een ID-veld en u wilt dat het object uit een array wordt verwijderd:

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

Antwoord 24

Ik wil antwoorden op basis van ECMAScript 6. Stel dat je een array hebt zoals hieronder:

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

Als je wilt verwijderen met een speciale index zoals 2, schrijf dan de onderstaande code:

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

Maar als je een speciaal item zoals 3wilt verwijderen en je weet de index niet, doe dan als volgt:

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

Hint: gebruik een pijlfunctie voor filtercallback, tenzij u een lege array krijgt.


Antwoord 25

Bijwerken:deze methode wordt alleen aanbevolen als u ECMAScript 2015 (voorheen bekend als ES6) niet kunt gebruiken. Als je het kunt gebruiken, bieden andere antwoorden hier veel nettere implementaties.


Deze kern hierlost uw probleem op en verwijdert ook alle exemplaren van het argument in plaats van slechts 1 (of een opgegeven waarde).

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

Gebruik:

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]

Antwoord 26

ES10-update

Dit bericht vat algemene benaderingen samen voor het verwijderen van elementen uit een array vanaf ECMAScript 2019 (ES10).

1. Algemene gevallen

1.1. Array-element op waarde verwijderen met .splice()

| Ter plaatse: Ja |
| Verwijdert duplicaten: Yes(loop), No(indexOf) |
| Op waarde / index: op index |

Als u de waarde weet die u uit een array wilt verwijderen, kunt u de splice-methode gebruiken. Eerst moet u de index van het doelitem identificeren. U gebruikt dan de index als startelement en verwijdert slechts één element.

// 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. Array-element verwijderen met de methode .filter()

| Ter plaatse: Nee |
| Verwijdert duplicaten: Ja |
| Op waarde / index: op waarde |

Het specifieke element kan uitgefilterd wordenuit de array door middel van een filterfunctie. Zo’n functie wordt dan aangeroepen voor elk element in de array.

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-element verwijderen door Array.prototype

uit te breiden

| In-place: Ja/Nee (afhankelijk van implementatie) |
| Verwijdert duplicaten: Ja/Nee (afhankelijk van implementatie) |
| Op waarde / index: op index / op waarde (afhankelijk van implementatie) |

Het prototype van Array kan worden uitgebreid met aanvullende methoden. Dergelijke methoden zijn dan beschikbaar voor gebruik op gemaakte arrays.

Opmerking:Het uitbreiden van prototypes van objecten uit de standaardbibliotheek van JavaScript (zoals Array) wordt door sommigen als een antipatroon beschouwd.

// 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. Array-element verwijderen met de operator delete

| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde / index: op index |

Het gebruik van de delete-operator heeft geen invloed op de eigenschap length. Het heeft ook geen invloed op de indexen van volgende elementen. De array wordt schaars, wat een mooie manier is om te zeggen dat het verwijderde item niet wordt verwijderd, maar ongedefinieerd wordt.

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]

De delete-operator is ontworpen om eigenschappen van JavaScript-objecten te verwijderen, welke arrays objecten zijn.

1.5. Array-element verwijderen met behulp van Object-hulpprogramma’s (>= ES10)

| Ter plaatse: Nee |
| Verwijdert duplicaten: Ja |
| Op waarde / index: op waarde |

ES10 introduceerde Object.fromEntries, dat kan worden gebruikt om de gewenste array te maken van elk array-achtig object en ongewenste elementen tijdens het proces te filteren.

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. Speciale gevallen

2.1 Element verwijderen als het aan het einde van de array staat

2.1.1. Array lengthwijzigen

| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde/index: n.v.t. |

JavaScript-array-elementen kunnen aan het einde van een array worden verwijderd door de eigenschap length in te stellen op een waarde die kleiner is dan de huidige waarde. Elk element waarvan de index groter is dan of gelijk is aan de nieuwe lengte wordt verwijderd.

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. Met behulp van de .pop()methode

| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde/index: n.v.t. |

De pop-methode verwijdert het laatste element van de array, retourneert dat element en werkt de eigenschap length bij. De pop-methode wijzigt de array waarop deze wordt aangeroepen. Dit betekent dat, in tegenstelling tot het gebruik van delete, het laatste element volledig wordt verwijderd en de lengte van de array wordt verminderd.

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

2.2. Element verwijderen als het aan het begin van de array staat

| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde/index: n.v.t. |

De methode .shift()werkt ongeveer hetzelfde als de methode pop, behalve dat het het eerste element van een JavaScript-array verwijdert in plaats van het laatste. Wanneer het element wordt verwijderd, worden de overige elementen naar beneden geschoven.

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

2.3. Element verwijderen als dit het enige element in de array is

| Ter plaatse: Ja |
| Verwijdert duplicaten: N.v.t. |
| Op waarde/index: n.v.t. |

De snelste techniek is om een ​​arrayvariabele op een lege array in te stellen.

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

Als alternatief kan de techniek van 2.1.1 worden gebruikt door de lengte in te stellen op 0.


Antwoord 27

U mag uw array nooit muteren. Omdat dit in strijd is met het functionele programmeerpatroon. U kunt een nieuwe array maken zonder te verwijzen naar de array waarvan u de gegevens wilt wijzigen met behulp van de ECMAScript 6-methode filter;

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

Stel dat u 5uit de array wilt verwijderen, dan kunt u dat eenvoudig als volgt doen:

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

Dit geeft je een nieuwe array zonder de waarde die je wilde verwijderen. Het resultaat is dus:

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

Voor meer begrip kunt u de MDN-documentatie lezen op Array.filter.


Antwoord 28

Je kunt een achterwaartse lus maken om ervoor te zorgen dat je de indexen niet verknoeit, als er meerdere instanties van het element zijn.

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

Antwoord 29

Een modernere, ECMAScript 2015-benadering (voorheen bekend als Harmony of ES 6). Gegeven:

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

Dan:

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

Opbrengst:

[1, 2, 4]

Je kunt Babelen een polyfill gebruiken serviceom ervoor te zorgen dat dit goed wordt ondersteund in alle browsers.


Antwoord 30

Je hebt 1 tot 9 in de array en je wilt 5 verwijderen. Gebruik de onderstaande code:

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

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes