• Terjemahan

Kebanyakan aplikasi yang dibangunkan hari ini memerlukan interaksi dengan beberapa jenis set data. Mengendalikan elemen dalam koleksi ialah operasi biasa yang mungkin anda temui. Apabila bekerja, sebagai contoh, dengan tatasusunan, anda boleh, tanpa berfikir, menggunakan gelung untuk biasa, yang kelihatan seperti ini: untuk (var i=0; i< value.length; i++){} . Однако, лучше, всё-таки, смотреть на вещи шире.

Katakan kita perlu memaparkan senarai produk, dan, jika perlu, bahagikannya ke dalam kategori, tapis, lakukan carian padanya, ubah suai senarai ini atau elemennya. Mungkin anda perlu melakukan beberapa pengiraan dengan cepat yang melibatkan unsur-unsur senarai. Katakan anda perlu menambah sesuatu dengan sesuatu, darabkan sesuatu dengan sesuatu. Adakah mungkin untuk mencari alat dalam JavaScript yang membolehkan anda menyelesaikan masalah sedemikian dengan lebih cepat dan lebih mudah daripada menggunakan gelung untuk biasa?

Malah, terdapat kemudahan sedemikian dalam JavaScript. Sebahagian daripada mereka dibincangkan dalam bahan, terjemahan yang kami sampaikan kepada perhatian anda hari ini. Khususnya, kita bercakap tentang operator spread, gelung for...of, dan kaedah includes(), some(), every(), filter(), map() dan reduce(). Kami kebanyakannya akan bercakap tentang tatasusunan di sini, tetapi teknik yang dibincangkan di sini biasanya sesuai untuk bekerja dengan jenis objek lain.

Perlu diingatkan bahawa ulasan pendekatan moden Pembangunan JS biasanya termasuk contoh yang disediakan menggunakan fungsi anak panah. Mungkin anda tidak menggunakannya dengan kerap - mungkin kerana anda tidak menyukainya, mungkin kerana anda tidak mahu menghabiskan terlalu banyak masa mempelajari sesuatu yang baharu, atau mungkin ia tidak sesuai untuk anda. Oleh itu, di sini, dalam kebanyakan situasi, dua pilihan untuk melakukan tindakan yang sama akan ditunjukkan: menggunakan fungsi biasa(ES5) dan menggunakan fungsi anak panah (ES6). Bagi mereka yang baru bekerja dengan fungsi anak panah, fungsi anak panah bukanlah setara dengan pengisytiharan fungsi dan ungkapan fungsi. Anda tidak sepatutnya menggantikan satu dengan yang lain. Khususnya, ini disebabkan oleh fakta bahawa dalam fungsi biasa dan anak panah kata kunci ini berkelakuan berbeza.

1. Operator sambungan

Operator spread membenarkan anda untuk "mengembangkan" tatasusunan dengan menggantikan elemen mereka dan bukannya tatasusunan di tempat di mana operator ini digunakan. Pendekatan yang sama telah dicadangkan untuk literal objek.

▍Kekuatan pengendali pengembangan

• Ia mudah dan cara cepat"tarik keluar" elemen individunya daripada tatasusunan.
• Operator ini sesuai untuk bekerja dengan tatasusunan dan literal objek.
• Ini ialah kaedah yang pantas dan intuitif untuk bekerja dengan hujah fungsi.
• Operator sambungan tidak mengambil banyak ruang dalam kod - ia kelihatan seperti tiga titik (...).

▍Contoh

Katakan anda ditugaskan untuk menyenaraikan hidangan kegemaran anda tanpa menggunakan gelung. Menggunakan operator sambungan ini dilakukan seperti ini:

2. Gelung untuk…daripada

Pernyataan for…of direka untuk melintasi objek boleh lelar. Ia memberikan akses kepada elemen individu objek tersebut (khususnya, kepada elemen tatasusunan), yang, sebagai contoh, membolehkannya diubah suai. Ia boleh dianggap sebagai pengganti yang biasa untuk gelung.

▍Kekuatan gelung for…of

• Ini ialah cara mudah untuk menambah atau mengemas kini item koleksi.
• Gelung for…of membolehkan anda melakukan pelbagai pengiraan menggunakan elemen (penjumlahan, pendaraban dan sebagainya).
• Ia mudah digunakan apabila anda perlu menyemak sebarang syarat.
• Penggunaannya membawa kepada penulisan kod yang lebih bersih dan lebih mudah dibaca.

▍Contoh

Katakan anda mempunyai struktur data yang menerangkan kandungan kotak alat dan anda mahu memaparkan alat tersebut. Berikut ialah cara melakukannya menggunakan gelung for...of:

3. Kaedah termasuk().

Kaedah includes() digunakan untuk menyemak sama ada elemen tertentu terdapat dalam koleksi, khususnya, sebagai contoh, garisan tertentu dalam tatasusunan yang mengandungi rentetan. Kaedah ini mengembalikan benar atau salah bergantung kepada keputusan ujian. Apabila menggunakannya, ia patut dipertimbangkan bahawa ia adalah sensitif huruf besar. Jika, sebagai contoh, koleksi mengandungi elemen rentetan SCHOOL , dan termasuk() menyemak kehadirannya menggunakan string school , kaedah itu akan mengembalikan false .

▍Kekuatan kaedah termasuk().

• Kaedah includes() berguna dalam mencipta mekanisme pengambilan data yang mudah.
• Ia memberikan pembangun intuitif jalan yang jelas menentukan kehadiran data tertentu dalam tatasusunan.
• Ia mudah digunakan dalam ungkapan bersyarat untuk mengubah suai, menapis elemen dan melaksanakan operasi lain.
• Penggunaannya membawa kepada kebolehbacaan kod yang lebih baik.

▍Contoh

Katakan anda mempunyai garaj, diwakili oleh susunan dengan senarai kereta, dan anda tidak tahu sama ada kereta tertentu berada di garaj ini atau tidak. Untuk menyelesaikan masalah ini, anda perlu menulis kod yang membolehkan anda menyemak sama ada kereta berada di dalam garaj. Mari gunakan kaedah includes():

4. beberapa () kaedah

Kaedah some() membolehkan anda menyemak sama ada beberapa elemen yang anda cari wujud dalam tatasusunan. Berdasarkan keputusan semakan, ia mengembalikan benar atau salah . Ia serupa dengan kaedah includes() di atas, kecuali hujahnya ialah fungsi dan bukannya, sebagai contoh, rentetan biasa.

▍Kekuatan kaedah some().

• Kaedah some() membolehkan kami menyemak sama ada tatasusunan mengandungi sekurang-kurangnya satu elemen yang kami minati.
• Ia melakukan ujian keadaan menggunakan fungsi yang dihantar kepadanya.
• Kaedah ini mudah digunakan.

▍Contoh

