Apa itu array dalam javascript?

Dalam JavaScript, array adalah salah satu tipe data yang paling umum digunakan. Ini menyimpan banyak nilai dan elemen dalam satu variabel

Nilai-nilai ini dapat berupa tipe data apa pun — artinya Anda dapat menyimpan string, angka, boolean, dan tipe data lainnya dalam satu variabel

Ada dua cara standar untuk mendeklarasikan array dalam JavaScript. Ini bisa melalui konstruktor array atau notasi literal

Jika Anda sedang terburu-buru, inilah tampilan array yang dideklarasikan dua arah

// Using array constructor let array = new array("John Doe", 24, true); // Using the literal notation let array = ["John Doe", 24, true];

Anda dapat melanjutkan membaca artikel ini untuk memahami metode ini dengan benar bersama beberapa opsi menarik lainnya yang mereka miliki

Cara Mendeklarasikan Array dengan Notasi Literal

Ini adalah cara paling populer dan termudah untuk membuat array. Ini adalah cara yang lebih pendek dan lebih bersih untuk mendeklarasikan array

Untuk mendeklarasikan array dengan notasi literal, Anda cukup mendefinisikan array baru menggunakan tanda kurung kosong. Sepertinya ini

let myArray = []; _

Anda akan menempatkan semua elemen di dalam tanda kurung siku dan memisahkan setiap item atau elemen dengan koma

let myArray = ["John Doe", 24, true];

Array diindeks nol, artinya Anda dapat mengakses setiap elemen mulai dari nol atau mengeluarkan seluruh array

console.log(myArray[0]); // 'John Doe' console.log(myArray[2]); // true console.log(myArray); // ['John Doe', 24, true]

Cara Mendeklarasikan Array dengan Pembuat Array

Anda juga dapat menggunakan konstruktor array untuk membuat atau mendeklarasikan array. Ada banyak teknis untuk mendeklarasikan array dengan konstruktor let myArray = []; 0

Sama seperti Anda dapat menyimpan banyak nilai dengan beragam tipe data dalam satu variabel dengan notasi literal array, Anda dapat melakukan hal yang sama dengan konstruktor array

let myArray = new Array(); console.log(myArray); // []

Di atas akan membuat array kosong baru. Anda dapat menambahkan nilai ke array baru dengan menempatkannya di antara tanda kurung, dipisahkan dengan koma

let myArray = new Array("John Doe", 24, true); _

Seperti yang Anda pelajari sebelumnya, Anda dapat mengakses setiap nilai menggunakan nomor indeksnya, yang dimulai dari nol (0)

console.log(myArray[0]); // 'John Doe' console.log(myArray[2]); // true console.log(myArray); // ['John Doe', 24, true]

Saat mendeklarasikan array dengan metode konstruktor array, penting untuk mengingat hal berikut

• Saat Anda memasukkan satu digit ke dalam konstruktor array, itu akan mengisi array dengan jumlah nilai kosong yang Anda masukkan

let myArray = new Array(4); console.log(myArray); // [,,,] _

Tapi ketika Anda melewatkan satu string atau tipe data lainnya, itu bekerja dengan baik

let myArray = new Array(true); console.log(myArray); // [true] _

• Tidak wajib menambahkan let myArray = []; _1, karena let myArray = []; 0 dan let myArray = []; 3 melakukan tugas yang sama

let myArray = Array("John Doe", 24, true);

Membungkus

Pada artikel ini, Anda telah mempelajari cara mendeklarasikan array dalam JavaScript. Penting untuk diketahui bahwa konstruktor array tidak benar-benar digunakan, karena jauh lebih rumit daripada menggunakan notasi literal array

Anda dapat mempelajari lebih lanjut dalam artikel ini di JavaScript Arrays - Cara Membuat Array di JavaScript oleh Jessica Wilkins

Bersenang-senang membuat kode

IKLAN

IKLAN

IKLAN

Joel Olawanle

Pengembang Frontend & Penulis Teknis

