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

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 const bisa diubah isinya — const hanya 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 dari push() 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() atau arr.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 daripada indexOf() !== -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(...) atau users.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.
  • map mengembalikan array baru (sama panjang); filter menyaring; reduce meringkas.
  • forEach tidak mengembalikan nilai — gunakan untuk side effect.
  • Selalu berikan comparator pada sort() untuk angka.
  • Selalu berikan initial value pada reduce().
  • Gunakan includes() daripada indexOf() !== -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.

Top