Vraag Hoe leeg ik een array in JavaScript?


Is er een manier om een ​​array leeg te maken en zo ja met .remove()?

Bijvoorbeeld,

A = [1,2,3,4];

Hoe kan ik dat legen?


2199
2017-08-05 09:08


oorsprong


antwoorden:


Manieren om een ​​bestaande array te wissen A:

Methode 1

(dit was mijn oorspronkelijke antwoord op de vraag)

A = [];

Deze code stelt de variabele in A naar een nieuwe lege array. Dit is perfect als je het niet hebt verwijzingen naar de originele array A nergens anders omdat dit feitelijk een gloednieuwe (lege) array creëert. U moet voorzichtig zijn met deze methode, want als u deze array hebt verwezen vanuit een andere variabele of eigenschap, blijft de oorspronkelijke array ongewijzigd. Gebruik dit alleen als u alleen de array verwijst naar de oorspronkelijke variabele A.

Dit is ook de snelste oplossing.

In dit codevoorbeeld ziet u het probleem dat u kunt tegenkomen bij het gebruik van deze methode:

var arr1 = ['a','b','c','d','e','f'];
var arr2 = arr1;  // Reference arr1 by another variable 
arr1 = [];
console.log(arr2); // Output ['a','b','c','d','e','f']

Methode 2 (als suggereerde door Matthew Crumley)

A.length = 0

Hiermee wordt de bestaande array gewist door de lengte in te stellen op 0. Sommigen hebben aangevoerd dat dit misschien niet in alle JavaScript-implementaties werkt, maar het blijkt dat dit niet het geval is. Het werkt ook bij gebruik van "strict mode" in ECMAScript 5 omdat de eigenschap length van een array een lees- / schrijf-eigenschap is.

Methode 3 (als suggereerde door Anthony)

A.splice(0,A.length)

Gebruik makend van .splice() zal perfect werken, maar sinds de .splice() functie zal een array retourneren met alle verwijderde items, het zal feitelijk een kopie van de originele array retourneren. Benchmarks suggereren dat dit geen effect heeft op de prestaties.

Methode 4 (als suggereerde door tanguy_k)

while(A.length > 0) {
    A.pop();
}

Deze oplossing is niet erg beknopt, en het is ook de langzaamste oplossing, in tegenstelling tot eerdere benchmarks waarnaar in het oorspronkelijke antwoord wordt verwezen.

Prestatie

Van alle methoden om een ​​te verwijderen bestaande array, methoden 2 en 3 lijken qua prestaties sterk op elkaar en zijn een stuk sneller dan methode 4. Zie dit criterium.

Zoals aangegeven door Diadistis in hun antwoord hieronder waren de oorspronkelijke benchmarks die werden gebruikt om de prestaties van de vier hierboven beschreven methoden vast te stellen, onjuist. De oorspronkelijke benchmark hergebruikt de gewiste array zodat de tweede iteratie een array wist die al leeg was.

De volgende benchmark lost deze fout op: http://jsben.ch/#/hyj65. Het laat duidelijk zien dat methoden # 2 (eigenschap length) en # 3 (splice) de snelste zijn (niet meegerekend methode # 1 die de oorspronkelijke array niet verandert).


Dit is een hot topic en de oorzaak van veel controverse. Er zijn eigenlijk veel juiste antwoorden en omdat dit antwoord al heel lang als geaccepteerd antwoord is gemarkeerd, zal ik hier alle methoden opnemen. Als u op dit antwoord stemt, stem dan de andere antwoorden waar ik naar heb verwezen, opnieuw bij.


3440
2017-08-05 09:10



Als u de originele array wilt behouden omdat er andere verwijzingen naar zijn die ook moeten worden bijgewerkt, kunt u deze wissen zonder een nieuwe array te maken door de lengte in te stellen op nul:

A.length = 0;

2253
2017-08-05 16:29



Hier de snelste werkende implementatie terwijl dezelfde array behouden ("veranderlijk"):

Array.prototype.clear = function() {
  while (this.length) {
    this.pop();
  }
};

ter info Kaart definieert clear() dus het lijkt logisch om te hebben clear() voor reeks te.