Jika Anda membaca sejauh ini, tweet ke penulis untuk menunjukkan bahwa Anda peduli. Tweet terima kasih

Belajar kode secara gratis. Kurikulum open source freeCodeCamp telah membantu lebih dari 40.000 orang mendapatkan pekerjaan sebagai pengembang. Memulai

Tetapi cukup sering kita menemukan bahwa kita membutuhkan koleksi yang dipesan, di mana kita memiliki elemen ke-1, ke-2, ke-3, dan seterusnya. Misalnya, kita membutuhkannya untuk menyimpan daftar sesuatu. pengguna, barang, elemen HTML, dll

Tidak nyaman menggunakan objek di sini, karena tidak menyediakan metode untuk mengelola urutan elemen. Kami tidak dapat memasukkan properti baru "di antara" yang sudah ada. Objek tidak dimaksudkan untuk penggunaan seperti itu

Terdapat struktur data khusus bernama fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]5, untuk menyimpan koleksi yang dipesan

Ada dua sintaks untuk membuat array kosong

let arr = new Array(); let arr = [];

Hampir sepanjang waktu, sintaks kedua digunakan. Kami dapat menyediakan elemen awal dalam tanda kurung

let fruits = ["Apple", "Orange", "Plum"];

Elemen array diberi nomor, dimulai dengan nol

Kita bisa mendapatkan elemen dengan nomornya dalam tanda kurung siku

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum

Kita dapat mengganti sebuah elemen

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]

…Atau tambahkan yang baru ke array

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]

Jumlah total elemen dalam array adalah fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]6

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits.length ); // 3

Kami juga dapat menggunakan fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_7 untuk menampilkan seluruh array

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum

Array dapat menyimpan elemen dari tipe apa pun

Contohnya

// mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello

Tanda koma

Array, seperti halnya objek, dapat diakhiri dengan koma

let fruits = [ "Apple", "Orange", "Plum", ];

Gaya “tanda koma” memudahkan penyisipan/penghapusan item, karena semua baris menjadi sama

Tambahan baru-baru ini

Ini adalah tambahan terbaru untuk bahasa ini. Browser lama mungkin memerlukan polyfill

Katakanlah kita menginginkan elemen terakhir dari array

Beberapa bahasa pemrograman mengizinkan penggunaan indeks negatif untuk tujuan yang sama, seperti fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]8

Meskipun, dalam JavaScript itu tidak akan berfungsi. Hasilnya adalah fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_9, karena indeks dalam tanda kurung siku diperlakukan secara harfiah

Kami dapat secara eksplisit menghitung indeks elemen terakhir dan kemudian mengaksesnya. fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_0

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[fruits.length-1] ); // Plum

Agak merepotkan, bukan?

Untungnya, ada sintaks yang lebih pendek. fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_1

let fruits = ["Apple", "Orange", "Plum"];_0

Dengan kata lain, fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]2

• persis sama dengan fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_3, jika fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]4
• untuk nilai negatif fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]5, ia mundur dari akhir larik

Antrian adalah salah satu penggunaan array yang paling umum. Dalam ilmu komputer, ini berarti kumpulan elemen yang teratur yang mendukung dua operasi

• fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_6 menambahkan elemen sampai akhir
• fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_7 mendapatkan elemen dari awal, memajukan antrian, sehingga elemen ke-2 menjadi elemen ke-1

Array mendukung kedua operasi

Dalam praktiknya kita sangat membutuhkannya. Misalnya, antrian pesan yang perlu ditampilkan di layar

Ada kasus penggunaan lain untuk array – struktur data bernama tumpukan

Ini mendukung dua operasi

• fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_6 menambahkan elemen sampai akhir
• fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_9 mengambil elemen dari akhir

Jadi elemen baru selalu ditambahkan atau diambil dari "akhir"

Tumpukan biasanya diilustrasikan sebagai satu pak kartu. kartu baru ditambahkan ke atas atau diambil dari atas

