vararg Parameters

Terkadang kita ingin function menerima jumlah argumen yang tidak tetap — misalnya function jumlah yang bisa menerima 2, 5, atau 10 bilangan. Kotlin menyediakan vararg parameters untuk kebutuhan ini. Parameter vararg menyatukan semua argumen yang diberikan menjadi satu array. Pada chapter ini kita akan membongkar cara deklarasi, akses elemen, dan penerusan array sebagai argumen vararg.

Deklarasi Parameter vararg #

Keyword vararg diletakkan sebelum nama parameter. Di dalam body, parameter tersebut dapat diakses seperti array reguler. Karena vararg membungkus argumen menjadi array, tipe elemen harus seragam.

fun jumlah(vararg x: Int): Int {
    var total = 0
    for (n in x) total += n
    return total
}

fun rataRata(vararg x: Int): Double {
    if (x.isEmpty()) return 0.0
    var total = 0
    for (n in x) total += n
    return total.toDouble() / x.size
}

fun main() {
    println("Jumlah 1..5 = ${jumlah(1, 2, 3, 4, 5)}")
    println("Jumlah 10, 20 = ${jumlah(10, 20)}")
    println("Jumlah tanpa argumen = ${jumlah()}")

    val data = intArrayOf(7, 8, 9)
    println("Jumlah dengan spread operator = ${jumlah(*data)}")

    println("Rata-rata 10, 20, 30 = ${rataRata(10, 20, 30)}")
}

Output yang Dihasilkan:

Jumlah 1..5 = 15
Jumlah 10, 20 = 30
Jumlah tanpa argumen = 0
Jumlah dengan spread operator = 24
Rata-rata 10, 20, 30 = 20.0

Mari kita bedah baris per baris:

1. fun jumlah(vararg x: Int): parameter x bertipe IntArray di dalam body. Pemanggil dapat memberikan nol, satu, atau banyak argumen bertipe Int.
2. for (n in x) total += n: iterasi atas seluruh elemen vararg. Karena x bertipe IntArray, kita dapat memanggil x.size, x[0], dan method array lainnya.
3. jumlah(1, 2, 3, 4, 5): pemanggilan dengan lima argumen. Kotlin membungkus kelima nilai menjadi IntArray berisi [1, 2, 3, 4, 5].
4. jumlah(): pemanggilan tanpa argumen. x menjadi IntArray kosong berukuran nol.
5. jumlah(*data): spread operator * membongkar array data menjadi argumen individual. Tanpa *, kompilator akan menganggap kita mengirim satu argumen bertipe IntArray, padahal parameter vararg x: Int mengharapkan elemen Int.

Posisi Parameter vararg #

Parameter vararg biasanya ditempatkan di posisi terakhir. Pemanggilan menjadi lebih alami karena argumen variabel dapat diisi terus tanpa perlu nama. Kotlin mengizinkan vararg tidak di akhir, tetapi parameter setelahnya wajib menggunakan named arguments.

fun buatPesan(header: String, vararg isi: String, footer: String): String {
    val body = isi.joinToString(separator = "\n")
    return "$header\n$body\n$footer"
}

fun main() {
    println(buatPesan("Laporan", "Baris 1", "Baris 2", "Baris 3", footer = "Selesai"))
}

Parameter footer berada setelah vararg isi. Karena vararg menyerap semua argumen posisional setelahnya, parameter footer wajib diberi named argument agar tidak ikut terserap ke isi.

Spread Operator untuk Array #

Penerusan array ke parameter vararg memerlukan spread operator *. Operator ini membongkar elemen array menjadi argumen individual. Tanpa spread, kompilator menolak karena tipe tidak cocok — IntArray bukan Int.

fun gabung(vararg teks: String): String {
    val builder = StringBuilder()
    for (s in teks) builder.append(s).append(" ")
    return builder.toString().trim()
}

fun main() {
    val kata = arrayOf("Belajar", "Kotlin", "itu", "menyenangkan")
    println(gabung(*kata))

    val sebagian = arrayOf("Kotlin", "keren")
    println(gabung("Belajar", *sebagian, "bukan?"))
}

Pemanggilan gabung("Belajar", *sebagian, "bukan?") menggabungkan argumen literal dengan elemen array yang di-spread. Hasilnya sama dengan gabung("Belajar", "Kotlin", "keren", "bukan?").

Akses Iterasi dan Konversi #

Di dalam body, parameter vararg bertipe array primitif (misalnya IntArray untuk vararg x: Int). Kita dapat mengiterasi dengan for, memanggil .size, .isEmpty(), .indices, atau mengonversi ke koleksi lain bila dibutuhkan.

fun daftar(vararg item: String): List<String> {
    val hasil = mutableListOf<String>()
    for (i in item.indices) {
        hasil.add("${i + 1}. ${item[i]}")
    }
    return hasil
}

fun main() {
    println(daftar("Apel", "Mangga", "Jeruk"))
}

Konversi eksplisit ke List berguna bila kita ingin menghindari keterbatasan array primitif (misalnya tidak dapat menambah elemen baru). Setelah dikonversi, kita dapat memanipulasi data lebih leluasa.

Referensi Lanjutan #

• Kotlin functions — panduan resmi vararg parameter yang memungkinkan jumlah argumen variabel

Ringkasan #

Parameter vararg memungkinkan function menerima jumlah argumen tidak terbatas dengan tipe seragam. Di dalam body, parameter tersebut bertipe array primitif yang dapat diiterasi. Penerusan array eksisting memerlukan spread operator * agar elemen dibongkar menjadi argumen individual. Pada chapter infix Functions berikutnya, kita akan membahas bentuk pemanggilan function tanpa titik dan kurung yang membuat kode terbaca seperti kalimat natural.