Jak opróżnić tablicę w JavaScript?

Jeśli chcesz zachować oryginalną tablicę, ponieważ masz inne odniesienia do niej, które również powinny być zaktualizowane, możesz ją wyczyścić bez tworzenia nowej tablicy, ustawiając jej długość na zero:

A.length = 0;

tutaj najszybsza działająca implementacja podczas trzymania tej samej tablicy ("mutable"):

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

FYI Map definiuje clear() więc logiczne wydaje się mieć clear() dla Array też.

Lub jako podkreślenie.js mixin :

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

Lub prosta funkcja:

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

TypeScript version:

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

Dla twojej wiadomości nie można uprościć tego do while (array.pop()): testy zawiodą.

I testy, które idą z it:

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

Tutaj zaktualizowany jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

Bardziej przyjaznym dla wielu przeglądarek i bardziej optymalnym rozwiązaniem będzie użycie metody splice do opróżnienia zawartości tablicy A jak poniżej:

A.splice(0, A.length);

Odpowiedzi, które mają nie mniej niż 2739 głosów do tej pory są mylące i błędne.

Pytanie brzmi: "jak opróżnić istniejącą tablicę?"Np. dla A = [1,2,3,4].

1. Powiedzenie "A = [] jest odpowiedzią " jest ignoranckie i absolutnie błędne. [] == [] isfalse .

   Dzieje się tak dlatego, że te dwie tablice są dwoma oddzielnymi, indywidualnymi obiektami, o własnych dwóch tożsamościach, zajmującymi swoją własną przestrzeń w cyfrowym świecie, każdy na swoim własne.

Nie wprowadzasz nowego, jakbyś zrobił to, o co Cię poproszono.
• zamiast tego opróżniasz kosz na śmieci.
• nie zamieniasz wypełnionego na nową pustą puszkę i nie bierzesz etykiety " A " z wypełnionej puszki i nie przyklejasz jej do nowej, jak w A = [1,2,3,4]; A = [];

Opróżnianie obiektu tablicy jest najprostszą rzeczą w historii:

A.length = 0;

This way, the puszka pod " A " jest nie tylko pusta, ale także czysta jak nowa!

1. Ponadto nie musisz ręcznie usuwać śmieci, dopóki pojemnik nie będzie pusty! Poproszono Cię o całkowite opróżnienie istniejącego pojemnika w jednej turze, zamiast zbierania śmieci, dopóki nie będzie pusty, jak w poniższym przykładzie:

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

2. Ani, aby położyć lewą rękę na dole kosza, trzymając go z prawej na górze, aby móc wyciągnąć jego zawartość jako in:

   A.splice(0, A.length);
   

Nie, poproszono Cię o opróżnienie:

A.length = 0;

Jest to jedyny kod, który poprawnie opróżnia zawartość danej tablicy JavaScript.

Test wydajności:

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

Możesz dodać to do pliku JavaScript, aby umożliwić "wyczyszczenie" tablic:

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

Wtedy możesz użyć go tak:

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

Lub jeśli chcesz mieć pewność, że czegoś nie zniszczysz:

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

Wiele osób uważa, że nie należy modyfikować natywnych obiektów (takich jak tablica) i jestem skłonny się z tym zgodzić. Proszę zachować ostrożność przy podejmowaniu decyzji, jak sobie z tym poradzić.

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

I nazwij to: array.clear();

Istnieje wiele zamieszania i dezinformacji dotyczących while;pop / shift wydajność zarówno w odpowiedziach i komentarzach. Rozwiązanie while / pop ma (zgodnie z oczekiwaniami) najgorszą wydajność . To, co się dzieje, to to, że konfiguracja działa tylko raz dla każdej próbki, która uruchamia fragment w pętli. eg:

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

Stworzyłem nowy test, który działa poprawnie:

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

Warning: even in this version of test nie widać rzeczywistej różnicy, ponieważ klonowanie tablicy zajmuje większość czasu testu. To nadal pokazuje, że {[1] } jest najszybszym sposobem na wyczyszczenie tablicy (nie biorąc pod uwagę [], ponieważ chociaż jest najszybsza, to w rzeczywistości nie czyści istniejącej tablicy).

Jeśli jesteś zainteresowany alokacją pamięci, możesz porównać każde podejście, używając czegoś takiego jak Ten jsfiddle w połączeniu z zakładką timeline chrome Dev tools. Będziesz chciał użyć ikony kosza na dole, aby wymusić zbieranie śmieci po "wyczyszczeniu" tablicy. Powinno to dać bardziej konkretną odpowiedź dla wybranej przeglądarki. Wiele odpowiedzi tutaj jest starych i nie polegałbym na nich, ale raczej testuję jak w odpowiedzi @ tanguy_k powyżej.

