Default & Rest Parameter

Analogi: Warteg dengan Lauk Standar dan Prasmanan

Bayangkan dua model warung makan. Warteg langgananmu: kalau kamu cuma bilang "nasi bungkus", penjual otomatis memberi lauk STANDAR (tempe + sayur), tapi kamu boleh menyebut lauk lain kalau mau. Itulah default parameter: nilai cadangan yang dipakai kalau pemanggil tidak memberi argumen. Model kedua: prasmanan. Kamu boleh ambil lauk SEBANYAK apa pun, dan pelayan menampung semua pilihanmu dalam SATU piring besar. Itulah rest parameter: ...nama menampung semua sisa argumen menjadi satu array. Dua fitur ini lahir dari kebutuhan yang sama: fungsi yang lentur, bisa dipanggil dengan banyak atau sedikit argumen tanpa merengek.

Kenapa Fitur Ini Ada?

Fungsi kaku yang menuntut argumen lengkap itu merepotkan. Dulu, programmer menulis pola berulang seperti nama = nama || "Tamu" di awal setiap fungsi untuk menangani argumen kosong, berantakan dan rawan salah (nilai 0 atau string kosong ikut tertimpa!). Default parameter merapikan pola itu menjadi deklarasi satu baris yang jelas. Sementara itu, fungsi seperti "jumlahkan semua angka" atau "gabungkan semua kata" butuh menerima argumen dalam JUMLAH TAK TERBATAS, dulu diakali dengan objek arguments yang canggung (bukan array asli, tidak ada di arrow function). Rest parameter menggantikannya dengan array betulan yang bisa langsung di-map atau di-reduce. Singkatnya: default untuk "kalau tidak diberi", rest untuk "beri sebanyak apa pun".

Contoh 1: Default Parameter, Sederhana Dulu

function sapa(nama = "Tamu") {
  return "Halo, " + nama;
}

console.log(sapa());        // "Halo, Tamu" (pakai cadangan)
console.log(sapa("Budi"));  // "Halo, Budi" (cadangan diabaikan)

Nilai default HANYA dipakai saat argumen undefined, yaitu saat tidak dikirim sama sekali. Perhatikan bedanya dengan nilai falsy lain:

function diskon(harga, persen = 10) {
  return harga - harga * (persen / 100);
}

console.log(diskon(100000));            // 90000 (pakai 10)
console.log(diskon(100000, 20));        // 80000
console.log(diskon(100000, 0));         // 100000 (0 dipakai! bukan default)
console.log(diskon(100000, undefined)); // 90000 (undefined -> default)

Ini penting: mengirim 0 secara eksplisit TIDAK memicu default, karena 0 adalah nilai yang sah. Hanya undefined (tidak dikirim) yang memicu default. Inilah keunggulan dibanding pola lama persen = persen || 10 yang akan menimpa 0 secara salah.

Contoh 2: Kasus Nyata, Rest Parameter untuk Total Fleksibel

Sekarang rest parameter. Tanda ... di posisi parameter MENGUMPULKAN semua sisa argumen menjadi array:

function total(...angka) {
  // angka sudah berupa array betulan: [1, 2, 3, 4]
  return angka.reduce((a, b) => a + b, 0);
}

console.log(total(1, 2, 3, 4));    // 10
console.log(total(5, 5));          // 10
console.log(total(100));           // 100
console.log(total());              // 0 (array kosong, aman)

Contoh realistis: fungsi pencatat aktivitas (logger) yang menerima level dan pesan sebanyak apa pun, pola yang dipakai di hampir semua library:

function catat(level = "INFO", ...pesan) {
  const waktu = new Date().toLocaleTimeString();
  console.log("[" + waktu + "] " + level + ": " + pesan.join(" "));
}

catat("ERROR", "Gagal", "konek", "database");
catat("Login berhasil untuk user Budi"); // level default INFO

Satu fungsi melayani panggilan dengan 1 argumen maupun 5 argumen. Rest parameter WAJIB di posisi terakhir, karena ia "menyapu" semua sisa. Menaruh parameter biasa setelah rest adalah error sintaks.

Kombinasi Keduanya

Default dan rest bisa dipakai bersama selama aturannya dipatuhi (rest terakhir):

function kenalkan(salam = "Halo", ...nama) {
  if (nama.length === 0) return salam + " (tidak ada nama)";
  return salam + ": " + nama.join(", ");
}

console.log(kenalkan());                 // "Halo (tidak ada nama)"
console.log(kenalkan("Hai", "A", "B"));  // "Hai: A, B"

Kesalahan Umum Pemula

1. Mengira default berlaku untuk null atau string kosong.

function sapa(nama = "Tamu") {
  return "Halo, " + nama;
}

// SALAH sangka: null TIDAK memicu default
console.log(sapa(null)); // "Halo, null" (bukan "Halo, Tamu"!)

// BENAR: hanya undefined (tidak dikirim) yang memicu default
console.log(sapa(undefined)); // "Halo, Tamu"
console.log(sapa());          // "Halo, Tamu"

Kalau datamu bisa berupa null (umum dari API), tangani eksplisit: nama = nama ?? "Tamu" di dalam fungsi, atau validasi sebelum memanggil.

2. Menaruh rest bukan di posisi terakhir.

// SALAH: SyntaxError!
function salah(...angka, terakhir) {
  return angka;
}

// BENAR: rest selalu paling belakang
function benar(pertama, ...sisanya) {
  return sisanya;
}
console.log(benar(1, 2, 3, 4)); // [2, 3, 4]

3. Tertukar rest dan spread.

const angka = [1, 2, 3];

// REST: di definisi fungsi, MENGUMPULKAN jadi array
function jumlahkan(...args) {
  return args.reduce((a, b) => a + b, 0);
}

// SPREAD: saat MEMANGGIL, MENYEBAR array jadi argumen lepas
console.log(jumlahkan(...angka)); // 6
console.log(jumlahkan(angka));    // SALAH: args = [[1,2,3]], hasilnya "01,2,3"

Ingat mantra: rest mengumpulkan (saat definisi), spread menyebar (saat pemanggilan). Keduanya memakai ... yang sama sehingga wajar tertukar di awal.

Ringkasan

Default parameter (nama = "Tamu") memberi nilai cadangan yang hanya aktif saat argumen undefined, membuat fungsi tahan dipanggil tanpa argumen lengkap. Rest parameter (...angka) menampung sisa argumen tak terbatas menjadi array betulan dan wajib di posisi terakhir. Bersama-sama mereka membuat fungsi lentur: sedikit argumen tetap jalan, banyak argumen tetap ketampung. Jangan tertukar dengan spread yang justru menyebar array saat memanggil.