Katakan anda pemilik kelab, dan secara amnya, anda tidak berminat dengan siapa sebenarnya yang datang ke kelab anda. Bagaimanapun, sesetengah pelawat tidak dibenarkan memasuki kelab itu, kerana mereka terdedah kepada pengambilan minuman beralkohol secara berlebihan, menurut sekurang-kurangnya, seandainya mereka mendapati diri mereka berada dalam pertubuhan kamu sendiri, dan tiada seorang pun bersama mereka yang dapat menjaga mereka. DALAM dalam kes ini sekumpulan pelawat boleh memasuki kelab hanya jika sekurang-kurangnya seorang daripada mereka berumur sekurang-kurangnya 18 tahun. Untuk mengautomasikan semakan jenis ini, kami akan menggunakan kaedah some(). Di bawah aplikasinya ditunjukkan dalam dua versi.

ES5

ES6

5. Setiap () kaedah

Kaedah every() berulang melalui tatasusunan dan menguji setiap elemen terhadap keadaan tertentu, mengembalikan benar jika semua elemen tatasusunan sepadan dengan syarat, dan palsu sebaliknya. Anda boleh melihat bahawa ia adalah serupa dengan kaedah some().

▍Kekuatan kaedah every().

• Kaedah every() membolehkan anda menyemak sama ada semua elemen tatasusunan memenuhi syarat.
• Syarat boleh ditetapkan menggunakan fungsi.
• Ia menggalakkan pendekatan deklaratif kepada pengaturcaraan.

▍Contoh

Mari kita kembali kepada contoh sebelumnya. Di sana anda membenarkan pelawat bawah 18 ke dalam kelab, tetapi seseorang menulis kenyataan kepada polis, selepas itu anda mendapati diri anda berada dalam situasi yang tidak menyenangkan. Selepas semuanya diselesaikan, anda memutuskan bahawa anda tidak memerlukan semua ini dan mengetatkan peraturan untuk melawat kelab. Kini sekumpulan pelawat boleh memasuki kelab hanya jika setiap ahli kumpulan itu berumur sekurang-kurangnya 18 tahun. Seperti kali terakhir, kami akan mempertimbangkan untuk menyelesaikan masalah dalam dua versi, tetapi kali ini kami akan menggunakan kaedah every().

ES5

ES6

6. kaedah penapis().

Kaedah penapis() membolehkan anda membuat, berdasarkan tatasusunan, tatasusunan baharu, yang mengandungi hanya elemen tatasusunan sumber yang memenuhi syarat tertentu.

▍Kekuatan kaedah penapis().

• Kaedah penapis() mengelakkan pengubahsuaian tatasusunan asal.
• Ia membolehkan anda menyingkirkan unsur-unsur yang tidak perlu.
• Ia meningkatkan kebolehbacaan kod.

▍Contoh

Katakan anda perlu memilih daripada senarai harga hanya yang lebih besar daripada atau sama dengan 30. Mari gunakan kaedah penapis() untuk menyelesaikan masalah ini.

ES5

ES6

7. Kaedah Peta().

Kaedah map() adalah serupa dengan kaedah penapis() kerana ia juga mengembalikan tatasusunan baharu. Walau bagaimanapun, ia digunakan untuk mengubah suai elemen tatasusunan asal.

▍Kekuatan kaedah map().

• Kaedah map() mengelakkan keperluan untuk menukar elemen tatasusunan asal.
• Ia boleh digunakan untuk mengubah suai elemen tatasusunan dengan mudah.
• Ia meningkatkan kebolehbacaan kod.

▍Contoh

Katakan anda mempunyai senarai produk dengan harga. Pengurus anda perlukan senarai baru barangan yang harganya dikurangkan sebanyak 25%. Mari gunakan kaedah map() untuk menyelesaikan masalah ini.

ES5

ES6

8. kaedah mengurangkan().

Kaedah reduce(), dalam bentuk yang paling mudah, membolehkan anda menjumlahkan elemen tatasusunan angka. Dalam erti kata lain, ia mengurangkan tatasusunan kepada satu nilai. Ini membolehkan anda menggunakannya untuk melakukan pelbagai pengiraan.

▍Kekuatan kaedah reduce().

• Menggunakan kaedah reduce(), anda boleh mengira jumlah atau purata unsur-unsur tatasusunan.
• Kaedah ini mempercepatkan dan memudahkan pengiraan.

▍Contoh

Katakan anda perlu mengira perbelanjaan anda untuk minggu itu, yang disimpan dalam tatasusunan. Mari selesaikan masalah ini menggunakan kaedah reduce().

ES5

ES6

Tambah tag

Dalam artikel ini kita akan melihat tatasusunan JavaScript dan komponennya. JavaScript direka bentuk secara ideal untuk pengaturcaraan. Malah, ia melaksanakan bahasa ECMAScript (standard ECMA-262).

Di manakah JavaScript digunakan? Ia digunakan sebagai bahasa terbenam untuk menentukan laluan perisian kepada subjek permohonan. Ia boleh didapati dalam pelayar di mana ia digunakan sebagai bahasa skrip yang menjadikan halaman web interaktif.

Ciri seni bina yang paling penting bagi produk ini ialah penaipan dinamik dan lemah, pengurusan memori automatik, pengaturcaraan sempurna dan fungsi objek kelas pertama.

Secara umum, JavaScript telah dipengaruhi sebab yang berbeza, kerana semasa pembangunan mereka ingin mencipta bahasa yang serupa dengan Java, tetapi mudah untuk pengaturcara digunakan. Ngomong-ngomong, bahasa JavaScript tidak dimiliki oleh mana-mana syarikat atau organisasi, yang menjadikannya tidak seperti beberapa gaya pengaturcaraan yang digunakan oleh pembangun web.

Perlu diingatkan bahawa JavaScript telah didaftarkan tanda dagangan kebimbangan Oracle Corporation.

Apakah tatasusunan?

Tatasusunan ialah satu yang menyimpan nilai bernombor. Setiap nilai tersebut dipanggil komponen tatasusunan, dan digit yang dikaitkan dengan komponen itu dipanggil indeks. Tatasusunan JavaScript tidak ditaip. Ini bermakna bahagian-bahagian tatasusunan boleh terdiri daripada sebarang jenis, dan bahagian-bahagian yang berlainan kepunyaan tatasusunan yang sama mempunyai jenis yang sama sekali berbeza.

Di samping itu, tatasusunan JavaScript adalah dinamik, yang bermaksud itu saiz tetap tidak perlu mengisytiharkan. Lagipun, anda boleh menambah butiran baharu pada bila-bila masa.

Pengeluaran tatasusunan

Menggunakan JavaScript, membuat tatasusunan tidak sukar sama sekali. Terdapat dua kaedah untuk ini. Yang pertama melibatkan mencipta tatasusunan menggunakan kurungan literal - segi empat sama, di dalamnya terdapat senarai bahagian, dipisahkan dengan koma.

