Parameter dan Argument

Banyak pemula menggunakan istilah parameter dan argument secara bergantian, padahal keduanya merujuk ke momen yang berbeda. Parameter adalah nama yang ditulis pada deklarasi function, sementara argument adalah nilai konkret yang diberikan saat function dipanggil. Pemisahan istilah ini penting karena banyak error kompilasi muncul dari ketidakcocokan tipe atau urutan keduanya. Pada chapter ini kita akan melihat bagaimana parameter dan argument saling terkait.

Parameter: Deklarasi di Sisi Function #

Parameter ditulis di dalam tanda kurung setelah nama function. Setiap parameter wajib memiliki nama dan tipe. Tipe tidak boleh dihilangkan karena Kotlin tidak melakukan type inference untuk parameter. Perhatikan deklarasi berikut yang menerima tiga parameter bertipe berbeda.

fun buatProfil(nama: String, umur: Int, kota: String): String {
    return "$nama berumur $umur tahun dan tinggal di $kota"
}

fun hitungLuas(panjang: Int, lebar: Int): Int {
    return panjang * lebar
}

fun main() {
    val profilBudi = buatProfil("Budi", 25, "Bandung")
    println(profilBudi)

    val profilSiti = buatProfil("Siti", 30, "Surabaya")
    println(profilSiti)

    val luas = hitungLuas(panjang = 4, lebar = 6)
    println("Luas persegi panjang: $luas")
}

Output yang Dihasilkan:

Budi berumur 25 tahun dan tinggal di Bandung
Siti berumur 30 tahun dan tinggal di Surabaya
Luas persegi panjang: 24

Mari kita bedah baris per baris:

1. fun buatProfil(nama: String, umur: Int, kota: String): tiga parameter — nama, umur, kota. Tipe setiap parameter harus eksplisit dan dipisahkan dengan koma.
2. buatProfil("Budi", 25, "Bandung"): tiga argumen diberikan dalam urutan yang sama dengan deklarasi. "Budi" mengisi nama, 25 mengisi umur, "Bandung" mengisi kota. Urutan argumen posisional wajib sesuai.
3. hitungLuas(panjang = 4, lebar = 6): argumen ditulis dengan nama parameter eksplisit. Bentuk ini disebut named argument dan akan kita bahas tuntas pada chapter khusus.

Argument: Nilai di Sisi Pemanggil #

Argument adalah nilai konkret yang diberikan ke parameter saat function dipanggil. Setiap parameter wajib menerima tepat satu argument, kecuali bila parameter tersebut memiliki nilai default. Argument posisional mengikuti urutan deklarasi, sedangkan argument bernama dapat ditulis dalam urutan apa pun.

fun hitungDiskon(harga: Int, persen: Int): Int {
    return harga * persen / 100
}

fun main() {
    val a = hitungDiskon(100000, 10)             // posisional
    val b = hitungDiskon(persen = 10, harga = 100000) // bernama
    println(a)
    println(b)
}

Kedua pemanggilan di atas menghasilkan nilai yang sama. Pemilihan bentuk bergantung pada keterbacaan; bila dua argumen sama-sama bertipe Int, bentuk bernama membantu pembaca membedakan peran masing-masing argumen.

Mengapa Tipe Parameter Wajib #

Bayangkan sebuah function yang dapat menerima Int atau String sekaligus — kompilator tidak akan tahu operasi apa yang valid. Dengan menuntut tipe eksplisit pada parameter, Kotlin memaksa kita berpikir tentang kontrak function: tipe apa yang diterima dan tipe apa yang dikembalikan. Kontrak yang eksplisit memudahkan kompilator mendeteksi galat tipe saat kompilasi, bukan saat program berjalan.

Parameter Banyak dan Urutan #

Bila function menerima banyak parameter, urutan deklarasi menentukan urutan argumen posisional. Konvensi umum adalah meletakkan parameter wajib di awal, lalu parameter opsional (yang punya nilai default) di akhir. Aturan ini juga membantu saat kita menggabungkan argumen posisional dengan argumen bernama.

fun kirimEmail(tujuan: String, subjek: String, isi: String, lampiran: Boolean = false): String {
    return "Kirim ke $tujuan: $subjek [$isi] lampiran=$lampiran"
}

Pemanggilan kirimEmail("[email protected]", "Halo", "Halo Budi") valid tanpa menyebut lampiran karena memiliki default false. Pemanggilan kirimEmail("[email protected]", "Halo", "Halo Budi", lampiran = true) juga valid. Kombinasi parameter wajib dan opsional akan kita bedah lebih lanjut pada chapter Default Arguments.

Referensi Lanjutan #

• Kotlin functions — panduan resmi parameter function dan passing argumen di Kotlin

Ringkasan #

Parameter adalah nama yang ditulis pada deklarasi function, sedangkan argument adalah nilai yang diberikan saat pemanggilan. Setiap parameter wajib bertipe eksplisit, dan urutan argumen posisional harus mengikuti urutan deklarasi. Pemahaman kontrak antara parameter dan argument menjadi fondasi untuk fitur seperti default arguments, named arguments, dan vararg parameters yang akan kita pelajari pada chapter-chapter berikutnya.