Hoe maak ik een array in JavaScript leeg?

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 leegmaken?

Antwoord 1, autoriteit 100%

Manieren om een bestaande array Ate wissen:

Methode 1

(dit was mijn oorspronkelijke antwoord op de vraag)

a = []; 

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

Dit is ook de snelste oplossing.

Dit codevoorbeeld toont 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(zoals aanbevolendoor Matthew Crumley)

A.length = 0

Dit zal de bestaande array wissen door de lengte in te stellen op 0. Sommigen hebben beweerd dat dit niet in alle implementaties van JavaScript werkt, maar het blijkt dat dit niet het geval is. Het werkt ook bij gebruik van “strikte modus” in ECMAScript 5 omdat de eigenschap length van een array een lees-/schrijfeigenschap is.

Methode 3(zoals aanbevolendoor Anthony)

a.splice(0,a.length)

Het gebruik van .splice()werkt perfect, maar aangezien de functie .splice()een array retourneert met alle verwijderde items, wordt er feitelijk een kopie geretourneerd van de oorspronkelijke reeks. Benchmarks suggereren dat dit geen enkel effect heeft op de prestaties.

Methode 4(zoals aanbevolendoor 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.

Prestaties

Van alle methoden om een bestaande arrayte wissen, lijken de prestaties van methoden 2 en 3 erg op elkaar en zijn ze een stuk sneller dan methode 4. Zie deze benchmark.

Zoals opgemerkt door Diadistisin hun antwoordhieronder, waren de oorspronkelijke benchmarks die werden gebruikt om de prestaties van de vier hierboven beschreven methoden te bepalen, gebrekkig. De oorspronkelijke benchmark gebruikte de gewiste array opnieuw, dus de tweede iteratie wist een array die al leeg was.

De volgende benchmark lost deze fout op: http://jsben.ch/#/hyj65. Het laat duidelijk zien dat methodes #2 (lengte-eigenschap) en #3 (splice) de snelste zijn (methode #1 niet meegerekend die de originele 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 het geaccepteerde antwoord is gemarkeerd, zal ik hier alle methoden opnemen. Als je op dit antwoord stemt, stem dan alsjeblieft op de andere antwoorden waarnaar ik heb verwezen.

Antwoord 2, autoriteit 52%

Als je de originele array moet behouden omdat je er andere verwijzingen naar hebt die ook moeten worden bijgewerkt, kun je deze wissen zonder een nieuwe array te maken door de lengte op nul in te stellen:

a.length = 0;

Antwoord 3, autoriteit 6%

Hier de snelst werkende implementatieterwijl dezelfde array behouden(“mutable”):

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

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

Ter info Kaarten Setdefinieer clear(), zou het logisch zijn geweest om clear()te hebben voor Arrayook.

TypeScript-versie:

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

De bijbehorende tests:

describe('clearArray()', () => {
  test('clear regular array', () => {
    const array = [1, 2, 3, 4, 5];
    clearArray(array);
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });
  test('clear array that contains undefined and null', () => {
    const array = [1, undefined, 3, null, 5];
    clearArray(array);
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });
});

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

jsPerf offline. Vergelijkbare benchmark: https://jsben.ch/hyj65

Antwoord 4, autoriteit 5%

Een meer browservriendelijke en optimalere oplossing is om de splice-methode te gebruiken om de inhoud van de array A te legen, zoals hieronder:

A.splice(0, A.length);

Antwoord 5, autoriteit 2%

De antwoorden die niet minder hebben dat 2739 upventotes inmiddels misleidend en onjuist zijn.

De vraag is: “Hoe maak je je bestaande array leeg?” B.v. voor A = [1,2,3,4].

1. zeggen “A = []is het antwoord” is onwetend en absoluut onjuist. [] == []is false .

   Dit komt omdat deze twee arrays twee afzonderlijke, individuele objecten zijn, met hun eigen twee identiteiten, het opnemen van hun eigen ruimte in de digitale wereld, elk alleen.

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

• Breng je geen nieuwe mee alsof je hebt gedaan waar je om hebt gevraagd.
• In plaats daarvan legt u de prullenbak leeg.
• Je vervangt niet de gevulde met een nieuw leeg blikje, en je neemt het label niet “A” van het gevulde blikje en plak het aan de nieuwe als in A = [1,2,3,4]; A = [];

Een array-object legen is het gemakkelijkste ding ooit:

a.length = 0;

Op deze manier is de blik onder “A” niet alleen leeg, maar ook zo schoon als nieuw!

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

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

3. Noch, om uw linkerhand aan de onderkant van de vuilnisbak te plaatsen, houd deze vast met uw rechterkant aan de bovenkant om zijn inhoud eruit te kunnen trekken als in:

   A.splice(0, A.length);
   

Nee, u werd gevraagd om het te legen:

a.length = 0;

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

Antwoord 6

Prestatietest:

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

Antwoord 7

U kunt dit toevoegen aan uw JavaScript-bestand zodat uw arrays kunnen worden “gewist”:

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 er zeker van wilt zijn dat je niets 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 wijzigen, en ik ben geneigd het daarmee eens te zijn. Wees voorzichtig bij het beslissen hoe u hiermee omgaat.

Antwoord 8

Je kunt eenvoudig een functie maken om dat voor je te doen, de lengtewijzigen of zelfs toevoegen aan native Arrayals remove()functie voor hergebruik.

Stel je voor dat je deze array hebt:

var arr = [1, 2, 3, 4, 5]; //the array

OK, voer gewoon dit uit:

arr.length = 0; //change the length

en het resultaat is:

[] //result

eenvoudige manier om een array leeg te maken…

Ook lus gebruiken die niet nodig is, maar gewoon een andere manier om dat te doen:

/* could be arr.pop() or arr.splice(0)
don't need to return as main array get changed */
function remove(arr) {
  while(arr.length) {
    arr.shift(); 
  }
}

Er zijn ook lastige manieren om over na te denken, bijvoorbeeld zoiets als dit:

arr.splice(0, arr.length); //[]

Dus als arr 5 items heeft, zal het 5 items van 0 splitsen, wat betekent dat er niets in de array achterblijft.

Ook andere manieren, zoals het eenvoudig opnieuw toewijzen van de array, bijvoorbeeld:

arr = []; //[]

Als je naar de array-functies kijkt, zijn er veel andere manieren om dit te doen, maar de meest aanbevolen manier zou het veranderen van de lengte kunnen zijn.

Zoals ik in de eerste plaats al zei, kun je ook een prototype remove() maken, omdat dit het antwoord op je vraag is. je kunt eenvoudig een van de bovenstaande methoden kiezen en er een prototype van maken om het object in JavaScript te arrayeren, zoiets als:

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

en je kunt het eenvoudig zo noemen om elke array in je javascript-toepassing te legen:

arr.remove(); //[]

Antwoord 9

Er is veel verwarring en verkeerde informatie over de while;pop/shift-prestaties, zowel in antwoorden als opmerkingen. De while/pop-oplossing heeft (zoals verwacht) de slechtste prestatie. Wat er feitelijk gebeurt, is dat de installatie slechts één keer wordt uitgevoerd voor elk voorbeeld dat het fragment in een lus uitvoert. bv:

var arr = [];
for (var i = 0; i < 100; i++) { 
    arr.push(Math.random()); 
}
for (var j = 0; j < 1000; j++) {
    while (arr.length > 0) {
        arr.pop(); // this executes 100 times, not 100000
    }
}

Ik heb een nieuwe test gemaakt die correct werkt:

http://jsperf.com/empty-javascript-array-redux

Waarschuwing:zelfs in deze versie van de test kun je het echte verschil niet zien, omdat het klonen van de array het grootste deel van de testtijd in beslag neemt. Het laat nog steeds zien dat splicede snelste manier is om de array te wissen (er wordt geen rekening gehouden met [], want hoewel het de snelste is, wordt de bestaande array niet echt gewist).

Antwoord 10

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

En noem het: array.clear();

Antwoord 11

In het geval dat u geïnteresseerd bent in de geheugentoewijzing, kunt u elke benadering vergelijken met iets als this jsfiddlein combinatie met chrome dev-tools ‘ tabblad tijdlijn. U wilt het prullenbakpictogram onderaan gebruiken om een afvalverzameling te forceren na het ‘opruimen’ van de array. Dit zou u een duidelijker antwoord moeten geven voor de browser van uw keuze. Veel antwoorden hier zijn oud en ik zou er niet op vertrouwen, maar eerder testen zoals in het antwoord van @tanguy_k hierboven.

(voor een introductie op het bovengenoemde tabblad kunt u kijken op hier)

Stackoverflow dwingt me om de jsfiddle te kopiëren, dus hier is het:

<html>
<script>
var size = 1000*100
window.onload = function() {
  document.getElementById("quantifier").value = size
}
function scaffold()
{
  console.log("processing Scaffold...");
  a = new Array
}
function start()
{
  size = document.getElementById("quantifier").value
  console.log("Starting... quantifier is " + size);
  console.log("starting test")
  for (i=0; i<size; i++){
    a[i]="something"
  }
  console.log("done...")
}
function tearDown()
{
  console.log("processing teardown");
  a.length=0
}
</script>
<body>
    <span style="color:green;">Quantifier:</span>
    <input id="quantifier" style="color:green;" type="text"></input>
    <button onclick="scaffold()">Scaffold</button>
    <button onclick="start()">Start</button>
    <button onclick="tearDown()">Clean</button>
    <br/>
</body>
</html>

En je moet er rekening mee houden dat dit kan afhangen van het type array-elementen, omdat javascript strings anders beheert dan andere primitieve typen, om nog maar te zwijgen van arrays van objecten. Het type kan van invloed zijn op wat er gebeurt.

Antwoord 12

Als u

. gebruikt

a = []; 

Vervolgens wijst u een nieuwe array-verwijzing toe aan a, als verwijzing in a al is toegewezen aan een andere variabele, dan zal het die array ook niet leegmaken en daarom zal de garbage collector dat geheugen niet verzamelen.

Bijvoorbeeld.

var a=[1,2,3];
var b=a;
a=[];
console.log(b);// It will print [1,2,3];

of

a.length = 0;

Als we a.lengthspecificeren, stellen we alleen de grenzen van de array opnieuw in en wordt het geheugen voor rest array-elementen verbonden door een garbage collector.

In plaats van deze twee oplossingen zijn beter.

a.splice(0,a.length)

en

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

Zoals in het vorige antwoord van kenshou.html, is de tweede methode sneller.

Antwoord 13

A.splice(0);

Ik heb dit zojuist gedaan met een code waaraan ik werk. Het heeft de array gewist.

Antwoord 14

Gebruik een aangepaste versie van Jan‘s eerste suggestie:

var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
     A.pop();
}