• var kosong = ; // tatasusunan kosong;
• nombor var = ; //array dengan lima komponen digital;
• var diff = ; //array dengan tiga elemen daripada jenis yang berbeza.

Lazimnya, nilai di sini tidak diperlukan untuk menjadi mudah (rentetan dan nombor). Ia juga boleh menjadi sebarang ungkapan lain, contohnya, literal subjek, fungsi dan tatasusunan lain.

Cara kedua untuk mencipta tatasusunan ialah memanggil pereka Array(). Anda boleh menjemputnya dalam tiga cara:

• Memanggil pereka tanpa hujah: var b - new Array(). Ini menyediakan untuk penciptaan tatasusunan kosong, bersamaan dengan literal kosong.
• Pembina secara eksplisit menyatakan nilai n komponen tatasusunan: var b = Tatasusunan baru (1, 3, 5, 8, "rentetan", benar). Dalam kes ini, pereka bentuk dibentangkan dengan senarai argumen yang diubah menjadi komponen tatasusunan baharu. Argumen ditulis pada tatasusunan di lokasi di mana ia ditentukan.
• Menentukan kawasan untuk penetapan nilai seterusnya. Ini dilakukan dengan menyatakan, apabila mengenal pasti tatasusunan, nombor tunggal yang disertakan dalam kurungan: var b = Tatasusunan baharu(5). Kaedah ini pengenalan melibatkan memperuntukkan bilangan komponen yang diperlukan kepada tatasusunan (setiap satunya disenaraikan sebagai tidak ditentukan) dengan kemungkinan seterusnya memberikan nilai semasa proses pembentangan. Borang ini biasanya digunakan untuk pra-peruntukkan tatasusunan Javascript yang panjangnya diketahui terlebih dahulu.

Menulis, membaca dan menambah butiran tatasusunan

Anda boleh mengakses komponen tatasusunan menggunakan operator. By the way, semua komponen dalam JavaScript, bermula dari sifar, bernombor. Untuk mendapatkan elemen yang diperlukan, nombornya ditunjukkan dalam Sebagai peraturan, butiran boleh ditukar. Dan untuk menambah JavaScript pada tatasusunan, anda hanya perlu menetapkan nilai baharu.

Perlu diingatkan bahawa tatasusunan JavaScript boleh menyimpan sebarang bilangan elemen dalam apa jua bentuk.

Panjang tatasusunan

Jadi, kita tahu bahawa panjang tatasusunan secara amnya merupakan fenomena yang menarik. Mari kita lihat lebih dekat. Semua tatasusunan, sama ada dibina menggunakan pereka bentuk Array() atau didedahkan melalui literal tatasusunan, mempunyai sifat panjang tertentu yang menunjukkan jumlah bilangan elemen yang disimpan. Memandangkan tatasusunan mungkin mengandungi bahagian yang tidak ditentukan (ditandakan dengan tidak ditentukan), ungkapan yang lebih tepat ialah: kualiti panjang sentiasa lebih besar daripada yang paling banyak. bilik besar(indeks) komponen tatasusunan. Kualiti panjang dilaraskan secara automatik, kekal tepat apabila bahagian baharu muncul dalam tatasusunan.

Untuk membuat komponen akhir tatasusunan muncul, anda boleh menggunakan sifat panjang.

Bahagian terakhir mempunyai indeks satu kurang daripada saiz tatasusunan. Lagipun, kira detik sentiasa bermula dari awal. Oh, JavaScript ini! Panjang tatasusunan bergantung pada bilangan elemen yang tepat. Jadi, jika anda tidak tahu berapa banyak yang perlu ada, tetapi anda perlu mengakses elemen akhir tatasusunan, anda perlu menggunakan tatatanda: v.length - 1.

Mengulangi butiran tatasusunan

Selalunya sifat panjang digunakan untuk mengulangi butiran tatasusunan dalam gelung:

• var buah = [“strawberi”, “pic”, “epal”, “pisang”];
• untuk(var I = 0; i< fruits.lenght; i++);
• document.write(buah[i] + "...").

Dalam contoh ini, komponen kelihatan diletakkan secara berterusan dan bermula dengan bahagian pertama yang memiliki indeks sifar. Jika ini tidak berlaku, sebelum memanggil setiap elemen tatasusunan, anda perlu menyemak sama ada ia ditakrifkan.

Gelung juga kadangkala digunakan untuk memulakan komponen.

Tumbuh dan Potong Array

Saya tertanya-tanya bagaimana menggunakan lidah Rentetan JavaScript tambah pada tatasusunan? Semasa kami bekerja dengan tatasusunan, panjang kualiti bertambah baik secara automatik, itulah sebabnya kami perlu menjaganya sendiri. Perlu diingat satu butiran - sifat panjang bukan sahaja boleh dibaca, tetapi juga boleh ditulis. Jika kualiti panjang diberikan nilai yang lebih kecil daripada saiz semasa, maka tatasusunan dikurangkan kepada saiz yang ditentukan. Mana-mana komponen yang tiada dalam julat indeks baharu akan dibuang dan nilainya hilang, walaupun panjang kemudian dikembalikan - nilai tidak dipulihkan.

Agak mudah untuk mengosongkan tatasusunan seperti ini: foo.length = 0.

Jika kualiti panjang dibuat lebih besar daripada nilai semasanya, bahagian baru yang tidak dikenal pasti akan muncul pada penghujung tatasusunan, yang akan meningkatkannya kepada saiz yang dikehendaki.

Mengeluarkan Bahagian Corak

Operator padam menentukan nilai yang tidak ditentukan dalam komponen tatasusunan, tetapi ia terus wujud. Jika anda perlu mengalih keluar elemen tatasusunan JavaScript supaya bahagian yang tinggal dipindahkan ke ruang kosong, anda perlu menggunakan salah satu kaedah tatasusunan yang disediakan. Kaedah Array.shift() menghapuskan komponen pertama, pop() menghapuskan komponen akhir, dan kaedah splice() menghapuskan satu atau julat komponen di mana-mana dalam tatasusunan.

Tatasusunan berbilang dimensi

Nampaknya kami telah menyelesaikan sedikit perkara Tatasusunan dua dimensi- itu yang perlu dipertimbangkan seterusnya. Adakah anda masih ingat bahawa tatasusunan JavaScript boleh mengandungi elemen lain sebagai komponen? Ciri ini digunakan untuk pengeluaran tatasusunan berbilang dimensi. Untuk melawati komponen dalam tatasusunan, hanya gunakan kurungan segi empat sama dua kali.

Susunan Bersekutu