Untuk stack, item yang di push paling akhir diterima terlebih dahulu, yang disebut juga dengan prinsip LIFO (Last-In-First-Out). Untuk antrian, kami memiliki FIFO (First-In-First-Out)

Array dalam JavaScript dapat berfungsi baik sebagai antrian maupun sebagai tumpukan. Mereka memungkinkan Anda untuk menambah/menghapus elemen, baik ke/dari awal atau akhir

Dalam ilmu komputer, struktur data yang memungkinkan ini disebut deque

Metode yang bekerja dengan akhir array

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_9

Ekstrak elemen terakhir dari array dan mengembalikannya

let fruits = ["Apple", "Orange", "Plum"];_1

Baik let fruits = ["Apple", "Orange", "Plum"]; alert( fruits.length ); // 31 dan fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]1 mengembalikan elemen terakhir dari array, tetapi let fruits = ["Apple", "Orange", "Plum"]; alert( fruits.length ); // 31 juga mengubah array dengan menghapusnya

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_6

Tambahkan elemen ke akhir array

let fruits = ["Apple", "Orange", "Plum"];_2

Panggilan let fruits = ["Apple", "Orange", "Plum"]; alert( fruits.length ); // 3_5 sama dengan let fruits = ["Apple", "Orange", "Plum"]; alert( fruits.length ); // 36

Metode yang bekerja dengan awal array

fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_7

Ekstrak elemen pertama dari array dan mengembalikannya

let fruits = ["Apple", "Orange", "Plum"];_3

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits.length ); // 38

Tambahkan elemen ke awal array

let fruits = ["Apple", "Orange", "Plum"];_4

Metode fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]6 dan let fruits = ["Apple", "Orange", "Plum"]; alert( fruits.length ); // 38 dapat menambahkan beberapa elemen sekaligus

let fruits = ["Apple", "Orange", "Plum"];_5

Array adalah jenis objek khusus. Tanda kurung siku yang digunakan untuk mengakses properti let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum1 sebenarnya berasal dari sintaks objek. Itu pada dasarnya sama dengan let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum_2, di mana let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum3 adalah objeknya, sedangkan angka digunakan sebagai kunci

Mereka memperluas objek yang menyediakan metode khusus untuk bekerja dengan kumpulan data yang dipesan dan juga properti fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]6. Tapi pada intinya itu masih sebuah objek

Ingat, hanya ada delapan tipe data dasar dalam JavaScript (lihat bab Tipe data untuk info lebih lanjut). Array adalah objek dan karenanya berperilaku seperti objek

Misalnya, itu disalin dengan referensi

let fruits = ["Apple", "Orange", "Plum"];_6

…Tapi apa yang membuat array benar-benar spesial adalah representasi internalnya. Mesin mencoba menyimpan elemennya di area memori yang berdekatan, satu demi satu, seperti yang digambarkan pada ilustrasi di bab ini, dan ada juga pengoptimalan lainnya, untuk membuat larik bekerja sangat cepat

Tapi mereka semua rusak jika kita berhenti bekerja dengan array seperti "koleksi yang dipesan" dan mulai bekerja dengannya seolah-olah itu adalah objek biasa

Misalnya, secara teknis kita bisa melakukan ini

let fruits = ["Apple", "Orange", "Plum"];_7

Itu mungkin, karena array adalah objek pada dasarnya. Kami dapat menambahkan properti apa pun ke dalamnya

Tapi mesin akan melihat bahwa kita bekerja dengan array seperti objek biasa. Optimalisasi khusus array tidak cocok untuk kasus seperti itu dan akan dimatikan, manfaatnya akan hilang

Cara menyalahgunakan array

• Tambahkan properti non-numerik seperti let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum5
• Buat lubang, seperti. tambahkan let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum1 dan kemudian let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum7 (dan tidak ada apa pun di antara keduanya)
• Isi array dengan urutan terbalik, seperti let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum7, let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum9 dan seterusnya