Terser:

for (let i = A.length; i > 0;A.pop(),i--) {}

of hier is een andere nemen:

while(!A[Symbol.iterator]().next().done)A.shift()

Antwoord 15

Als u constanten gebruikt, heeft u geen keuze:

const numbers = [1, 2, 3]

U kunt niet opnieuw instellen:

numbers = []

U kunt alleen afknotten:

numbers.length = 0

Antwoord 16

Om een ​​huidige geheugenlocatie van een arraygebruik leeg te maken: 'myArray.length = 0'of 'myArray.pop() UN-till its length is 0'

• length: U kunt de eigenschap Lengte instellen om op elk moment een array af te klappen. Wanneer u een array uitbreidt door de eigenschap van zijn lengte te wijzigen, neemt het aantal daadwerkelijke elementen toe.
• pop(): de POP-methode verwijdert het laatste -element van een array en rendement die de verwijderde waarde retourneert.
• shift(): De Shift-methode verwijdert het element op de Zero-index en verschuift de waarden bij opeenvolgende indexen naar beneden en retourneert vervolgens de verwijderde waarde.

Voorbeeld:

var arr = ['77'];
arr.length = 20;
console.log("Increasing : ", arr); // (20) ["77", empty × 19]
arr.length = 12;
console.log("Truncating : ", arr); // (12) ["77", empty × 11]
var mainArr = new Array();
mainArr = ['1', '2', '3', '4'];
var refArr = mainArr;
console.log('Current', mainArr, 'Refered', refArr);
refArr.length = 3;
console.log('Length: ~ Current', mainArr, 'Refered', refArr);
mainArr.push('0');
console.log('Push to the End of Current Array Memory Location \n~ Current', mainArr, 'Refered', refArr);
mainArr.poptill_length(0);
console.log('Empty Array \n~ Current', mainArr, 'Refered', refArr);
Array.prototype.poptill_length = function (e) {
  while (this.length) {
    if( this.length == e ) break;
    console.log('removed last element:', this.pop());
  }
};

