Named Arguments

Pemanggilan function dengan banyak parameter seringkali membingungkan, terutama bila tipe argumen sama. Sebuah pemanggilan buatProfil("Budi", 25, true, false) tidak menjelaskan peran true dan false. Kotlin mengatasi hal ini dengan named arguments — pemanggil dapat menyebut nama parameter secara eksplisit. Pada chapter ini kita akan melihat bagaimana named arguments meningkatkan keterbacaan dan membebaskan urutan argumen.

Sintaks Dasar #

Named argument ditulis dengan pola namaParameter = nilai. Pemanggil dapat menuliskan argumen bernama dalam urutan apa pun karena nama parameter menjadi penanda, bukan posisi. Perhatikan contoh berikut.

fun buatProfil(
    nama: String,
    umur: Int = 17,
    kota: String = "Jakarta",
    pekerjaan: String = "Pelajar"
): String {
    return "$nama, $umur tahun, $kota, $pekerjaan"
}

fun main() {
    println(buatProfil(nama = "Budi"))
    println(buatProfil(nama = "Siti", kota = "Bandung"))
    println(buatProfil(pekerjaan = "Insinyur", nama = "Dewi"))
    println(buatProfil("Andi", umur = 28, pekerjaan = "Peneliti"))
}

Output yang Dihasilkan:

Budi, 17 tahun, Jakarta, Pelajar
Siti, 17 tahun, Bandung, Pelajar
Dewi, 17 tahun, Jakarta, Insinyur
Andi, 28 tahun, Jakarta, Peneliti

Mari kita bedah baris per baris:

1. buatProfil(nama = "Budi"): hanya argumen wajib nama yang ditulis. Sisa parameter memakai nilai default dari deklarasi function.
2. buatProfil(nama = "Siti", kota = "Bandung"): argumen ditulis tidak mengikuti urutan deklarasi. umur dan pekerjaan tetap memakai default.
3. buatProfil(pekerjaan = "Insinyur", nama = "Dewi"): urutan dibalik total. Nama parameter memastikan setiap argumen diberikan ke parameter yang tepat.
4. buatProfil("Andi", umur = 28, pekerjaan = "Peneliti"): gabungan posisional dan bernama. Argumen posisional wajib ditulis lebih dulu sebelum argumen bernama.

Aturan Posisional dan Bernama #

Kotlin mengizinkan campuran argumen posisional dan bernama dalam satu pemanggilan, tetapi dengan satu aturan ketat: argumen posisional harus mendahului semua argumen bernama. Bila kita menulis argumen bernama lebih dulu lalu argumen posisional setelahnya, kompilator melaporkan galat.

fun kirimEmail(tujuan: String, subjek: String, isi: String, lampiran: Boolean): String {
    return "Ke: $tujuan | $subjek | $isi | lampiran=$lampiran"
}

fun main() {
    // Valid: posisional dulu, lalu bernama
    kirimEmail("[email protected]", "Halo", "Halo Budi", lampiran = true)

    // Valid: semua bernama, urutan bebas
    kirimEmail(lampiran = false, isi = "Halo Siti", subjek = "Test", tujuan = "[email protected]")

    // GALAT: argumen posisional setelah argumen bernama
    // kirimEmail(tujuan = "[email protected]", "Halo", "Halo Budi", true)
}

Baris yang dikomentari di atas akan memicu galat kompilasi karena argumen posisional "Halo" muncul setelah argumen bernama tujuan = .... Aturan ini menjaga agar alur pembacaan argumen tetap konsisten.

Kapan Memakai Named Arguments #

Named arguments paling berguna pada tiga situasi:

• function dengan banyak parameter bertipe sama (misal Int, Int, Int) sehingga urutan rawan tertukar
• function dengan parameter Boolean yang makna true/false-nya tidak jelas dari pemanggilan posisional
• function dengan banyak parameter default dan kita hanya ingin mengisi beberapa di antaranya

fun aturCache(ukuranMB: Int, kompresi: Boolean = true, persisten: Boolean = false, terenkripsi: Boolean = true): String {
    return "Cache ${ukuranMB}MB, kompresi=$kompresi, persisten=$persisten, enkripsi=$terenkripsi"
}

fun main() {
    // Tanpa named argument: bingung true/false untuk apa
    // aturCache(128, true, false, true)

    // Dengan named argument: jelas
    aturCache(ukuranMB = 128, persisten = true, terenkripsi = false)
}

Pemanggilan dengan named arguments membantu pembaca memahami maksud setiap argumen tanpa harus membuka deklarasi function.

Keterbacaan dan Refactor #

Named arguments membuat refactor lebih aman. Bila urutan parameter ditukar saat refactor, pemanggilan yang menggunakan named arguments tetap valid karena dipetakan berdasarkan nama, bukan posisi. Sebaliknya, pemanggilan posisional akan tetap kompilasi tetapi menghasilkan perilaku berbeda — bug yang sulit dideteksi.

Batasan Named Arguments #

Named arguments tidak dapat dipakai untuk parameter vararg. Saat memanggil function fun jumlah(vararg x: Int), kita menulis argumen secara langsung tanpa nama. Selain itu, named arguments tidak tersedia saat memanggil kode Kotlin dari Java — Java tidak memiliki sintaks tersebut. Pada chapter vararg Parameters berikutnya, kita akan membahas function yang menerima jumlah argumen variabel.

Referensi Lanjutan #

• Kotlin functions — panduan resmi named argument dengan sintaks name = value saat memanggil function

Ringkasan #

Named arguments membebaskan urutan argumen dan meningkatkan keterbacaan pemanggilan function. Argumen posisional harus mendahului argumen bernama dalam satu pemanggilan. Pola ini paling berharga untuk parameter Boolean dan function dengan banyak parameter default. Pada chapter vararg Parameters berikutnya, kita akan melihat bagaimana membuat function yang menerima jumlah argumen tidak terbatas.