Sekarang mari kita kaji bagaimana tanda dagangan JavaScript bersekutu menggunakan tatasusunan. Untuk melakukan ini, kita perlu melihat ke dalam teori: tatasusunan bersekutu kadang-kadang dipanggil jadual cincang. Terima kasih kepada mereka, rentetan digunakan dan bukannya indeks. Menggunakan binaan sedemikian adalah serupa dengan menggunakan nama harta objek mudah, tetapi dalam pilihan ini semasa melaksanakan kerja dalam format tatasusunan. Memandangkan JavaScript tidak mempunyai cara untuk beroperasi dengan tatasusunan bersekutu, ia digunakan lebih kurang kerap daripada yang biasa. Perlu diingatkan bahawa mereka masih boleh berguna untuk menyimpan data dan menjadikannya lebih mudah untuk mengingati butiran yang perlu diakses.

Output tatasusunan

Apakah yang akan kita pelajari tentang JavaScript sekarang? Memaparkan tatasusunan dalam kotak dialog (pada skrin monitor), serta memaparkan nilai komponen tatasusunan.

Jika anda perlu memaparkan nilai semua komponen dalam program, maka adalah mudah untuk menggunakan pernyataan for. Menariknya, pembolehubah pembilang bagi peraturan digunakan sebagai indeks komponen tatasusunan.

Pembersihan

Untuk menapis Tatasusunan JavaScript, anda perlu menetapkan semula panjangnya:

• var myArray = ;
• myArray.length = 0.