• new Array() | []Maak een array met nieuwe geheugenlocatie met behulp van Array constructorof array literal.

  mainArr = []; // a new empty array is addressed to mainArr.
  var arr = new Array('10'); // Array constructor
  arr.unshift('1'); // add to the front
  arr.push('15'); // add to the end
  console.log("After Adding : ", arr); // ["1", "10", "15"]
  arr.pop(); // remove from the end
  arr.shift(); // remove from the front
  console.log("After Removing : ", arr); // ["10"]
  var arrLit = ['14', '17'];
  console.log("array literal « ", indexedItem( arrLit ) ); // {0,14}{1,17}
  function indexedItem( arr ) {
      var indexedStr = "";
      arr.forEach(function(item, index, array) {
          indexedStr += "{"+index+","+item+"}";
          console.log(item, index);
      });
      return indexedStr;
  }
  

• slice(): Door gebruik te maken van de slice-functie krijgen we een ondiepe kopie van elementen uit de originele array, met een nieuw geheugenadres, zodat elke wijziging op cloneArr geen invloed heeft op een daadwerkelijke|originele array.

  var shallowCopy = mainArr.slice(); // this is how to make a copy
  var cloneArr = mainArr.slice(0, 3); 
  console.log('Main', mainArr, '\tCloned', cloneArr);
  cloneArr.length = 0; // Clears current memory location of an array.
  console.log('Main', mainArr, '\tCloned', cloneArr);
  

Antwoord 17

Het verbaast me dat nog niemand dit heeft voorgesteld:

let xs = [1,2,3,4];
for (let i in xs)
    delete xs[i];

Dit levert een array op in een heel andere staat dan de andere oplossingen. In zekere zin is de array ‘leeggemaakt’:

xs
=> Array [ <4 empty slots> ]
[...xs]
=> Array [ undefined, undefined, undefined, undefined ]
xs.length
=> 4
xs[0]
=> ReferenceError: reference to undefined property xs[0]

U kunt een equivalente array maken met [,,,,]of Array(4)

Antwoord 18

Gebruik hieronder als u legular 2+ formarray moet legen.

public emptyFormArray(formArray:FormArray) {
    for (let i = formArray.controls.length - 1; i >= 0; i--) {
        formArray.removeAt(i);
    }
}