Bagaimana cara mengosongkan array dalam JavaScript?

Apakah ada cara untuk mengosongkan array dan jika mungkin dengan .remove()?

Contohnya,

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

Bagaimana saya bisa mengosongkannya?

Cara menghapus array yang ada A:

Metode 1

(ini adalah jawaban asli saya untuk pertanyaan itu)

A = [];

Kode ini akan mengatur variabel Ake array kosong baru. Ini sempurna jika Anda tidak memiliki referensi ke array asli diA tempat lain karena ini benar-benar menciptakan array baru (kosong). Anda harus berhati-hati dengan metode ini karena jika Anda telah mereferensikan array ini dari variabel atau properti lain, array asli akan tetap tidak berubah. Hanya gunakan ini jika Anda hanya mereferensikan array dengan variabel aslinya A.

Ini juga solusi tercepat.

Contoh kode ini menunjukkan masalah yang dapat Anda temui saat menggunakan metode ini:

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

Metode 2 (seperti yang disarankan oleh Matthew Crumley )

A.length = 0

Ini akan menghapus array yang ada dengan menetapkan panjangnya ke 0. Beberapa berpendapat bahwa ini mungkin tidak bekerja di semua implementasi JavaScript, tetapi ternyata ini bukan masalahnya. Ini juga berfungsi ketika menggunakan "mode ketat" di ECMAScript 5 karena properti panjang array adalah properti baca / tulis.

Metode 3 (seperti yang disarankan oleh Anthony )

A.splice(0,A.length)

Menggunakan .splice()akan bekerja dengan sempurna, tetapi karena .splice()fungsi akan mengembalikan array dengan semua item yang dihapus, itu sebenarnya akan mengembalikan salinan dari array asli. Tingkatan yang dicapai menunjukkan bahwa ini tidak mempengaruhi kinerja apa pun.

Metode 4 (seperti yang disarankan oleh tanguy_k )

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

Solusi ini tidak terlalu ringkas, dan juga solusi paling lambat, bertentangan dengan tolok ukur sebelumnya yang dirujuk dalam jawaban asli.

Performa

Dari semua metode pembersihan array yang ada , metode 2 dan 3 sangat mirip dalam kinerjanya dan jauh lebih cepat daripada metode 4. Lihat benchmark ini .

Seperti yang ditunjukkan oleh Diadistis dalam jawaban mereka di bawah ini, tolok ukur asli yang digunakan untuk menentukan kinerja empat metode yang dijelaskan di atas cacat. Benchmark asli menggunakan kembali array yang telah dihapus sehingga iterasi kedua membersihkan sebuah array yang sudah kosong.

Tolok ukur berikut memperbaiki kekurangan ini: http://jsben.ch/#/hyj65 . Ini jelas menunjukkan bahwa metode # 2 (properti panjang) dan # 3 (sambatan) adalah yang tercepat (tidak menghitung metode # 1 yang tidak mengubah array asli).

Ini telah menjadi topik hangat dan menjadi penyebab banyak kontroversi. Sebenarnya ada banyak jawaban yang benar dan karena jawaban ini telah ditandai sebagai jawaban yang diterima untuk waktu yang sangat lama, saya akan memasukkan semua metode di sini. Jika Anda memilih jawaban ini, harap jawab dengan jawaban lain yang telah saya referensikan juga.

Jika Anda perlu mempertahankan array asli karena Anda memiliki referensi lain yang harus diperbarui juga, Anda dapat menghapusnya tanpa membuat array baru dengan menetapkan panjangnya ke nol:

A.length = 0;

Di sini, implementasi tercepat bekerja dengan tetap mempertahankan array yang sama ("bisa berubah"):

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

FYI tidak dapat disederhanakan menjadi while (array.pop()): tes akan gagal.

FYI Map and Set define clear(), akan terlihat logis clear()untuk Array juga.

Versi TypeScript:

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

Tes terkait:

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

Di sini jsPerf yang diperbarui: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

Solusi cross-browser yang lebih ramah dan lebih optimal adalah dengan menggunakan splicemetode ini untuk mengosongkan konten array A seperti di bawah ini:

A.splice(0, A.length);