• jelas: function() (;
• ini.panjang = 0;
• kembalikan ini;

Menambah dan mengalih keluar komponen

Baiklah, mari kita sambung mengkaji ini dengan lebih lanjut. bahasa yang paling menarik JavaScript. Elemen tatasusunan boleh dipadamkan atau ditambah dengan cara yang sama seperti sifat biasa objek lain. Tetapi terdapat beberapa perbezaan di sini: apabila menambah sifat berangka kualiti panjang boleh berubah, dan apabila mengubah suai sifat panjang, kualiti berangka boleh dihapuskan. Pada dasarnya, algoritma untuk menetapkan kualiti untuk tatasusunan adalah seperti berikut:

• Apabila menambah sifat digital i yang tidak diketahui, jika panjang sama dengan atau kurang daripada i, panjang ditakrifkan sebagai i+1.
• Apabila kualiti berubah panjang, tindakan berikut: jika nilai yang diberikan adalah kurang daripada sifar, maka RangeError dilemparkan. Semua kualiti berangka dan indeks yang sama dengan panjang baharu dan yang lebih besar akan dihapuskan.

Secara umum, memadamkan elemen tatasusunan JavaScript tidak sukar. Lagipun, walaupun semasa menetapkan panjang, anda perlu mengeluarkan komponen "tambahan" daripadanya. Ini membawa kepada pilihan untuk mengosongkan tatasusunan. Jika atas sebab tertentu pembolehubah yang ditetapkan bagi tatasusunan baharu yang kosong tidak memuaskan, dan perlu menetapkan semula yang semasa, sudah cukup untuk menetapkan nilai sifar kepada kualiti panjangnya.

kaedah unshift, shift, pop dan push

Walaupun komponen tatasusunan diubah suai secara manual, ramai orang mengesyorkan menggunakan kaedah terbina dalam untuk ini. Nuansa inilah yang menjamin nilai kualiti panjang yang betul dan ketiadaan jurang dalam tatasusunan. Dengan cara ini, kualiti panjang yang betul akan sepadan dengan bilangan komponen.

Kaedah tolak menggerakkan bahagian yang dilalui ke hujung tatasusunan. Kaedah pop memberikan kembali komponen mengekor dan mengeluarkannya.

Umumnya dalam internet Explorer lebih awal daripada versi kelapan, unshift mungkin kembali tidak ditentukan; dalam pelayar lain, nilai panjang baharu. Jadi adalah lebih baik untuk tidak bergantung pada nilai yang dikembalikan daripada unshift.

Menambah dan menghapuskan bahagian di tengah tatasusunan

Jika saya perlu memadamkan tatasusunan JavaScript, apakah yang perlu saya lakukan? Kaedah splice diketahui mempunyai Array.prototype.splice tandatangan.

Ia mengalih keluar komponen deleteCount daripada tatasusunan, bermula dengan penunjuk mula. Jika lebih daripada dua hujah diluluskan, maka semua hujah seterusnya dalam tatasusunan diletakkan bukannya argumen yang dihapuskan. Jika permulaan adalah negatif, maka indeks dari mana pengeluaran akan disambung semula akan sama dengan panjang + permulaan. Tatasusunan dikembalikan daripada elemen yang dialih keluar.

Malah, menggunakan kaedah sambatan, anda boleh mengalih keluar komponen dari tengah tatasusunan atau menambah sebarang nombor ke mana-mana tempat dalam tatasusunan.

Dalam versi paling mudah, jika anda perlu mengalih keluar komponen dengan indeks i, anda perlu meminta kaedah splice daripada tatasusunan dengan parameter i dan 1.

Pada dasarnya, parameter kedua kaedah splice adalah pilihan, tetapi kelakuan fungsi dengan satu hujah adalah berbeza dalam setiap penyemak imbas.

Contohnya, dalam Firefox, dalam variasi terkini Opera, dalam Safari dan dalam Chrome, semua butiran sehingga penghujung tatasusunan akan dialih keluar.

Tiada komponen akan dihapuskan dalam IE. Dalam variasi pertama Opera, adalah mustahil untuk meramalkan tingkah laku - satu bahagian dengan permulaan indeks - 1 akan dialih keluar. Oleh itu, sentiasa perlu untuk kaedah ini lulus sekurang-kurangnya dua komponen.

kunci

Sudah tentu, semasa mempelajari JavaScript, tatasusunan bersekutu, seperti yang dinyatakan sebelum ini, juga perlu diingat. Ini ialah jenis maklumat abstrak (antara muka kepada storan data), yang membolehkan anda menyimpan pasangan borang "(kunci, nilai)" dan menyokong operasi menambah pasangan, serta memadam dan mencari pasangan dengan kunci:

CARI (kunci).

INSERT (nilai, kunci).

KELUARKAN (kunci).

Diandaikan bahawa dua pasangan dengan kunci yang serupa tidak boleh disimpan dalam tatasusunan bersekutu. Dalam pasangan k + v, v dipanggil nilai yang dikaitkan dengan kunci k. Semantik dan nama operasi di atas mungkin berbeza dalam pelaksanaan berbeza tatasusunan tersebut.

Oleh itu, tindakan FIND (kunci) mengembalikan nilai yang dikaitkan dengan kunci yang diberikan, atau beberapa objek UNDEF tertentu yang menunjukkan bahawa tiada nilai yang dikaitkan dengan kunci yang diberikan. Dua tindakan lain tidak mengembalikan apa-apa (kecuali sama ada operasi itu berjaya).

Secara umum, dari sudut pandangan antara muka, adalah mudah untuk mempertimbangkan tatasusunan bersekutu sebagai tatasusunan mudah di mana bukan sahaja integer, tetapi juga nilai jenis lain - sebagai contoh, rentetan - boleh digunakan sebagai indeks.

Dengan cara ini, sokongan untuk tatasusunan sedemikian tersedia dalam banyak tafsiran bahasa pengaturcaraan tahap tinggi, seperti PHP, Perl, Ruby, Python, Tcl, JavaScript dan lain-lain. Untuk bahasa yang tidak mempunyai alat terbina dalam untuk bekerja dengan tatasusunan bersekutu, sejumlah besar pelaksanaan dalam bentuk perpustakaan telah dibuat.

Contoh tatasusunan bersekutu boleh layan buku telefon. Dalam versi ini, maksudnya ialah kompleks "F. alamat I. O. +”, dan kuncinya ialah nombor telefon. satu nombor telefon mempunyai seorang pemilik, tetapi seorang boleh memiliki beberapa nombor.

Sambungan bersekutu

Perlu diingatkan bahawa yang paling sambungan yang diketahui termasuk tindakan berikut:

• SETIAP - "lalui" semua pasangan yang disimpan.
• CLEAR - keluarkan semua rekod.
• MIN - cari pasangan dengan nilai kunci terkecil.
• MAX - cari pasangan dengan nilai kunci terbesar.

Dua pilihan terakhir memerlukan kekunci menunjukkan tindakan perbandingan.

Pelaksanaan tatasusunan bersekutu

Terdapat banyak pelaksanaan yang berbeza tatasusunan bersekutu. Pelaksanaan yang paling biasa mungkin berdasarkan tatasusunan mudah, yang komponennya adalah pasangan (nilai, kunci). Untuk mempercepatkan tindakan carian, anda boleh menyusun komponen daripada tatasusunan ini dengan kunci dan cari menggunakan Tetapi ini akan meningkatkan tempoh masa yang diperlukan untuk menambah pasangan baharu, kerana perlu "mengalihkan" komponen tatasusunan untuk membungkus rekod baharu ke dalam sel kosong yang muncul.

Pelaksanaan yang paling terkenal adalah yang berdasarkan pelbagai pepohon carian. Sebagai contoh, dalam pembaca C++ STL biasa, bekas peta dilaksanakan berdasarkan pokok hitam-mahoni. Gaya Ruby, Tcl, Python menggunakan satu jenis jadual hash. Terdapat pelaksanaan lain.

Secara umumnya, setiap perlaksanaan mempunyai kelemahan dan kelebihan yang tersendiri. Adalah penting bahawa ketiga-tiga tindakan dilakukan secara purata dan dalam nuansa terburuk sepanjang tempoh O(log n), di mana n ialah bilangan pasangan semasa yang disimpan. Untuk pokok carian dipadankan (termasuk pokok hitam-merah), syarat ini dipenuhi.

Pelaksanaan berasaskan jadual hash diketahui mempunyai purata masa O(1), yang lebih baik daripada pelaksanaan berasaskan pepohon carian. Sudah tentu, ini tidak menjamin pelaksanaan berkelajuan tinggi bagi operasi individu: masa INSERT kes terburuk dilambangkan sebagai O(n). Proses INSERT berjalan masa yang lama, apabila faktor isian mencapai titik tertinggi dan ia menjadi perlu untuk membina semula indeks jadual cincang.

Ngomong-ngomong, senarai cincang ini tidak baik kerana ia tidak boleh digunakan untuk melaksanakan dengan pantas tindakan tambahan MAX, MIN dan algoritma untuk melintasi semua pasangan yang disimpan dalam susunan kekunci menurun atau menaik.

Tatasusunan ialah salah satu jenis pembolehubah yang paling biasa digunakan yang membolehkan anda menyimpan banyak nilai berurutan dalam "satu tempat." Walau bagaimanapun, apabila ia berkaitan dengan JavaScript, terdapat ruang untuk penambahbaikan.

Dalam artikel ini, kita akan melihat tiga teknik yang kurang diketahui yang boleh digunakan apabila bekerja dengan tatasusunan.

1. Menambah sifat tersuai pada tatasusunan

Jika anda menggunakan carian untuk mencari definisi tatasusunan dalam bahasa JavaScript, maka kebanyakan sumber akan mendakwa bahawa jenis ini Nilai pembolehubah diwakili sebagai objek.

Secara umumnya, banyak perkara yang kita temui dalam JavaScript adalah objek. Adalah adil untuk diperhatikan bahawa bahasa itu juga mengandungi jenis data "primitif", tetapi nilainya entah bagaimana digunakan dalam sifat di dalam objek.

2. Mengakses elemen tatasusunan dalam gelung

Memandangkan indeks tatasusunan hanya boleh mengambil nilai positif, pengiraan bermula dari sifar. Kemudian kita boleh menggunakan indeks ini untuk mengakses elemen tatasusunan pada lelaran gelung yang diberikan.

ECMAScript6 memperkenalkan cara untuk menatal melalui tatasusunan tanpa menggunakan indeks, tetapi melalui gelung untuk…daripada yang baharu.

Gelung for...of direka bentuk untuk melelaran melalui elemen tatasusunan tanpa menjejaskan indeks elemen.

Var ary = ["oren","epal","laici"]; untuk (biar item ary)( console.log(item); ) // "oren", "epal", "laici" Sebagai perbandingan: mengeluarkan indeks item dalam gelung for. var ary = ["oren","epal","laici"]; untuk (var item = 0; item< ary.length; item++){ console.log(item); } // 0, 1, 2

3. Bilangan elemen bukan dimensi tatasusunan

Apabila kita bercakap tentang saiz tatasusunan, kita biasanya menganggapnya sebagai bilangan elemen yang disimpan di dalamnya. Malah, ini tidak sepenuhnya benar - sifat panjang dikira bergantung pada indeks maksimum elemen.

Sifat panjang sangat samar-samar. Untuk mengesahkan ini, lihat sahaja manipulasi berikut:

Var ary = ; ary.panjang = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6

Dalam contoh terakhir, sudah cukup untuk meletakkan elemen di kedudukan kelima, akibatnya panjang tatasusunan menjadi 6. Jika anda berfikir bahawa indeks dari 0 hingga 4 akan dibuat secara automatik, anda akan silap. Ini boleh disemak menggunakan operator dalam.

Var ary = ; ary.panjang = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 console.log(0 dalam ary); // salah

Dalam kes ini, adalah adil untuk memanggil tatasusunan ary "jarang".

Kami juga boleh memanipulasi sifat panjang untuk memangkas tatasusunan. Contoh di bawah menunjukkan "kehilangan" elemen pada indeks 5 dengan mengurangkan sifat panjang tatasusunan ary.

Var ary = ; ary.panjang = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 ary.length = 2; console.log(ary.length); // 2 console.log(ary); // tidak ditentukan

• Terjemahan

• I. Mengulang ke atas tatasusunan sebenar
  1. untukSetiap kaedah dan kaedah yang berkaitan
  2. untuk gelung
  3. Penggunaan yang Betul untuk...dalam gelung
  4. for...of loop (penggunaan tersirat iterator)
  5. Penggunaan iterator secara eksplisit
• 1. Menggunakan kaedah untuk mengulangi tatasusunan sebenar
  2. Tukar kepada tatasusunan sebenar
  3. Nota pada objek masa jalan

I. Mengulang ke atas tatasusunan sebenar

hidup masa ini Terdapat tiga cara untuk mengulangi elemen tatasusunan sebenar:

1. kaedah Array.prototype.forEach ;
2. klasik untuk gelung
3. "betul" dibina untuk...dalam gelung.

Di samping itu, tidak lama lagi, dengan kemunculan standard ECMAScript 6 (ES 6) baharu, dua lagi kaedah dijangka:

1. for...of loop (penggunaan tersirat iterator);
2. penggunaan eksplisit iterator.

1. Kaedah untukSetiap dan kaedah yang berkaitan

Jika projek anda direka bentuk untuk menyokong ciri standard ECMAScript 5 (ES5), anda boleh menggunakan salah satu daripada inovasinya - kaedah forEach.

Contoh penggunaan:
var a = ["a", "b", "c"]; a.forEach(function(entry) ( console.log(entry); ));
Secara umum, menggunakan forEach memerlukan penyambungan perpustakaan emulasi es5-shim untuk penyemak imbas yang tidak mempunyai sokongan orang asli kaedah ini. Ini termasuk IE 8 dan ke atas versi awal, yang masih digunakan di sana sini.

Kelebihan forEach ialah tidak perlu mengisytiharkan pembolehubah tempatan untuk menyimpan indeks dan nilai elemen tatasusunan semasa, kerana ia dihantar secara automatik ke fungsi panggil balik sebagai argumen.

Jika anda bimbang tentang kemungkinan kos panggilan balik pada setiap elemen, jangan risau dan baca ini.

ForEach direka bentuk untuk mengulangi semua elemen tatasusunan, tetapi sebagai tambahan kepadanya, ES5 menawarkan beberapa kaedah yang lebih berguna untuk lelaran melalui semua atau beberapa elemen serta melakukan beberapa tindakan padanya:

• setiap - mengembalikan benar jika untuk setiap elemen tatasusunan panggilan balik mengembalikan nilai yang boleh ditukar kepada benar.
• sesetengah - mengembalikan benar jika untuk sekurang-kurangnya satu elemen tatasusunan panggilan balik mengembalikan nilai yang boleh ditukar kepada benar.
• penapis - mencipta tatasusunan baharu yang merangkumi unsur tatasusunan asal yang mana panggilan balik itu kembali benar.
• peta - mencipta tatasusunan baharu yang terdiri daripada nilai yang dikembalikan oleh panggilan balik.
• mengurangkan - mengurangkan tatasusunan kepada satu nilai, menggunakan panggilan balik pada setiap elemen tatasusunan secara bergilir-gilir, bermula dengan yang pertama (boleh berguna untuk mengira jumlah elemen tatasusunan dan fungsi ringkasan lain).
• reduceRight - berfungsi sama seperti mengurangkan, tetapi berulang melalui elemen dalam susunan terbalik.

2. Untuk gelung

Baik lama untuk peraturan:

Var a = ["a", "b", "c"]; indeks var; untuk (indeks = 0; indeks< a.length; ++index) { console.log(a); }
Jika panjang tatasusunan adalah malar sepanjang gelung, dan gelung itu sendiri tergolong dalam bahagian kritikal prestasi kod (yang tidak mungkin), maka anda boleh menggunakan "lebih optimum" versi untuk dengan menyimpan panjang tatasusunan:

Var a = ["a", "b", "c"]; indeks var, len; untuk (indeks = 0, len = a.panjang; indeks< len; ++index) { console.log(a); }
Secara teorinya, kod ini sepatutnya berjalan sedikit lebih cepat daripada yang sebelumnya.

Jika susunan elemen tidak penting, maka anda boleh pergi lebih jauh dari segi pengoptimuman dan menyingkirkan pembolehubah untuk menyimpan panjang tatasusunan, menukar susunan carian ke sebaliknya:

Var a = ["a", "b", "c"]; indeks var; untuk (indeks = a.panjang - 1; indeks >= 0; --index) ( console.log(a); )
Walau bagaimanapun, dalam enjin JavaScript moden permainan pengoptimuman seperti itu biasanya tidak bermakna apa-apa.

3. Penggunaan yang betul bagi...dalam gelung

Jika anda dinasihatkan untuk menggunakan for...in loop, ingat bahawa lelaran ke atas tatasusunan bukanlah perkara yang dimaksudkan. Bertentangan dengan salah tanggapan biasa, gelung for...in tidak berulang ke atas indeks tatasusunan, sebaliknya melalui sifat terhitung objek.

Walau bagaimanapun, dalam beberapa kes, seperti mengulangi tatasusunan yang jarang, untuk...in boleh berguna, selagi anda mengambil langkah berjaga-jaga, seperti yang ditunjukkan dalam contoh di bawah:

// a - tatasusunan jarang var a = ; a = "a"; a = "b"; a = "c"; untuk (kunci var dalam a) ( jika (a.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key<= 4294967294) { console.log(a); } }
Dalam contoh ini, dua semakan dilakukan pada setiap lelaran gelung:

1. bahawa tatasusunan mempunyai sifatnya sendiri yang dipanggil kunci (tidak diwarisi daripada prototaipnya).
2. kunci itu ialah rentetan yang mengandungi perwakilan perpuluhan bagi integer yang nilainya kurang daripada 4294967294 . Dari mana datangnya nombor terakhir? Daripada definisi indeks tatasusunan dalam ES5, yang menunjukkan bahawa indeks tertinggi yang boleh dimiliki oleh sesuatu elemen dalam tatasusunan ialah: (2^32 - 2) = 4294967294 .

Sudah tentu, semakan sedemikian akan mengambil masa yang tidak perlu apabila melaksanakan gelung. Tetapi dalam kes tatasusunan jarang, kaedah ini lebih cekap daripada gelung for, kerana dalam kes ini hanya unsur-unsur yang ditakrifkan secara eksplisit dalam tatasusunan diulang. Jadi, dalam contoh di atas, hanya 3 lelaran akan dilakukan (untuk indeks 0, 10 dan 10000) - berbanding 10001 dalam gelung for.

Untuk tidak menulis kod semak yang menyusahkan setiap kali anda perlu mengulangi tatasusunan, anda boleh menulisnya sebagai fungsi yang berasingan:

Fungsi arrayHasOwnIndex(array, key) ( return array.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key<= 4294967294; }
Kemudian badan gelung dari contoh akan dikurangkan dengan ketara:

Untuk (masukkan a) ( jika (arrayHasOwnIndex(a, kunci)) ( console.log(a); ) )
Kod semak yang dibincangkan di atas adalah universal, sesuai untuk semua kes. Tetapi sebaliknya, anda boleh menggunakan versi yang lebih pendek, walaupun secara rasmi tidak betul sepenuhnya, tetapi sesuai untuk kebanyakan kes:

Untuk (masukkan a) ( jika (a.hasOwnProperty(key) && String(parseInt(key, 10)) === key) ( console.log(a); ) )

4. Untuk...gelung (penggunaan tersirat lelaran)

ES6, masih dalam status draf, harus memperkenalkan iterator kepada JavaScript.

Iterator ialah protokol yang dilaksanakan oleh objek yang mentakrifkan cara standard untuk mendapatkan urutan nilai (terhingga atau tidak terhingga).
Iterator ialah objek yang mentakrifkan kaedah next() - fungsi tanpa hujah yang mengembalikan objek dengan dua sifat:

1. done (boolean) - benar jika iterator telah mencapai penghujung urutan boleh lelar. Jika tidak, nilainya adalah palsu.
2. nilai - mentakrifkan nilai yang dikembalikan oleh iterator. Mungkin tidak ditentukan (hilang) jika harta yang dilakukan adalah benar.

Banyak objek terbina dalam, termasuk. tatasusunan sebenar mempunyai iterator secara lalai. Cara paling mudah untuk menggunakan iterator pada tatasusunan sebenar ialah menggunakan yang baharu untuk...daripada konstruk.

Contoh penggunaan untuk...daripada:

Varval; var a = ["a", "b", "c"]; untuk (val of a) ( console.log(val); )
Dalam contoh di atas, gelung for...of secara tersirat memanggil lelaran objek Array untuk mendapatkan setiap nilai tatasusunan.

5. Penggunaan iterator secara eksplisit

Iterator juga boleh digunakan secara eksplisit, walau bagaimanapun, dalam kes ini kod menjadi lebih rumit berbanding dengan gelung for...of. Ia kelihatan seperti ini:

Var a = ["a", "b", "c"]; var it = a.entry(); entri var; manakala (!(entry = it.next()).done) ( console.log(entry.value); )
Dalam contoh ini, kaedah Array.prototype.enries mengembalikan iterator yang digunakan untuk memaparkan nilai tatasusunan. Pada setiap lelaran, entry.value mengandungi tatasusunan bentuk [kunci, nilai] .

II. Mengulangi objek seperti tatasusunan

Sebagai tambahan kepada tatasusunan sebenar, dalam JavaScript terdapat juga objek seperti tatasusunan . Apa yang mereka ada persamaan dengan tatasusunan sebenar ialah mereka mempunyai sifat panjang dan sifat yang dinamakan sebagai nombor yang sepadan dengan unsur tatasusunan. Contohnya termasuk DOM koleksi NodeList dan argumen pseudo-array, tersedia dalam mana-mana fungsi/kaedah.

1. Menggunakan kaedah untuk lelaran ke atas tatasusunan sebenar

Sekurang-kurangnya, kebanyakan, jika tidak semua, kaedah lelaran ke atas tatasusunan sebenar boleh digunakan untuk lelaran ke atas objek seperti tatasusunan.

Konstruk untuk dan untuk...dalam boleh digunakan pada objek seperti tatasusunan dengan cara yang sama seperti ia digunakan pada tatasusunan sebenar.

ForEach dan kaedah Array.prototype yang lain juga digunakan pada objek seperti tatasusunan. Untuk melakukan ini, anda perlu menggunakan Function.call atau Function.apply .

Sebagai contoh, jika anda ingin memohon untukEach kepada sifat childNodes bagi objek Node, anda akan melakukannya seperti ini:

Array.prototype.forEach.call(node.childNodes, function(child) ( // lakukan sesuatu dengan objek kanak-kanak));
Untuk menjadikan helah ini lebih mudah digunakan semula, anda boleh mengisytiharkan rujukan kepada kaedah Array.prototype.forEach dalam pembolehubah berasingan dan menggunakannya sebagai pintasan:

// (Dengan mengandaikan semua kod di bawah adalah dalam skop yang sama) var forEach = Array.prototype.forEach; // ... forEach.call(node.childNodes, function(child) ( // buat sesuatu dengan objek kanak-kanak));
Jika objek seperti tatasusunan mempunyai iterator, ia boleh digunakan secara eksplisit atau tersirat untuk lelaran ke atas objek dengan cara yang sama seperti tatasusunan sebenar.

2. Tukar kepada tatasusunan sebenar

Terdapat juga satu lagi cara yang sangat mudah untuk mengulangi objek seperti tatasusunan: menukarnya menjadi tatasusunan sebenar dan gunakan mana-mana kaedah yang dibincangkan di atas untuk mengulangi tatasusunan sebenar. Untuk penukaran, anda boleh menggunakan kaedah Array.prototype.slice generik, yang boleh digunakan pada mana-mana objek seperti tatasusunan. Ini dilakukan dengan sangat mudah, seperti yang ditunjukkan dalam contoh di bawah:

Var trueArray = Array.prototype.slice.call(arrayLikeObject, 0);
Contohnya, jika anda ingin menukar koleksi NodeList kepada tatasusunan sebenar, anda memerlukan kod seperti ini:

Var divs = Array.prototype.slice.call(document.querySelectorAll("div"), 0);
Kemas kini: Seperti yang dinyatakan dalam komen

Mari belajar cara mengindeks tatasusunan dalam js, mengalih keluar dan menambah elemennya.

Tatasusunan dalam JavaScript ialah objek global yang direka untuk menyimpan senarai nilai.

Ia serupa dengan pembolehubah lain kerana ia boleh menyimpan sebarang jenis data. Tetapi tatasusunan mempunyai satu perbezaan penting daripada pembolehubah: ia boleh menyimpan lebih daripada satu elemen pada satu masa.

Tatasusunan ialah himpunan nilai tersusun. Setiap nilai dipanggil elemen dan mempunyai nombor sendiri, dipanggil indeks.

Elemen di dalam tatasusunan boleh terdiri daripada sebarang jenis. Selain itu, unsur-unsur satu tatasusunan boleh terdiri daripada pelbagai jenis: nombor, rentetan, elemen logik, dan juga objek atau tatasusunan lain.

Susunan elemen tatasusunan bermula dari 0. Ternyata tatasusunan akan sentiasa mempunyai indeks yang diimbangi oleh satu: elemen pertama akan mempunyai indeks 0, yang kedua 1, dsb.

Berikut ialah contoh tatasusunan dengan unsur-unsur jenis yang berbeza:

Mencipta (mengisytiharkan) tatasusunan

Tatasusunan sangat mudah kerana ia boleh menyimpan seberapa banyak data yang anda perlukan. Saiz maksimum yang mungkin bagi tatasusunan js ialah 2 32 elemen.

Kita perlu memberitahu JavaScript bahawa kita ingin membuat tatasusunan. Terdapat dua pilihan untuk ini: nilai dalam kurungan segi empat sama atau kata kunci baharu.

Notasi pendek: menggunakan kurungan segi empat sama

Senarai nilai yang dipisahkan koma yang disertakan dalam kurungan segi empat sama.

var myArray = [ "Jack", "Sawyer", "John", "Desmond" ];

Kandungan tatasusunan ditentukan oleh apa yang ada di antara kurungan segi empat sama. Setiap nilai dipisahkan dengan koma.

Nilai ditentukan dengan cara yang sama seperti pembolehubah mudah, iaitu, rentetan mesti diisytiharkan disertakan dalam petikan, dsb.

Untuk mengisytiharkan tatasusunan kosong, biarkan kurungan kosong:

var myArray = ;

Entri panjang: menggunakan pembina Array().

var lostArray = new Array("Jack", "Sawyer", "John", "Desmond"); var twinPeaksArray = new Array("Laura", 2, ["Bob", "Leland", "Dale"]);

Kata kunci baharu memberitahu JavaScript untuk membuat tatasusunan baharu yang nilainya diluluskan sebagai parameter.

Jika anda tahu terlebih dahulu berapa banyak elemen yang akan ada dalam tatasusunan anda, anda boleh segera menghantar nilai ini dalam pembina.

var myArray = new Array(80);

Ungkapan di atas akan mencipta tatasusunan kosong yang terdiri daripada 80 slot dengan nilai yang tidak ditentukan.

Mengisytiharkan tatasusunan kosong:

var myArray = new Array();

Mengakses Elemen Tatasusunan

Menggunakan indeks setiap elemen, anda boleh bekerja dengan mana-mana data dalam tatasusunan, mengaksesnya menggunakan operator:

var myArray = ["Jack", "Sawyer", "John", "Desmond"]; console.log(myArray); // Mencetak "Jack" console.log(myArray); // Mencetak "Desmond"

Tatasusunan boleh mempunyai beberapa peringkat, iaitu setiap elemen itu sendiri boleh menjadi tatasusunan. Hasilnya ialah tatasusunan js dua dimensi. Bagaimanakah kita boleh mengakses tatasusunan ini yang terletak di dalam yang lain - " tatasusunan berbilang dimensi»?

Sebagai contoh, mari kita pertimbangkan tatasusunan yang mewakili keluarga. Kanak-kanak daripada keluarga ini direkodkan dalam tatasusunan berasingan di dalam yang utama:

var familyArray = ["Marge", "Homer", ["Bart", "Lisa", "Maggie"]];

Anda boleh bayangkan seperti ini:

Untuk merujuk kepada nilai "Lisa":

var lisa = familyArray; console.log(lisa); // memaparkan "Lisa"

Ini boleh diteruskan hampir tanpa had, yang membolehkan anda menyimpan set data bersarang dalam tatasusunan dan mengaksesnya menggunakan indeks.

Menambah elemen pada tatasusunan

Kami mengetahui cara untuk mengakses elemen tatasusunan menggunakan indeks yang sepadan. Dengan cara yang sama, anda boleh menambah (atau menukar) elemen dengan mengisytiharkan, sebagai contoh:

var myArray = ["Kate", "Sun"]; myArray = "Juliet"; console.log(myArray); // Mencetak "Kate, Sun, Juliet"

Apakah yang berlaku jika saya mengisytiharkan elemen dengan indeks yang tidak mempunyai elemen lain sebelum itu? Tatasusunan itu sendiri akan mencipta semua elemen yang hilang dan memberikan mereka nilai undefined :

var myArray = ["Kate", "Sun"]; myArray = "Juliet"; console.log(myArray.length); // Mencetak "6" console.log(myArray); // Cetakan ["Kate", "Sung", undefined, undefined, undefined, "Juliet"]

Anda boleh mengetahui panjang tatasusunan js dengan menggunakan sifat panjang. Dalam contoh di atas, terdapat enam elemen dalam tatasusunan, dan tiga daripadanya belum diberi nilai - ia ditandakan sebagai tidak ditentukan .

kaedah push().

Menggunakan kaedah push(), anda boleh menambah satu atau lebih elemen pada tatasusunan js. Push() menerima bilangan parameter yang tidak terhad, kesemuanya akan ditambahkan pada penghujung tatasusunan.

var myArray = ["Kate", "Sut"]; myArray.push("Juliet"); // Menambah elemen "Juliet" pada penghujung tatasusunan myArray.push("Libby", "Shannon"); // Menambah elemen "Libby" dan "Shannon" pada penghujung array console.log(myaArray ); // Mencetak ["Kate", "Soon", "Juliet", "Libby", "Shannon"]

kaedah unshift().

Kaedah unshift() berfungsi sama seperti push(), kecuali ia menambahkan elemen pada permulaan tatasusunan.

var myArray = ["Kate", "Sun"]; myArray.unshift("Juliet"); // Menambah elemen "Juliet" pada permulaan tatasusunan myArray.unshift("Libby", "Shannon"); // Menambah elemen "Libby" dan "Shannon" pada permulaan array console.log(myArray); // Output ["Libby", "Shannon", "Juliet", "Kate", "Soon"]

Mengalih keluar Elemen Tatasusunan

kaedah pop() dan shift().

Kaedah pop() dan shift() mengalih keluar elemen terakhir dan pertama tatasusunan, masing-masing:

var myArray = ["Jack", "Sawyer", "John", "Desmond", "Kate"]; myArray.pop(); // Mengalih keluar elemen "Kate" myArray.shift(); // Mengalih keluar elemen "Jack" console.log(myArray); // Cetakan ["Sawyer", "John", "Desmond"]

kaedah splice().

Menggunakan kaedah splice(), anda boleh mengalih keluar atau menambah elemen pada tatasusunan, sambil menentukan indeks unsur dengan tepat.

Dalam contoh berikut, kaedah splice() menambah dua elemen bermula pada indeks 2 ( iaitu daripada unsur ketiga):

var fruitArray = ["epal", "pic", "oren", "lemon", "limau", "ceri"]; fruitArray.splice(2, 0, "melon", "banana"); console.log(fruitArray); // Output ["epal", "pic", "tembikai", "pisang", "oren", "lemon", "limau", "ceri"]

Parameter pertama kaedah splice() ialah indeks. Ia menunjukkan pada kedudukan elemen yang perlu ditambah/dialih keluar. Dalam contoh kami, kami memilih indeks 2 ( bermaksud "oren").

Parameter kedua ialah bilangan elemen yang perlu dialih keluar. Kami menetapkan nilai 0, jadi tiada apa yang akan dipadamkan.

Parameter berikut adalah pilihan. Mereka menambah nilai baharu pada tatasusunan. Dalam kes kita, kita perlu menambah "tembikai" dan "pisang", bermula dengan indeks 2.