Apa itu array dalam javascript?

Question

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

Table of Contents Show

Cara Mendeklarasikan Array dengan Notasi Literal
Cara Mendeklarasikan Array dengan Pembuat Array
Apa itu array dengan contoh?
Sebutkan 3 jenis array?

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

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

1 dan

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

1 mengembalikan elemen terakhir dari array, tetapi

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

alert( fruits.length ); // 3

1 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 ); // 3

6

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

8

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

8 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,Plum

1 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,Plum

3 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,Plum

5

Buat lubang, seperti. tambahkan

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

alert( fruits ); // Apple,Orange,Plum

1 dan kemudian

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

alert( fruits ); // Apple,Orange,Plum

7 (dan tidak ada apa pun di antara keduanya)

Isi array dengan urutan terbalik, seperti

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

alert( fruits ); // Apple,Orange,Plum

7,

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

alert( fruits ); // Apple,Orange,Plum

9 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](); // hello

0

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](); // hello

1 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](); // hello

2 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](); // hello

3. Elemen lain perlu diberi nomor ulang juga

Operasi

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

_7 harus melakukan 3 hal

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](); // hello

3

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](); // hello

6 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](); // hello

3, 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](); // hello

8 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](); // hello

6 dan seterusnya

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

8. 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](); // hello

1? . 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] ); // Plum

0

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] ); // Plum

1

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] ); // Plum

1

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

alert( fruits[0] ); // Apple
alert( fruits[1] ); // Orange
alert( fruits[2] ); // Plum

2

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

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

alert( fruits[fruits.length-1] ); // Plum
```
1 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
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] ); // Plum

1 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] ); // Plum

3

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] ); // Plum

5

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] ); // Plum

6

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] ); // Plum

7

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] ); // Plum

8

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

1

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?

Larik adalah kumpulan dari jenis data yang serupa . Misal kita ingin menyimpan nama 100 orang maka kita bisa membuat array bertipe string yang bisa menyimpan 100 nama. String[] array = string baru[100]; .