Jawaban yang tidak kurang dari 2739 yang diputuskan sekarang menyesatkan dan salah.

Pertanyaannya adalah: "Bagaimana Anda mengosongkan array yang ada?" Misalnya untuk A = [1,2,3,4].

1. Mengatakan " A = []adalah jawabannya" bodoh dan sama sekali tidak benar. [] == []itu salah .

   Ini karena kedua array ini adalah dua objek terpisah, masing-masing, dengan dua identitas mereka sendiri, mengambil ruang mereka sendiri di dunia digital, masing-masing dengan sendirinya.

Katakanlah ibumu meminta Anda untuk mengosongkan tempat sampah.

• Anda tidak membawa yang baru seolah-olah Anda telah melakukan apa yang Anda minta.
• Sebaliknya, Anda mengosongkan tempat sampah.
• Anda tidak mengganti yang diisi dengan kaleng kosong yang baru, dan Anda tidak mengambil label "A" dari kaleng yang diisi dan menempelkannya ke yang baru seperti di A = [1,2,3,4]; A = [];

Mengosongkan objek array adalah yang termudah:

A.length = 0;

Dengan cara ini, kaleng di bawah "A" tidak hanya kosong, tetapi juga sebersih baru!

2. Selain itu, Anda tidak perlu membuang sampah dengan tangan sampai kalengnya kosong! Anda diminta untuk mengosongkan yang sudah ada, sepenuhnya, dalam satu giliran, untuk tidak mengambil sampah sampai kaleng kosong, seperti pada:

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

3. Juga, untuk meletakkan tangan kiri Anda di bagian bawah tempat sampah, memegangnya dengan tangan kanan Anda di bagian atas untuk dapat menarik isinya seperti pada:

   A.splice(0, A.length);

Tidak, Anda diminta mengosongkannya:

A.length = 0;

Ini adalah satu-satunya kode yang secara benar mengosongkan isi dari array JavaScript yang diberikan.

Uji kinerja:

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

Anda dapat menambahkan ini ke file JavaScript Anda untuk memungkinkan array Anda "dihapus":

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

Maka Anda dapat menggunakannya seperti ini:

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

Atau jika Anda ingin memastikan Anda tidak menghancurkan sesuatu:

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

Banyak orang berpikir Anda tidak boleh memodifikasi objek asli (seperti Array), dan saya cenderung setuju. Harap berhati-hati dalam memutuskan bagaimana menangani hal ini.

Ada banyak kebingungan dan informasi yang salah mengenai sementara; kinerja pop / shift baik dalam jawaban dan komentar. Solusi while / pop memiliki (seperti yang diharapkan) kinerja terburuk . Apa yang sebenarnya terjadi adalah bahwa pengaturan hanya berjalan satu kali untuk setiap sampel yang menjalankan cuplikan dalam satu lingkaran. misalnya:

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

Saya telah membuat tes baru yang berfungsi dengan benar:

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

Peringatan: bahkan dalam versi tes ini, Anda tidak dapat benar-benar melihat perbedaan nyata karena mengkloning array memakan sebagian besar waktu pengujian. Itu masih menunjukkan bahwa itu spliceadalah cara tercepat untuk menghapus array (tidak []mempertimbangkan karena sementara itu tercepat itu tidak benar-benar membersihkan array yang ada).

Jika Anda tertarik dengan alokasi memori, Anda dapat membandingkan setiap pendekatan menggunakan sesuatu seperti jsfiddle ini bersama dengan tab garis waktu alat dev krom. Anda akan ingin menggunakan ikon tempat sampah di bagian bawah untuk memaksa pengumpulan sampah setelah 'membersihkan' array. Ini akan memberi Anda jawaban yang lebih pasti untuk peramban pilihan Anda. Banyak jawaban di sini sudah tua dan saya tidak akan bergantung pada mereka melainkan menguji seperti pada jawaban @ tanguy_k di atas.

(untuk pengantar ke tab tersebut Anda dapat memeriksa di sini )

Stackoverflow memaksa saya untuk menyalin jsfiddle jadi ini dia:

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

Dan Anda harus mencatat bahwa itu mungkin tergantung pada jenis elemen array, karena javascript mengelola string berbeda dari tipe primitif lainnya, belum lagi array objek. Jenisnya dapat memengaruhi apa yang terjadi.