(aby zapoznać się z wstępem do wspomnianej zakładki, Możesz sprawdzić tutaj)

Stackoverflow zmusza mnie do skopiowania jsfiddle więc oto jest:

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

I należy zauważyć, że może to zależeć od typu elementów tablicy, ponieważ javascript zarządza łańcuchami inaczej niż inne prymitywne typy, nie wspominając o tablicach obiektów. Typ może mieć wpływ na to, co się dzieje.

A.splice(0);

Zrobiłem to na jakimś kodzie, nad którym pracuję. Wyczyściło tablicę.

Jeśli używasz

a = []; 

Wtedy przypisujesz nową tablicę referencji do a, jeśli Referencja w a jest już przypisana do innej zmiennej, to nie opróżni również tej tablicy, a tym samym garbage collector nie zbierze tej pamięci.

Dla ex.

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

Lub

a.length = 0;

Kiedy określimy a.length, po prostu zresetujemy granice tablicy i pamięć dla elementów tablicy rest będzie podłączona przez garbage collector.

Zamiast tych dwóch rozwiązań są lepiej.

a.splice(0,a.length)

I

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

Zgodnie z poprzednią odpowiedzią kenshou.html, druga metoda jest szybsza.

Użyj zmodyfikowanej wersji początkowej sugestii Jana :

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

Jeśli używasz stałych to nie masz wyboru:

const numbers = [1, 2, 3]

Nie możesz reanimować:

numbers = []

Możesz tylko obciąć:

numbers.length = 0

Możesz łatwo utworzyć funkcję, aby to zrobić za Ciebie, Zmienić Długość lub nawet dodać ją do natywnej tablicy jako remove() funkcja do ponownego użycia.

Wyobraź sobie, że masz tę tablicę:

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

OK, po prostu uruchom to:

arr.length = 0; //change the length

A wynikiem jest:

[] //result

Łatwy sposób na opróżnienie tablicy...

Również za pomocą pętli, która nie jest konieczna, ale po prostu inny sposób, aby to zrobić:

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

Są też trudne sposoby, o których można pomyśleć, bo przykład coś takiego:

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

Więc jeśli arr ma 5 pozycji, połączy 5 pozycji z 0, co oznacza, że nic nie pozostanie w tablicy.

Również inne sposoby, takie jak na przykład ponowne przypisanie tablicy:

arr = []; //[]

Jeśli spojrzeć na funkcje tablicy, jest wiele innych sposobów, aby to zrobić, ale najbardziej zalecanym może być zmiana długości.

Tak jak powiedziałem w pierwszej kolejności, można również prototype remove (), ponieważ jest to odpowiedź na twoje pytanie. możesz po prostu wybierz jedną z powyższych metod i prototypuj ją do obiektu Array w JavaScript, coś w stylu:

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

I możesz po prostu wywołać go w ten sposób, aby opróżnić dowolną tablicę w aplikacji javascript:

arr.remove(); //[]

Dziwi mnie, że nikt jeszcze tego nie zasugerował:

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

To daje tablicę w zupełnie innym stanie niż inne rozwiązania. W pewnym sensie tablica została "opróżniona":

xs
=> Array [ <4 empty slots> ]

[...xs]
=> Array [ undefined, undefined, undefined, undefined ]

xs.length
=> 4

xs[0]
=> ReferenceError: reference to undefined property xs[0]

Możesz utworzyć równoważną tablicę z [,,,,] lub Array(4)

aby opróżnić bieżącą lokalizację pamięci tablicy użyj: 'myArray.length = 0' lub 'myArray.pop() UN-till its length is 0'

• length : w każdej chwili można ustawić właściwość length, aby obcinała tablicę. Po rozszerzeniu tablicy poprzez zmianę jej właściwości length, liczba rzeczywistych elementów wzrasta.
• pop() : metoda pop usuwa ostatni element z tablicy i zwraca, który zwraca usunięty element wartość.
• shift() : metoda shift usuwa element z zerowego indeksu i przesuwa wartości z kolejnych indeksów w dół, a następnie zwraca usuniętą wartość.

Przykład:

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() | [] Utwórz tablicę z nową lokalizacją pamięci za pomocą Array constructor lub 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() : za pomocą funkcji slice otrzymujemy płytką kopię elementów z oryginału tablica, z nowym adresem pamięci, tak aby jakakolwiek modyfikacja na cloneArr nie miała wpływu na rzeczywistą / oryginalną tablicę.

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

Użyj poniżej, jeśli chcesz opróżnić Angular 2 + FormArray.

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