Default Arguments

Seringkali sebuah function memiliki nilai parameter yang umum dipakai pada sebagian besar pemanggilan. Menulis ulang argumen yang sama berulang kali membuat kode jenuh dan rentan salah ketik. Kotlin mengatasi hal ini dengan default arguments — parameter dapat diberi nilai bawaan sehingga pemanggil boleh menghilangkannya. Pada chapter ini kita akan membongkar cara kerja default arguments dan kombinasi dengan argumen posisional.

Deklarasi Parameter dengan Nilai Default #

Nilai default ditulis dengan tanda sama dengan setelah tipe parameter. Pemanggil boleh tidak menyebutkan argumen tersebut, dan Kotlin akan memakai nilai bawaan. Perhatikan contoh function sapa yang menyediakan dua parameter default.

fun sapa(nama: String, salam: String = "Halo", tandaBaca: String = "!"): String {
    return "$salam, $nama$tandaBaca"
}

fun formatHarga(nilai: Int, mataUang: String = "IDR", suffix: String = ",00"): String {
    return "$mataUang $nilai$suffix"
}

fun main() {
    println(sapa("Budi"))
    println(sapa("Siti", "Hai"))
    println(sapa("Dewi", "Selamat pagi", "."))

    println(formatHarga(15000))
    println(formatHarga(25000, "USD"))
    println(formatHarga(99, "EUR", ""))
}

Output yang Dihasilkan:

Halo, Budi!
Hai, Siti!
Selamat pagi, Dewi.
IDR 15000,00
USD 25000,00
EUR 99

Mari kita bedah baris per baris:

1. fun sapa(nama: String, salam: String = "Halo", tandaBaca: String = "!"): parameter salam memiliki default "Halo" dan tandaBaca memiliki default "!". Pemanggil wajib memberikan nama karena tidak punya default.
2. sapa("Budi"): hanya nama yang diberikan. salam memakai "Halo" dan tandaBaca memakai "!" sehingga hasilnya "Halo, Budi!".
3. sapa("Siti", "Hai"): salam ditimpa menjadi "Hai", tandaBaca tetap "!" sehingga hasilnya "Hai, Siti!".
4. sapa("Dewi", "Selamat pagi", "."): ketiga argumen diberikan secara posisional sehingga semua default ditimpa.
5. formatHarga(...): pola yang sama dengan parameter mataUang dan suffix yang memiliki default.

Urutan Parameter Default #

Kotlin tidak melarang parameter default di tengah, tetapi pemanggilan posisional menjadi terbatas. Konvensi yang disarankan adalah meletakkan parameter wajib di awal dan parameter default di akhir. Aturan ini memudahkan pemanggilan posisional karena argumen wajib selalu diisi lebih dahulu.

// Disarankan: wajib di awal, default di akhir
fun kirimEmail(tujuan: String, subjek: String = "(Tanpa Subjek)", lampiran: Boolean = false): String {
    return "$tujuan | $subjek | lampiran=$lampiran"
}

// Membingungkan: default di tengah, pemanggil posisional jadi rumit
fun rumit(a: Int, b: Int = 0, c: Int): Int = a + b + c

Function rumit di atas valid secara sintaksis. Pemanggilan rumit(1, c = 3) diperbolehkan dengan argumen bernama untuk c, tetapi rumit(1, 3) tidak valid karena 3 akan dianggap mengisi b, padahal c tidak punya default. Bila ragu, selalu letakkan parameter default di akhir.

Menggabungkan Default dengan Argument Bernama #

Default arguments sangat bertenaga saat digabungkan dengan named arguments. Kita dapat melompati parameter default di tengah dan hanya mengisi yang dibutuhkan. Pola ini umum dipakai pada builder atau function konfigurasi.

fun buatPesan(
    tujuan: String,
    isi: String = "",
    prioritas: Int = 1,
    denganTandaTangan: Boolean = true,
    salinan: Boolean = false
): String {
    return "Ke: $tujuan | Prioritas: $prioritas | TTD: $denganTandaTangan | CC: $salinan | Isi: $isi"
}

fun main() {
    println(buatPesan("[email protected]"))
    println(buatPesan("[email protected]", prioritas = 5))
    println(buatPesan("[email protected]", salinan = true, isi = "Laporan harian"))
}

Pemanggilan buatPesan("[email protected]", prioritas = 5) melompati isi (default "") dan denganTandaTangan (default true). Tanpa named arguments, kita harus menulis buatPesan("[email protected]", "", 5) yang lebih sulit dipahami.

Interoperasi dengan Java #

Java tidak mengenal default arguments. Saat kode Kotlin dengan default arguments dipanggil dari Java, kita perlu menambahkan anotasi @JvmOverloads agar kompilator Kotlin menghasilkan overload-overload yang sesuai. Anotasi ini menghasilkan beberapa versi function dengan jumlah parameter yang berbeda, sehingga Java dapat memilih bentuk yang paling sesuai.

class PusatPesan {
    @JvmOverloads
    fun kirim(tujuan: String, isi: String = "", prioritas: Int = 1): String {
        return "Kirim ke $tujuan: [$isi] prioritas=$prioritas"
    }
}

Dengan @JvmOverloads, kompilator menghasilkan tiga method: kirim(tujuan), kirim(tujuan, isi), dan kirim(tujuan, isi, prioritas). Java kemudian dapat memanggil bentuk mana pun yang sesuai.

Referensi Lanjutan #

• Kotlin functions — panduan resmi default argument yang menjelaskan sintaks name: Type = default

Ringkasan #

Default arguments menyederhanakan pemanggilan function yang memiliki nilai parameter umum. Letakkan parameter default di akhir deklarasi agar pemanggilan posisional tetap sederhana. Gabungkan dengan named arguments untuk melompati parameter default di tengah. Pada chapter Named Arguments berikutnya, kita akan membedah secara mendalam cara menyebut argumen dengan nama parameter secara eksplisit.