Of als een Underscore.js mixin:

_.mixin({
  clearArray: function(array) {
    while (array.length) {
      array.pop();
    }
  }
});

Of een eenvoudige functie:

function clearArray(array) {
  while (array.length) {
    array.pop();
  }
}

getypte tekst versie:

function clearArray<T>(array: T[]) {
  while (array.length) {
    array.pop();
  }
}

Ter informatie: het kan niet worden vereenvoudigd while (array.pop()): de tests zullen mislukken.

En de tests die daarbij horen:

describe('Array', () => {
  it('should clear the array', () => {
    let array = [1, 2, 3, 4, 5];
    array.clear();
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);

    // Even with undefined or null inside
    array = [1, undefined, 3, null, 5];
    array.clear();
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });
});

Hier de bijgewerkte jsPerf: http://jsperf.com/array-destroy/32  http://jsperf.com/array-destroy/152


255
2018-06-25 20:32



Een meer browser-vriendelijke en meer optimale oplossing zal zijn om de splice methode om de inhoud van de array A leeg te maken zoals hieronder:

A.splice(0, A.length);


182
2017-11-15 09:49



De antwoorden die niet minder hebben dan 2739 upvocaties zijn nu misleidend en onjuist.

De vraag is: "Hoe leeg je je bestaande array?" Bijv. voor A = [1,2,3,4].

  1. Zeggen "A = [] is het antwoord "is onwetend en absoluut incorrect. [] == [] is vals.

    Dit komt omdat deze twee arrays twee afzonderlijke, individuele objecten zijn, met hun eigen twee identiteiten, die hun eigen ruimte innemen in de digitale wereld, elk op zich.


Laten we zeggen dat je moeder je vraagt ​​om de prullenbak leeg te maken.

  • U neemt geen nieuwe mee, alsof u hebt gedaan waarvoor u werd gevraagd.
  • In plaats daarvan leegt u de prullenbak.
  • U vervangt de gevulde kan niet door een nieuwe lege kan, en u neemt niet het etiket "A" uit de gevulde kan en plakt deze aan de nieuwe zoals in A = [1,2,3,4]; A = [];

Het legen van een array-object is het eenvoudigste wat ooit is gebeurd:

A.length = 0;

Op deze manier is het blik onder "A" niet alleen leeg, maar ook zo schoon als nieuw!


  1. Bovendien hoeft u de prullenbak niet met de hand te verwijderen totdat het blik leeg is! U bent gevraagd de bestaande volledig te legen, in één beurt, niet om de prullenbak op te halen totdat de kan leeg is, zoals in:

    while(A.length > 0) {
        A.pop();
    }
    
  2. Noch, om je linkerhand onderaan het afval te plaatsen, houd je het met je recht bovenaan om de inhoud eruit te halen zoals in:

    A.splice(0, A.length);
    

Nee, u bent gevraagd om het te legen:

A.length = 0;

Dit is de enige code die de inhoud van een bepaalde JavaScript-array correct leegt.


61
2018-04-30 15:18



Prestatie test:

http://jsperf.com/array-clear-methods/3

a = []; // 37% slower
a.length = 0; // 89% slower
a.splice(0, a.length)  // 97% slower
while (a.length > 0) {
    a.pop();
} // Fastest

59
2018-05-14 07:14



U kunt dit toevoegen aan uw JavaScript-bestand zodat uw arrays "leeggemaakt" kunnen worden:

Array.prototype.clear = function() {
    this.splice(0, this.length);
};

Dan kun je het als volgt gebruiken:

var list = [1, 2, 3];
list.clear();

Of als je zeker wilt zijn dat je iets niet vernietigt:

if (!Array.prototype.clear) {
    Array.prototype.clear = function() {
       this.splice(0, this.length);
    };
}

Veel mensen denken dat je native objecten (zoals Array) niet moet aanpassen, en ik ben het er mee eens. Wees voorzichtig als u besluit hoe u hiermee omgaat.


32
2017-12-11 02:58



Array.prototype.clear = function() {
    this.length = 0;
};

En noem het: array.clear();


16
2018-02-22 21:28