Tolong pikirkan array sebagai struktur khusus untuk bekerja dengan data yang dipesan. Mereka menyediakan metode khusus untuk itu. Array disetel dengan hati-hati di dalam mesin JavaScript untuk bekerja dengan data berurutan yang berurutan, silakan gunakan dengan cara ini. Dan jika Anda memerlukan kunci arbitrer, kemungkinan besar Anda benar-benar memerlukan objek biasa // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello0

Metode // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello1 berjalan cepat, sedangkan // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello2 lambat

Mengapa bekerja dengan akhir array lebih cepat daripada dengan awalnya?

let fruits = ["Apple", "Orange", "Plum"];_8

Tidak cukup mengambil dan menghapus elemen dengan indeks // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello3. Elemen lain perlu diberi nomor ulang juga

Operasi fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_7 harus melakukan 3 hal

1. Hapus elemen dengan indeks // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello3
2. Pindahkan semua elemen ke kiri, beri nomor baru dari indeks // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello6 ke // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello3, dari // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello8 ke // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello6 dan seterusnya
3. Perbarui properti fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_6

Semakin banyak elemen dalam array, semakin banyak waktu untuk memindahkannya, semakin banyak operasi dalam memori

Hal serupa terjadi dengan let fruits = ["Apple", "Orange", "Plum"]; alert( fruits.length ); // 38. untuk menambahkan elemen ke awal array, pertama-tama kita perlu memindahkan elemen yang ada ke kanan, meningkatkan indeksnya

Dan ada apa dengan // mix of values let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ]; // get the object at index 1 and then show its name alert( arr[1].name ); // John // get the function at index 3 and run it arr[3](); // hello1? . Untuk mengekstrak elemen dari akhir, metode fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_9 membersihkan indeks dan mempersingkat fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]6

Tindakan untuk operasi fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_9

let fruits = ["Apple", "Orange", "Plum"];_9

Metode fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_9 tidak perlu memindahkan apa pun, karena elemen lain menyimpan indeksnya. Itu sebabnya ini sangat cepat

Hal serupa dengan metode fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_6

Salah satu cara tertua untuk menggilir item array adalah let fruits = [ "Apple", "Orange", "Plum", ];8 loop di atas indeks

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum0

Tapi untuk array ada bentuk lain dari loop, let fruits = [ "Apple", "Orange", "Plum", ];9

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum1

let fruits = [ "Apple", "Orange", "Plum", ];_9 tidak memberikan akses ke nomor elemen saat ini, hanya nilainya, tetapi dalam kebanyakan kasus itu sudah cukup. Dan itu lebih pendek

Secara teknis, karena array adalah objek, maka dimungkinkan juga untuk menggunakan let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[fruits.length-1] ); // Plum1

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum2

Tapi itu sebenarnya ide yang buruk. Ada potensi masalah dengan itu

1. Loop let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[fruits.length-1] ); // Plum1 mengulang semua properti, tidak hanya yang numerik

   Ada yang disebut objek "mirip larik" di browser dan di lingkungan lain, yang terlihat seperti larik. Yaitu, mereka memiliki fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_6 dan mengindeks properti, tetapi mereka mungkin juga memiliki properti dan metode non-numerik lainnya, yang biasanya tidak kita perlukan. The let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[fruits.length-1] ); // Plum_1 loop akan mencantumkannya. Jadi jika kita perlu bekerja dengan objek seperti array, maka properti "ekstra" ini bisa menjadi masalah

2. Loop let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[fruits.length-1] ); // Plum_1 dioptimalkan untuk objek generik, bukan array, dan karenanya 10-100 kali lebih lambat. Tentu saja, ini masih sangat cepat. Percepatan mungkin hanya penting dalam kemacetan. Tapi tetap saja kita harus menyadari perbedaannya

Umumnya, kita tidak boleh menggunakan let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[fruits.length-1] ); // Plum1 untuk array

Properti fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_6 secara otomatis diperbarui ketika kita memodifikasi array. Tepatnya, ini sebenarnya bukan jumlah nilai dalam array, tetapi indeks numerik terbesar plus satu

Misalnya, satu elemen dengan indeks besar memberikan panjang yang besar

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum3