Anda dapat dengan mudah membuat fungsi untuk melakukan itu untuk Anda, mengubah panjangnya atau bahkan menambahkannya ke Array asli sebagai remove()fungsi untuk digunakan kembali.

Bayangkan Anda memiliki array ini:

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

Oke, jalankan saja ini:

arr.length = 0; //change the length

dan hasilnya adalah:

[] //result

cara mudah mengosongkan array ...

Juga menggunakan loop yang tidak perlu tetapi hanya cara lain untuk melakukan itu:

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

Ada juga cara rumit yang dapat Anda pikirkan, misalnya sesuatu seperti ini:

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

Jadi jika arr memiliki 5 item, itu akan memecah 5 item dari 0, yang berarti tidak ada yang tersisa dalam array.

Juga cara lain seperti cukup menetapkan kembali array misalnya:

arr = []; //[]

Jika Anda melihat fungsi Array, ada banyak cara lain untuk melakukan ini, tetapi yang paling direkomendasikan adalah mengubah panjangnya.

Seperti yang saya katakan di awal, Anda juga dapat membuat prototipe remove () karena itu adalah jawaban untuk pertanyaan Anda. Anda cukup memilih salah satu metode di atas dan membuat prototipe untuk objek Array di JavaScript, seperti:

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

dan Anda bisa menyebutnya seperti ini untuk mengosongkan array apa pun di aplikasi javascript Anda:

arr.remove(); //[]

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

Dan menyebutnya: array.clear();

A.splice(0);

Saya hanya melakukan ini pada beberapa kode yang sedang saya kerjakan. Itu membersihkan array.

Jika Anda menggunakan

a = []; 

Kemudian Anda menetapkan referensi array baru ke a, jika referensi dalam sudah ditugaskan ke variabel lain, maka itu tidak akan mengosongkan array itu juga dan karenanya pengumpul sampah tidak akan mengumpulkan memori itu.

Misalnya

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

atau

a.length = 0;

Ketika kita tentukan a.length , kami hanya mengatur ulang batas array dan memori untuk elemen array lainnya akan dihubungkan oleh pengumpul sampah.

Alih-alih kedua solusi ini lebih baik.

a.splice(0,a.length)

dan

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

Sesuai jawaban sebelumnya oleh kenshou.html, metode kedua lebih cepat.

Gunakan versi modifikasi dari saran awal Jan :

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

Jika Anda menggunakan konstanta maka Anda tidak punya pilihan:

const numbers = [1, 2, 3]

Anda tidak dapat menetapkan ulang:

numbers = []

Anda hanya dapat memotong:

numbers.length = 0

Untuk Mengosongkan Lokasi memori saat ini dari sebuah array gunakan: 'myArray.length = 0'atau'myArray.pop() UN-till its length is 0'

• length: Anda dapat mengatur properti panjang untuk memotong array kapan saja. Saat Anda memperluas array dengan mengubah properti panjangnya, jumlah elemen aktual bertambah.
• pop() : Metode pop menghapus elemen terakhir dari array dan mengembalikan yang mengembalikan nilai yang dihapus.
• shift(): Metode shift menghapus elemen pada indeks nol dan menggeser nilai pada indeks berturut-turut ke bawah, lalu mengembalikan nilai yang dihapus.

Contoh:

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() | [] Buat Array dengan lokasi memori baru dengan menggunakan Array constructoratau 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() : Dengan menggunakan fungsi slice kita mendapatkan salinan elemen yang dangkal dari array asli, dengan alamat memori baru, sehingga setiap modifikasi pada cloneArr tidak akan mempengaruhi ke array | asli yang sebenarnya.

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

Saya terkejut belum ada yang menyarankan ini:

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

Ini menghasilkan array dalam keadaan yang sangat berbeda dari solusi lain. Dalam arti tertentu, array telah 'dikosongkan':

xs
=> Array [ <4 empty slots> ]

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

xs.length
=> 4

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

Anda dapat menghasilkan array yang setara dengan [,,,,]atauArray(4)

Gunakan di bawah ini jika Anda perlu mengosongkan Angular 2+ FormArray.

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