Array & Method-nya
Array adalah struktur data paling sering digunakan di JavaScript. Artikel ini membahas cara membuat dan mengakses array, method mutasi dan non-mutasi, map/filter/reduce, sort, spread operator, dan destructuring dengan contoh praktis.
- Pendahuluan
- Membuat Array
- Mengakses Elemen
- Method Mutasi vs Non-Mutasi
- Method Mutasi (Mengubah Array Asli)
- Method Non-Mutasi (Mengembalikan Nilai Baru)
slice()— Mengambil Bagian Arrayconcat()— Menggabungkan Arrayjoin()— Menggabungkan menjadi StringindexOf()danlastIndexOf()includes()— Cek Keberadaanfind()danfindIndex()findLast()danfindLastIndex()(ES2023)some()danevery()flat()danflatMap()toReversed(),toSorted(),toSpliced()(ES2023)
- Method Iterasi:
forEach,map,filter,reduce - Spread Operator dan Destructuring
- Array Multidimensi
- Contoh Praktis
- Ringkasan
Daftar isi
- Pendahuluan
- Membuat Array
- Mengakses Elemen
- Method Mutasi vs Non-Mutasi
- Method Mutasi (Mengubah Array Asli)
- Method Non-Mutasi (Mengembalikan Nilai Baru)
slice()— Mengambil Bagian Arrayconcat()— Menggabungkan Arrayjoin()— Menggabungkan menjadi StringindexOf()danlastIndexOf()includes()— Cek Keberadaanfind()danfindIndex()findLast()danfindLastIndex()(ES2023)some()danevery()flat()danflatMap()toReversed(),toSorted(),toSpliced()(ES2023)
- Method Iterasi:
forEach,map,filter,reduce - Spread Operator dan Destructuring
- Array Multidimensi
- Contoh Praktis
- Ringkasan
Pendahuluan
Array adalah struktur data yang menyimpan urutan nilai dalam satu variabel. Array bisa berisi tipe apa pun — string, number, boolean, object, bahkan array lain (nested array).
Array adalah struktur data yang paling sering digunakan di JavaScript. Hampir setiap aplikasi menggunakan array: daftar produk, daftar user, hasil query API, dan sebagainya.
Artikel ini membahas cara membuat array, mengakses elemen, method-method penting (mutasi dan non-mutasi), serta teknik modern seperti spread operator dan destructuring.
Asumsi: Anda sudah memahami variabel, tipe data, fungsi, dan arrow function dari artikel sebelumnya.
Membuat Array
1. Array Literal (Direkomendasikan)
const buah = ["apel", "jeruk", "mangga"];
const angka = [1, 2, 3, 4, 5];
const campuran = ["Budi", 25, true, null, { kota: "Jakarta" }];
const kosong = [];
const nested = [[1, 2], [3, 4], [5, 6]];
2. Constructor Array
const arr1 = new Array(); // []
const arr2 = new Array(5); // [ <5 empty items> ] (length 5, bukan [5]!)
const arr3 = new Array(1, 2, 3); // [1, 2, 3]
⚠️ Peringatan:
new Array(5)membuat array dengan length 5 (kosong), bukan[5]. Gunakan literal[5]untuk array berisi satu angka 5.
3. Array.from() — Dari Iterable atau Array-like
// Dari string
Array.from("Hello"); // ["H", "e", "l", "l", "o"]
// Dari Set
Array.from(new Set([1, 2, 2, 3, 3])); // [1, 2, 3]
// Dengan mapping function
Array.from([1, 2, 3], x => x * 2); // [2, 4, 6]
// Dari array-like (misalnya arguments)
function contoh() {
return Array.from(arguments);
}
contoh(1, 2, 3); // [1, 2, 3]
4. Array.of() — Membuat Array dari Argumen
Array.of(5); // [5] (bukan array kosong seperti new Array(5))
Array.of(1, 2, 3); // [1, 2, 3]
5. Array.fill() — Array dengan Nilai yang Sama
const nol = new Array(5).fill(0); // [0, 0, 0, 0, 0]
const nama = new Array(3).fill("Anonim"); // ["Anonim", "Anonim", "Anonim"]
Mengakses Elemen
Index (Mulai dari 0)
const buah = ["apel", "jeruk", "mangga"];
console.log(buah[0]); // "apel"
console.log(buah[1]); // "jeruk"
console.log(buah[2]); // "mangga"
console.log(buah[3]); // undefined (di luar batas)
length — Jumlah Elemen
const buah = ["apel", "jeruk", "mangga"];
console.log(buah.length); // 3
// Elemen terakhir
console.log(buah[buah.length - 1]); // "mangga"
at() — Akses dengan Index (Termasuk Negatif)
Diperkenalkan di ES2022. Mendukung index negatif (dari akhir).
const buah = ["apel", "jeruk", "mangga"];
console.log(buah.at(0)); // "apel"
console.log(buah.at(-1)); // "mangga" (terakhir)
console.log(buah.at(-2)); // "jeruk"
Mengubah Elemen
const buah = ["apel", "jeruk", "mangga"];
buah[1] = "pisang";
console.log(buah); // ["apel", "pisang", "mangga"]
Catatan: Array yang dideklarasikan dengan
constbisa diubah isinya —consthanya mencegah reassign binding, bukan mutasi isi.
Method Mutasi vs Non-Mutasi
Method array terbagi menjadi dua kategori penting:
- Mutasi — mengubah array asli.
- Non-mutasi — mengembalikan array/nilai baru, array asli tidak berubah.
Best practice: Utamakan method non-mutasi agar kode lebih mudah diprediksi dan tidak menimbulkan side effect.
Method Mutasi (Mengubah Array Asli)
push() — Tambah di Akhir
const buah = ["apel", "jeruk"];
buah.push("mangga");
console.log(buah); // ["apel", "jeruk", "mangga"]
// Bisa menambah beberapa sekaligus
buah.push("pisang", "anggur");
console.log(buah); // ["apel", "jeruk", "mangga", "pisang", "anggur"]
// Mengembalikan length baru
const len = buah.push("kiwi");
console.log(len); // 6
pop() — Hapus dari Akhir
const buah = ["apel", "jeruk", "mangga"];
const terakhir = buah.pop();
console.log(terakhir); // "mangga"
console.log(buah); // ["apel", "jeruk"]
unshift() — Tambah di Awal
const buah = ["jeruk", "mangga"];
buah.unshift("apel");
console.log(buah); // ["apel", "jeruk", "mangga"]
Catatan:
unshift()lebih lambat daripush()karena harus menggeser semua elemen.
shift() — Hapus dari Awal
const buah = ["apel", "jeruk", "mangga"];
const pertama = buah.shift();
console.log(pertama); // "apel"
console.log(buah); // ["jeruk", "mangga"]
splice() — Tambah/Hapus di Posisi Tertentu
Sintaks: splice(start, deleteCount, item1, item2, ...)
const buah = ["apel", "jeruk", "mangga", "pisang"];
// Hapus 1 elemen di index 1
buah.splice(1, 1);
console.log(buah); // ["apel", "mangga", "pisang"]
// Hapus 2 elemen mulai index 1, lalu tambah 2 elemen baru
buah.splice(1, 2, "anggur", "kiwi");
console.log(buah); // ["apel", "anggur", "kiwi"]
// Sisipkan tanpa menghapus
buah.splice(1, 0, "jeruk");
console.log(buah); // ["apel", "jeruk", "anggur", "kiwi"]
// Mengembalikan elemen yang dihapus
const dihapus = buah.splice(0, 1);
console.log(dihapus); // ["apel"]
console.log(buah); // ["jeruk", "anggur", "kiwi"]
sort() — Mengurutkan (Mutasi!)
const buah = ["mangga", "apel", "jeruk"];
buah.sort();
console.log(buah); // ["apel", "jeruk", "mangga"]
const angka = [10, 2, 30, 4];
angka.sort();
console.log(angka); // [10, 2, 30, 4] (!!) — diurutkan sebagai string
// Untuk angka, gunakan comparator
angka.sort((a, b) => a - b);
console.log(angka); // [2, 4, 10, 30]
// Descending
angka.sort((a, b) => b - a);
console.log(angka); // [30, 10, 4, 2]
⚠️ Peringatan:
sort()tanpa comparator mengubah angka menjadi string dan mengurutkannya secara leksikografis. Selalu berikan comparator untuk angka!
reverse() — Membalik Urutan (Mutasi!)
const buah = ["apel", "jeruk", "mangga"];
buah.reverse();
console.log(buah); // ["mangga", "jeruk", "apel"]
Tips:
reverse()memutasi array asli. Untuk versi non-mutasi, gunakan[...arr].reverse()atauarr.toReversed()(ES2023).
fill() — Mengisi dengan Nilai
const arr = [1, 2, 3, 4, 5];
arr.fill(0, 2, 4); // isi 0 dari index 2 sampai 4 (eksklusif)
console.log(arr); // [1, 2, 0, 0, 5]
Method Non-Mutasi (Mengembalikan Nilai Baru)
slice() — Mengambil Bagian Array
Sintaks: slice(start, end) — end eksklusif.
const buah = ["apel", "jeruk", "mangga", "pisang", "anggur"];
console.log(buah.slice(1, 3)); // ["jeruk", "mangga"]
console.log(buah.slice(2)); // ["mangga", "pisang", "anggur"]
console.log(buah.slice(-2)); // ["pisang", "anggur"]
console.log(buah.slice()); // salinan seluruh array
Array asli tidak berubah.
concat() — Menggabungkan Array
const arr1 = [1, 2];
const arr2 = [3, 4];
const arr3 = [5, 6];
const gabungan = arr1.concat(arr2, arr3);
console.log(gabungan); // [1, 2, 3, 4, 5, 6]
console.log(arr1); // [1, 2] (tidak berubah)
join() — Menggabungkan menjadi String
const buah = ["apel", "jeruk", "mangga"];
console.log(buah.join()); // "apel,jeruk,mangga"
console.log(buah.join(", ")); // "apel, jeruk, mangga"
console.log(buah.join(" - ")); // "apel - jeruk - mangga"
console.log(buah.join("")); // "apeljerukmangga"
indexOf() dan lastIndexOf()
const buah = ["apel", "jeruk", "mangga", "jeruk"];
console.log(buah.indexOf("jeruk")); // 1 (pertama)
console.log(buah.lastIndexOf("jeruk")); // 3 (terakhir)
console.log(buah.indexOf("pisang")); // -1 (tidak ditemukan)
includes() — Cek Keberadaan
const buah = ["apel", "jeruk", "mangga"];
console.log(buah.includes("jeruk")); // true
console.log(buah.includes("pisang")); // false
Tips:
includes()lebih mudah dibaca daripadaindexOf() !== -1.
find() dan findIndex()
const users = [
{ id: 1, nama: "Budi" },
{ id: 2, nama: "Siti" },
{ id: 3, nama: "Andi" }
];
const user = users.find(u => u.id === 2);
console.log(user); // { id: 2, nama: "Siti" }
const index = users.findIndex(u => u.id === 3);
console.log(index); // 2
// Jika tidak ditemukan
console.log(users.find(u => u.id === 99)); // undefined
console.log(users.findIndex(u => u.id === 99)); // -1
findLast() dan findLastIndex() (ES2023)
Mencari dari akhir array.
const angka = [1, 2, 3, 4, 5, 4, 3, 2, 1];
console.log(angka.findLast(n => n < 4)); // 3 (dari akhir)
some() dan every()
const angka = [1, 2, 3, 4, 5];
// some: apakah ADA yang memenuhi?
console.log(angka.some(n => n > 4)); // true
console.log(angka.some(n => n > 10)); // false
// every: apakah SEMUA memenuhi?
console.log(angka.every(n => n > 0)); // true
console.log(angka.every(n => n > 2)); // false
flat() dan flatMap()
// flat: meratakan nested array
const nested = [1, [2, 3], [4, [5, 6]]];
console.log(nested.flat()); // [1, 2, 3, 4, [5, 6]]
console.log(nested.flat(2)); // [1, 2, 3, 4, 5, 6]
console.log(nested.flat(Infinity)); // [1, 2, 3, 4, 5, 6]
// flatMap: map lalu flat (satu level)
const kalimat = ["Hello World", "Foo Bar"];
console.log(kalimat.flatMap(s => s.split(" ")));
// ["Hello", "World", "Foo", "Bar"]
toReversed(), toSorted(), toSpliced() (ES2023)
Versi non-mutasi dari reverse(), sort(), dan splice().
const buah = ["mangga", "apel", "jeruk"];
const terbalik = buah.toReversed();
console.log(terbalik); // ["jeruk", "apel", "mangga"]
console.log(buah); // ["mangga", "apel", "jeruk"] (tidak berubah)
const terurut = buah.toSorted();
console.log(terurut); // ["apel", "jeruk", "mangga"]
console.log(buah); // ["mangga", "apel", "jeruk"] (tidak berubah)
Method Iterasi: forEach, map, filter, reduce
Empat method ini adalah yang paling sering digunakan untuk memproses array.
forEach() — Jalankan Fungsi untuk Setiap Elemen
const buah = ["apel", "jeruk", "mangga"];
buah.forEach((item, index) => {
console.log(`${index}: ${item}`);
});
// 0: apel
// 1: jeruk
// 2: mangga
forEach tidak mengembalikan nilai (return undefined). Gunakan untuk side effect (misalnya console.log, update DOM).
map() — Transformasi Setiap Elemen
Mengembalikan array baru dengan hasil transformasi.
const angka = [1, 2, 3, 4, 5];
const kuadrat = angka.map(n => n * n);
console.log(kuadrat); // [1, 4, 9, 16, 25]
console.log(angka); // [1, 2, 3, 4, 5] (tidak berubah)
// Map object
const users = [
{ nama: "Budi", umur: 25 },
{ nama: "Siti", umur: 30 }
];
const nama = users.map(u => u.nama);
console.log(nama); // ["Budi", "Siti"]
const denganSapaan = users.map(u => ({
...u,
sapaan: `Halo, ${u.nama}`
}));
console.log(denganSapaan);
// [
// { nama: "Budi", umur: 25, sapaan: "Halo, Budi" },
// { nama: "Siti", umur: 30, sapaan: "Halo, Siti" }
// ]
filter() — Menyaring Elemen
Mengembalikan array baru berisi elemen yang lolos kondisi.
const angka = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const genap = angka.filter(n => n % 2 === 0);
console.log(genap); // [2, 4, 6, 8, 10]
const users = [
{ nama: "Budi", aktif: true },
{ nama: "Siti", aktif: false },
{ nama: "Andi", aktif: true }
];
const aktif = users.filter(u => u.aktif);
console.log(aktif);
// [{ nama: "Budi", aktif: true }, { nama: "Andi", aktif: true }]
reduce() — Meringkas Array menjadi Satu Nilai
Sintaks: reduce(callback, initialValue)
callback(accumulator, currentValue, index, array)
const angka = [1, 2, 3, 4, 5];
// Menjumlahkan
const total = angka.reduce((sum, n) => sum + n, 0);
console.log(total); // 15
// Mencari nilai maksimum
const maks = angka.reduce((max, n) => n > max ? n : max, angka[0]);
console.log(maks); // 5
// Menghitung frekuensi
const buah = ["apel", "jeruk", "apel", "mangga", "jeruk", "apel"];
const frekuensi = buah.reduce((acc, item) => {
acc[item] = (acc[item] || 0) + 1;
return acc;
}, {});
console.log(frekuensi);
// { apel: 3, jeruk: 2, mangga: 1 }
// Mengelompokkan berdasarkan properti
const users = [
{ nama: "Budi", role: "admin" },
{ nama: "Siti", role: "user" },
{ nama: "Andi", role: "admin" }
];
const byRole = users.reduce((acc, user) => {
if (!acc[user.role]) acc[user.role] = [];
acc[user.role].push(user.nama);
return acc;
}, {});
console.log(byRole);
// { admin: ["Budi", "Andi"], user: ["Siti"] }
⚠️ Peringatan: Selalu berikan initial value pada
reduce(). Tanpa initial value,reduce()menggunakan elemen pertama sebagai accumulator — dan akan error jika array kosong.
Perbandingan forEach, map, filter, reduce
| Method | Mengembalikan | Kegunaan |
|---|---|---|
forEach |
undefined |
Side effect (log, DOM) |
map |
Array baru (sama panjang) | Transformasi |
filter |
Array baru (lebih pendek/sama) | Penyaringan |
reduce |
Nilai apa pun | Ringkasan/agregasi |
Chaining Method
Method non-mutasi bisa dirangkai (chaining):
const angka = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const hasil = angka
.filter(n => n % 2 === 0) // [2, 4, 6, 8, 10]
.map(n => n * n) // [4, 16, 36, 64, 100]
.reduce((sum, n) => sum + n, 0); // 220
console.log(hasil); // 220
Contoh dengan data object:
const produk = [
{ nama: "Keyboard", harga: 450000, stok: 25 },
{ nama: "Mouse", harga: 150000, stok: 0 },
{ nama: "Monitor", harga: 1500000, stok: 10 },
{ nama: "Headset", harga: 350000, stok: 20 }
];
const totalNilaiStok = produk
.filter(p => p.stok > 0)
.map(p => p.harga * p.stok)
.reduce((sum, val) => sum + val, 0);
console.log(totalNilaiStok);
// 450000*25 + 1500000*10 + 350000*20 = 11250000 + 15000000 + 7000000 = 33250000
Tips: Chaining yang terlalu panjang bisa sulit dibaca. Pecah menjadi beberapa variabel antara jika perlu.
Spread Operator dan Destructuring
Spread Operator (...) pada Array
Menyebarkan elemen array menjadi elemen individual.
1. Menggabungkan array:
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const gabungan = [...arr1, ...arr2];
console.log(gabungan); // [1, 2, 3, 4, 5, 6]
2. Menyalin array (shallow copy):
const asli = [1, 2, 3];
const salinan = [...asli];
salinan.push(4);
console.log(asli); // [1, 2, 3] (tidak berubah)
console.log(salinan); // [1, 2, 3, 4]
3. Menyisipkan elemen:
const angka = [1, 2, 5];
const baru = [0, ...angka, 6];
console.log(baru); // [0, 1, 2, 5, 6]
4. Mengirim array sebagai argumen:
const angka = [3, 1, 4, 1, 5];
console.log(Math.max(...angka)); // 5
console.log(Math.min(...angka)); // 1
5. Mengubah iterable menjadi array:
const set = new Set([1, 2, 2, 3]);
const arr = [...set];
console.log(arr); // [1, 2, 3]
const str = "Hello";
console.log([...str]); // ["H", "e", "l", "l", "o"]
Destructuring Array
Mengekstrak nilai dari array ke variabel.
const buah = ["apel", "jeruk", "mangga"];
const [pertama, kedua, ketiga] = buah;
console.log(pertama); // "apel"
console.log(kedua); // "jeruk"
console.log(ketiga); // "mangga"
Melewati elemen:
const [a, , c] = [1, 2, 3];
console.log(a); // 1
console.log(c); // 3
Default value:
const [x = 10, y = 20] = [5];
console.log(x); // 5
console.log(y); // 20 (default)
Rest element:
const [kepala, ...ekor] = [1, 2, 3, 4, 5];
console.log(kepala); // 1
console.log(ekor); // [2, 3, 4, 5]
Swap variabel:
let a = 1, b = 2;
[a, b] = [b, a];
console.log(a, b); // 2 1
Destructuring dalam parameter fungsi:
function hitung([panjang, lebar]) {
return panjang * lebar;
}
console.log(hitung([5, 3])); // 15
Destructuring nested array:
const [[a, b], [c, d]] = [[1, 2], [3, 4]];
console.log(a, b, c, d); // 1 2 3 4
Array Multidimensi
Array bisa berisi array lain.
const matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
];
console.log(matrix[0][0]); // 1
console.log(matrix[1][2]); // 6
// Iterasi nested
for (const baris of matrix) {
for (const nilai of baris) {
process.stdout.write(nilai + " ");
}
console.log();
}
// 1 2 3
// 4 5 6
// 7 8 9
Meratakan nested array:
const nested = [[1, 2], [3, 4], [5, 6]];
const flat = nested.flat();
console.log(flat); // [1, 2, 3, 4, 5, 6]
Contoh Praktis
1. Keranjang Belanja
const keranjang = [
{ produk: "Keyboard", harga: 450000, jumlah: 2 },
{ produk: "Mouse", harga: 150000, jumlah: 1 },
{ produk: "Monitor", harga: 1500000, jumlah: 1 }
];
// Hitung total
const total = keranjang.reduce(
(sum, item) => sum + item.harga * item.jumlah,
0
);
console.log(`Total: Rp${total.toLocaleString("id-ID")}`);
// "Total: Rp2.550.000"
// Daftar nama produk
const namaProduk = keranjang.map(item => item.produk);
console.log(namaProduk); // ["Keyboard", "Mouse", "Monitor"]
// Produk di atas 200rb
const mahal = keranjang.filter(item => item.harga > 200000);
console.log(mahal);
// [{ produk: "Keyboard", ... }, { produk: "Monitor", ... }]
2. Menghapus Duplikat
const angka = [1, 2, 2, 3, 3, 4, 5, 5, 5];
// Dengan Set
const unik = [...new Set(angka)];
console.log(unik); // [1, 2, 3, 4, 5]
// Dengan filter + indexOf
const unik2 = angka.filter((n, i) => angka.indexOf(n) === i);
console.log(unik2); // [1, 2, 3, 4, 5]
3. Mengelompokkan Data
const transaksi = [
{ tanggal: "2022-12-01", total: 100000 },
{ tanggal: "2022-12-01", total: 250000 },
{ tanggal: "2022-12-02", total: 300000 },
{ tanggal: "2022-12-02", total: 150000 }
];
const perHari = transaksi.reduce((acc, t) => {
if (!acc[t.tanggal]) acc[t.tanggal] = 0;
acc[t.tanggal] += t.total;
return acc;
}, {});
console.log(perHari);
// { "2022-12-01": 350000, "2022-12-02": 450000 }
4. Pencarian dan Filter
const produk = [
{ nama: "Keyboard Mechanical", harga: 450000, kategori: "aksesoris" },
{ nama: "Mouse Wireless", harga: 150000, kategori: "aksesoris" },
{ nama: "Monitor 24 inch", harga: 1500000, kategori: "display" },
{ nama: "Headset Gaming", harga: 350000, kategori: "audio" }
];
// Cari berdasarkan kata kunci
function cariProduk(keyword) {
const lower = keyword.toLowerCase();
return produk.filter(p =>
p.nama.toLowerCase().includes(lower)
);
}
console.log(cariProduk("gaming"));
// [{ nama: "Headset Gaming", ... }]
// Filter berdasarkan kategori dan harga
function filterProduk({ kategori, hargaMax }) {
return produk.filter(p => {
if (kategori && p.kategori !== kategori) return false;
if (hargaMax && p.harga > hargaMax) return false;
return true;
});
}
console.log(filterProduk({ kategori: "aksesoris", hargaMax: 200000 }));
// [{ nama: "Mouse Wireless", ... }]
5. Sorting Data Kompleks
const users = [
{ nama: "Budi", umur: 30 },
{ nama: "Andi", umur: 25 },
{ nama: "Siti", umur: 35 }
];
// Urutkan berdasarkan umur (ascending)
const byUmur = [...users].sort((a, b) => a.umur - b.umur);
console.log(byUmur);
// [{ nama: "Andi", umur: 25 }, { nama: "Budi", umur: 30 }, { nama: "Siti", umur: 35 }]
// Urutkan berdasarkan nama (ascending)
const byNama = [...users].sort((a, b) => a.nama.localeCompare(b.nama));
console.log(byNama);
// [{ nama: "Andi", ... }, { nama: "Budi", ... }, { nama: "Siti", ... }]
Tips: Gunakan
[...users].sort(...)atauusers.toSorted(...)agar array asli tidak termutasi.
Ringkasan
| Kategori | Method |
|---|---|
| Mutasi | push, pop, shift, unshift, splice, sort, reverse, fill |
| Non-mutasi | slice, concat, join, indexOf, includes, find, findIndex, some, every, flat, flatMap |
| Iterasi | forEach, map, filter, reduce |
| ES2023 non-mutasi | toReversed, toSorted, toSpliced |
| Akses | arr[i], arr.at(i), arr.length |
| Spread | [...arr] — salin, gabung, sebarkan |
| Destructuring | const [a, b] = arr |
Poin penting:
- Gunakan method non-mutasi sebagai default agar kode mudah diprediksi.
mapmengembalikan array baru (sama panjang);filtermenyaring;reducemeringkas.forEachtidak mengembalikan nilai — gunakan untuk side effect.- Selalu berikan comparator pada
sort()untuk angka. - Selalu berikan initial value pada
reduce(). - Gunakan
includes()daripadaindexOf() !== -1. [...new Set(arr)]adalah cara ringkas menghapus duplikat.- Gunakan
arr.toSorted()/[...arr].sort()agar array asli tidak termutasi.
Pada artikel berikutnya, kita akan membahas Object & Method-nya — membuat object, properti, method, destructuring, spread, optional chaining, dan lainnya.