Perhatikan bahwa kami biasanya tidak menggunakan array seperti itu

Hal lain yang menarik tentang properti fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_6 adalah properti ini dapat ditulisi

Jika kami meningkatkannya secara manual, tidak ada hal menarik yang terjadi. Tetapi jika kita menguranginya, array akan terpotong. Prosesnya tidak dapat diubah, inilah contohnya

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum_4

Jadi, cara paling sederhana untuk menghapus array adalah. let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[fruits.length-1] ); // Plum_9

Ada satu sintaks lagi untuk membuat array

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum5

Jarang digunakan, karena tanda kurung siku let fruits = ["Apple", "Orange", "Plum"];00 lebih pendek. Juga, ada fitur yang rumit dengannya

Jika let fruits = ["Apple", "Orange", "Plum"];_01 dipanggil dengan argumen tunggal yang berupa angka, maka ia akan membuat larik tanpa item, tetapi dengan panjang yang diberikan

Mari kita lihat bagaimana seseorang bisa menembak dirinya sendiri

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum6

Untuk menghindari kejutan seperti itu, kami biasanya menggunakan tanda kurung siku, kecuali kami benar-benar tahu apa yang kami lakukan

Array dapat memiliki item yang juga merupakan array. Kita bisa menggunakannya untuk array multidimensi, misalnya untuk menyimpan matriks

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum7

Array memiliki implementasi sendiri dari metode let fruits = ["Apple", "Orange", "Plum"];_02 yang mengembalikan daftar elemen yang dipisahkan koma

Contohnya

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum8

Juga, mari kita coba ini

let fruits = ["Apple", "Orange", "Plum"]; alert( fruits[0] ); // Apple alert( fruits[1] ); // Orange alert( fruits[2] ); // Plum_9

Array tidak memiliki let fruits = ["Apple", "Orange", "Plum"];03, juga ________16______04 yang layak, mereka hanya menerapkan let fruits = ["Apple", "Orange", "Plum"];02 konversi, jadi di sini let fruits = ["Apple", "Orange", "Plum"];00 menjadi string kosong, let fruits = ["Apple", "Orange", "Plum"];07 menjadi let fruits = ["Apple", "Orange", "Plum"];08 dan let fruits = ["Apple", "Orange", "Plum"];09 menjadi let fruits = ["Apple", "Orange", "Plum"];

Ketika operator binary plus let fruits = ["Apple", "Orange", "Plum"];_11 menambahkan sesuatu ke string, ia juga mengubahnya menjadi string, jadi langkah selanjutnya terlihat seperti ini

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_0

Array dalam JavaScript, tidak seperti beberapa bahasa pemrograman lainnya, tidak boleh dibandingkan dengan operator let fruits = ["Apple", "Orange", "Plum"];12

Operator ini tidak memiliki perlakuan khusus untuk array, ia bekerja dengannya seperti pada objek apa pun

Mari kita ingat aturannya

• Dua objek adalah sama let fruits = ["Apple", "Orange", "Plum"];_12 hanya jika keduanya mengacu pada objek yang sama
• Jika salah satu argumen dari let fruits = ["Apple", "Orange", "Plum"];_12 adalah objek, dan yang lainnya adalah primitif, maka objek akan diubah menjadi primitif, seperti yang dijelaskan dalam bab Konversi objek menjadi primitif
• …Dengan pengecualian let fruits = ["Apple", "Orange", "Plum"];15 dan fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]9 yang sama dengan let fruits = ["Apple", "Orange", "Plum"];12 satu sama lain dan tidak ada yang lain

Perbandingan ketat let fruits = ["Apple", "Orange", "Plum"];_18 bahkan lebih sederhana, karena tidak mengonversi tipe

Jadi, jika kita membandingkan array dengan let fruits = ["Apple", "Orange", "Plum"];12, mereka tidak akan pernah sama, kecuali jika kita membandingkan dua variabel yang mereferensikan array yang persis sama

Misalnya

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_1

