Pengenalan kepada ciri tatasusunan dalam kemahiran JavaScript_javascript

Tidak seperti bahasa Java, tatasusunan dalam JavaScript mempunyai tiga ciri:

1. Tiada jenis. Ahli tatasusunan boleh terdiri daripada sebarang jenis, dan tatasusunan yang sama juga boleh terdiri daripada banyak ahli daripada jenis yang berbeza.
2. Panjangnya berubah-ubah. Panjang tatasusunan boleh diubah secara dinamik, jadi tiada masalah akses tatasusunan di luar sempadan dalam JavaScript.
3. Ketaksinambungan. Kedudukan ahli dalam tatasusunan boleh berterusan (0, 1, 2, 3...) atau tidak selanjar. Mana-mana tatasusunan mempunyai atribut bernama panjang Apabila ahli tatasusunan adalah berterusan, nilai panjang adalah konsisten dengan bilangan ahli tatasusunan apabila ahli tatasusunan tidak berterusan, nilai panjang adalah lebih besar daripada bilangan ahli tatasusunan. Berbanding dengan tatasusunan berterusan, prestasi baca dan tulis tatasusunan tak selanjar adalah lebih teruk.

Percubaan:

Salin kod Kod adalah seperti berikut:

var o = [42, "Teks Contoh", {x:88}];//tatasusunan JavaScript tidak ditaip.
console.log(o);//[42, "Teks Contoh", Objek {x=88}]
o[3] = 27;// Tatasusunan JavaScript adalah dinamik.
console.log(o);//[42, "Teks Contoh", Objek {x=88}, 27]
o[5] = 99;// Tatasusunan JavaScript adalah jarang.
console.log(o);//[42, "Sample Text", Objek {x=88}, 27, undefined, 99]

Seperti yang anda lihat daripada contoh di atas, untuk tatasusunan terputus, JavaScript akan kembali tidak ditentukan apabila ahli yang hilang itu diakses. Jika tatasusunan berterusan tetapi salah satu ahlinya tidak ditentukan, hasil daripada mengakses tatasusunan adalah sama:

Salin kod Kod adalah seperti berikut:

var a = [42, "Sample Text", {x:88}, 27, undefined, 99];
console.log(a);//[42, "Sample Text", Objek {x=88}, 27, undefined, 99]

Tatasusunan tidak berterusan dan mempunyai ahli yang hilang, dan tatasusunan adalah bersebelahan tetapi mempunyai ahli yang tidak ditentukan Dalam kedua-dua kes, hasil yang diperoleh dengan mengakses kandungan tatasusunan adalah sama. Tetapi masih terdapat beberapa perbezaan halus antara keduanya, terutamanya dalam akses kepada kunci tatasusunan:

Salin kod Kod adalah seperti berikut:

console.log(4 in o);//false
console.log(4 dalam a);//true

Dapat dilihat bahawa walaupun keputusan yang diperoleh dengan mengakses kandungan adalah sama dalam kedua-dua kes ini, mekanisme dalaman mereka adalah berbeza sama sekali: apabila tatasusunan tidak berterusan, ahli tertentu hilang, jadi apabila ahli diakses, JavaScript kembali tidak ditentukan ; apabila tatasusunan berterusan, semua ahli wujud, tetapi nilai sesetengah ahli adalah istimewa dan tidak ditentukan.

Seperti yang anda boleh lihat daripada contoh di atas, tatasusunan dalam JavaScript pada asasnya hanyalah objek dengan nombor sebagai kunci dan tidak berbeza daripada pasangan nilai kunci biasa. Sebenarnya, apabila membaca dan menulis operasi pada tatasusunan, JavaScript akan cuba menukar parameter kepada integer positif Jika penukaran berjaya, operasi tatasusunan akan dilakukan (sifat panjang tatasusunan itu dikemas kini secara automatik). gagal, parameter akan ditukar menjadi aksara Selepas rentetan, operasi baca dan tulis pada objek biasa dilakukan. Sudah tentu, dalam pelaksanaan penterjemah JavaScript, banyak pengoptimuman prestasi telah dibuat untuk ciri tatasusunan yang menggunakan nombor sebagai kunci Oleh itu, dalam penggunaan sebenar, jika kunci objek adalah semua nombor, maka secara langsung menggunakan objek tatasusunan akan mendapat hasil yang lebih baik.

Semasa proses menentukan tatasusunan, JavaScript membenarkan koma berlebihan dan ahli tatasusunan hilang antara dua koma:

Salin kod Kod adalah seperti berikut:

var x = [1,2,3,];//koma di belakang akan ditiadakan.
console.log(x.length);//3
                                      
var y = [1,,3];//ahli boleh terlepas.
console.log(y);//[1, undefined, 3]
console.log(1 in y);//false
console.log(y.length);//3

Untuk penciptaan tatasusunan, JavaScript menyokong empat kaedah:

1. Gunakan literal (seperti ungkapan kurungan dalam contoh di atas) untuk terus mencipta objek tatasusunan.
2. Gunakan pembina Array() tanpa memasukkan sebarang parameter. Dalam kes ini, tatasusunan kosong dicipta, yang mempunyai kesan yang sama seperti [].
3. Gunakan pembina Array() dan hantarkan integer positif sebagai panjang tatasusunan. Dalam kes ini, JavaScript akan menempah ruang memori yang sepadan untuk menyimpan tatasusunan ini. Perlu diingat bahawa kunci tatasusunan tidak ditakrifkan pada masa ini, iaitu, tiada ahli dalam tatasusunan. Kesannya sama seperti [,,,,]
4. Gunakan pembina Array() dan masukkan ahli tatasusunan.

Percubaan:

Salin kod Kod adalah seperti berikut:

var z = Tatasusunan baharu(10);//pra-peruntukkan memori, tetapi tiada indeks ditakrifkan lagi.
console.log(3 dalam z);//false

var m = Tatasusunan baharu(42, 33, 99, "ujian", {k:99});
console.log(m);//[42, 33, 99, "test", Objek {k=99}]

Dalam standard ECMAScript 5, anda boleh menggunakan Array.isArray() untuk menentukan sama ada objek ialah tatasusunan:

Salin kod Kod adalah seperti berikut:

Array.isArray([]);//true
Array.isArray({});//false