main() Function

Setiap program Kotlin yang dapat dijalankan sebagai aplikasi CLI memerlukan satu titik masuk: function main. Pada chapter ini kita akan membedah dua bentuk tanda tangan main yang didukung Kotlin, membaca argumen command-line yang diteruskan ke program, dan mengatur exit code melalui kotlin.system.exitProcess. Pemahaman ini menjadi dasar saat kita menulis alat CLI yang berinteraksi dengan shell dan skrip otomatisasi.

Dua Bentuk Tanda Tangan main #

Kotlin mendukung dua tanda tangan resmi untuk function main:

fun main()                              // bentuk tanpa argumen
fun main(args: Array<String>)           // bentuk yang menerima argumen command-line

Bentuk pertama dipakai ketika program tidak perlu membaca argumen dari shell. Bentuk kedua dipakai ketika program membaca parameter dari command-line, misalnya path file atau opsi --output. Kompilator Kotlin mengenali kedua tanda tangan ini sebagai titik masuk yang valid.

Berikut contoh bentuk paling sederhana:

fun main() {
    val daftar = listOf("Budi", "Siti", "Andi")
    println("Peserta pelatihan:")
    daftar.forEach { println("- $it") }
}

Output yang Dihasilkan:

Peserta pelatihan:
- Budi
- Siti
- Andi

Program tersebut tidak membaca argumen apa pun dari shell; semua data sudah ada di dalam kode.

Membaca Argumen Command-Line #

Bentuk main(args: Array<String>) menerima daftar argumen yang diberikan shell saat menjalankan program. Setiap argumen menjadi satu elemen String di dalam array. Berikut contoh program yang membaca dan mencetak argumen:

fun main(args: Array<String>) {
    println("Jumlah argumen: ${args.size}")
    if (args.isEmpty()) {
        println("Tidak ada argumen yang diberikan.")
        return
    }
    println("Daftar argumen:")
    for ((index, value) in args.withIndex()) {
        println("  args[$index] = $value")
    }
    val kode = prosesKode(args.first())
    println("Kode keluar proses: $kode")
    kotlin.system.exitProcess(kode)
}

fun prosesKode(input: String): Int {
    return if (input == "ok") 0 else 1
}

Output yang Dihasilkan:

Jumlah argumen: 0
Tidak ada argumen yang diberikan.

Mari kita bedah baris penting di atas:

1. Baris 1 (fun main(args: Array<String>)) — parameter args bertipe Array<String>, bukan Array<String>?. Kotlin menjamin array tidak pernah null, sehingga kita bisa langsung memanggil args.size tanpa pengecekan null.
2. Baris 3 (args.size) — property size mengembalikan jumlah elemen argumen. Property ini mirip length di Java, namun Kotlin menggunakan nama size untuk koleksi dan array.
3. Baris 4-7 (if (args.isEmpty()) { ... return }) — guard clause yang keluar lebih awal ketika tidak ada argumen. Kata kunci return pada function main mengakhiri program dengan exit code default 0.
4. Baris 9-11 (for ((index, value) in args.withIndex())) — destructuring loop yang mengekstrak pasangan indeks dan nilai sekaligus, mirip enumerate di Python.
5. Baris 13 (args.first()) — mengembalikan elemen pertama; melempar NoSuchElementException bila array kosong. Guard clause di atas memastikan baris ini aman dijalankan.
6. Baris 15 (kotlin.system.exitProcess(kode)) — menghentikan JVM dan mengembalikan kode ke shell sebagai exit code.

Mengatur Exit Code dengan exitProcess #

Shell dan sistem operasi membaca exit code untuk menentukan apakah program selesai dengan sukses (0) atau mengalami kegagalan (selain 0). Kotlin menyediakan function kotlin.system.exitProcess(kode: Int) untuk mengatur nilai tersebut secara eksplisit.

import kotlin.system.exitProcess

fun main(args: Array<String>) {
    if (args.isEmpty()) {
        System.err.println("Penggunaan: program <input>")
        exitProcess(2)            // 2 = kesalahan penggunaan
    }
    // ... logika utama ...
    exitProcess(0)               // 0 = sukses
}

Konvensi exit code yang umum dipakai di ekosistem Unix:

Tanpa exitProcess, function main kembali secara normal dan JVM mengembalikan exit code 0. Oleh karena itu, kita hanya perlu memanggil exitProcess ketika ingin menyatakan kondisi khusus.

Menjalankan dengan Argumen #

Untuk menguji program yang menerima argumen, kita jalankan JAR dengan menambahkan argumen setelah nama file:

java -jar main_args.jar ok extra

Output yang dihasilkan akan menampilkan args[0] = ok dan args[1] = extra. Bila argumen pertama bukan "ok", function prosesKode mengembalikan 1, dan exitProcess(1) menyebabkan shell melaporkan exit code 1. Shell seperti bash menyimpan exit code terakhir di variabel $?:

java -jar main_args.jar ok
echo "Exit: $?"        # mencetak 0
java -jar main_args.jar gagal
echo "Exit: $?"        # mencetak 1

Referensi Lanjutan #

• Kotlin basic syntax — panduan resmi fun main() sebagai pintu masuk program Kotlin
• Kotlin command-line compiler — rujukan kompilator Kotlin CLI untuk menjalankan main() dari berkas .kt

Function main adalah jembatan antara shell dan logika program Kotlin. Setelah memahami cara menerima argumen dan mengatur exit code, kita siap menambahkan lapisan dokumentasi di atas kode melalui komentar, yang akan kita bahas pada chapter Komentar.