Array ini secara teknis adalah objek yang berbeda. Jadi mereka tidak setara. Operator let fruits = ["Apple", "Orange", "Plum"];_12 tidak melakukan perbandingan item demi item

Perbandingan dengan primitif dapat memberikan hasil yang tampaknya aneh juga

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_2

Di sini, dalam kedua kasus, kami membandingkan primitif dengan objek array. Jadi array let fruits = ["Apple", "Orange", "Plum"];00 dikonversi menjadi primitif untuk tujuan perbandingan dan menjadi string kosong let fruits = ["Apple", "Orange", "Plum"];22

Kemudian proses perbandingan berlanjut dengan primitif, seperti yang dijelaskan di bab Konversi Jenis

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_3

Jadi, bagaimana cara membandingkan array?

Itu sederhana. jangan gunakan operator let fruits = ["Apple", "Orange", "Plum"];12. Sebagai gantinya, bandingkan item demi item dalam satu lingkaran atau gunakan metode iterasi yang dijelaskan di bab berikutnya

Array adalah jenis objek khusus, cocok untuk menyimpan dan mengelola item data yang dipesan

Deklarasi

fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_4

Panggilan ke let fruits = ["Apple", "Orange", "Plum"];_24 membuat array dengan panjang tertentu, tetapi tanpa elemen

• Properti fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_6 adalah panjang array atau, tepatnya, indeks numerik terakhirnya ditambah satu. Ini disesuaikan secara otomatis dengan metode array
• Jika kita mempersingkat fruits[2] = 'Pear'; // now ["Apple", "Orange", "Pear"]_6 secara manual, array akan terpotong

Mendapatkan elemen

• kita bisa mendapatkan elemen dengan indeksnya, seperti let fruits = ["Apple", "Orange", "Plum"]; alert( fruits ); // Apple,Orange,Plum1
• juga kita dapat menggunakan metode let fruits = ["Apple", "Orange", "Plum"];_28 yang memungkinkan indeks negatif. Untuk nilai negatif fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_5, ia mundur dari akhir larik. Jika fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]_4, ini berfungsi sama seperti fruits[3] = 'Lemon'; // now ["Apple", "Orange", "Pear", "Lemon"]3

Kita dapat menggunakan array sebagai deque dengan operasi berikut

• let fruits = ["Apple", "Orange", "Plum"];_32 menambahkan let fruits = ["Apple", "Orange", "Plum"];33 sampai akhir
• let fruits = ["Apple", "Orange", "Plum"];_34 menghapus elemen dari akhir dan mengembalikannya
• let fruits = ["Apple", "Orange", "Plum"];_35 menghapus elemen dari awal dan mengembalikannya
• let fruits = ["Apple", "Orange", "Plum"];_36 menambahkan let fruits = ["Apple", "Orange", "Plum"];33 ke awal

Untuk mengulang elemen-elemen array

• let fruits = ["Apple", "Orange", "Plum"];_38 – bekerja tercepat, kompatibel dengan browser lama
• let fruits = ["Apple", "Orange", "Plum"];_39 – sintaks modern untuk item saja,
• let fruits = ["Apple", "Orange", "Plum"];_40 – tidak pernah digunakan

Untuk membandingkan array, jangan gunakan operator let fruits = ["Apple", "Orange", "Plum"];12 (serta let fruits = ["Apple", "Orange", "Plum"];42, let fruits = ["Apple", "Orange", "Plum"];43 dan lainnya), karena tidak ada perlakuan khusus untuk array. Mereka menanganinya sebagai objek apa pun, dan itu bukan yang biasanya kita inginkan

Sebagai gantinya, Anda dapat menggunakan let fruits = [ "Apple", "Orange", "Plum", ];9 loop untuk membandingkan array item demi item

Kami akan melanjutkan dengan array dan mempelajari lebih banyak metode untuk menambah, menghapus, mengekstrak elemen, dan mengurutkan array di bab berikutnya Metode array

Apa itu array dengan contoh?

Sebutkan 3 jenis array?