Main Parameter

Function main() merupakan function utama yang menjadi titik awal eksekusi program Kotlin.

Selain digunakan tanpa parameter, main() juga dapat menerima parameter.

Parameter pada main() biasanya digunakan untuk menerima argument dari command line ketika program dijalankan.

Main Tanpa Parameter

Bentuk paling sederhana dari main() adalah:

fun main() {
    println("Hello World")
}

Ketika program dijalankan, Kotlin akan memulai eksekusi dari function:

main()

Output:

Hello World

Main dengan Parameter

Kita dapat membuat main() dengan parameter berupa Array<String>.

Contoh:

fun main(args: Array<String>) {
    println("Hello World")
}

Pada contoh tersebut:

args: Array<String>

adalah parameter yang digunakan untuk menerima argument dari command line.

Parameter tersebut biasanya disebut:

args

Namun, nama args sebenarnya bukan keharusan. Kita dapat menggunakan nama variable lainnya.

Contoh:

fun main(arguments: Array<String>) {
    println("Hello World")
}

Apa Itu Array<String>?

Perhatikan:

Array<String>

Artinya parameter tersebut merupakan sebuah Array yang setiap elemennya bertipe String.

Misalnya kita menjalankan program dengan argument:

Ucup 30 Palu

maka data tersebut dapat diterima sebagai:

args[0] = "Ucup"
args[1] = "30"
args[2] = "Palu"

Semua argument yang diterima melalui command line pada main() akan berupa String.

Mengakses Parameter args

Kita dapat mengakses argument menggunakan index.

Contoh:

fun main(args: Array<String>) {
    println(args[0])
}

Jika program dijalankan dengan:

Ucup

maka output:

Ucup

Argument pertama berada pada index:

0

Contoh Beberapa Argument

Contoh:

fun main(args: Array<String>) {

    println(args[0])
    println(args[1])
    println(args[2])
}

Jika program dijalankan dengan argument:

Ucup Topekox Palu

maka:

args[0] = "Ucup"
args[1] = "Topekox"
args[2] = "Palu"

Output:

Ucup
Topekox
Palu

Menampilkan Semua Argument

Kita juga dapat melakukan perulangan terhadap args.

Contoh:

fun main(args: Array<String>) {

    for (arg in args) {
        println(arg)
    }
}

Jika argument yang diberikan:

Ucup Topekox Palu

output:

Ucup
Topekox
Palu

Menggunakan forEach

Karena args merupakan array, kita juga dapat menggunakan forEach.

Contoh:

fun main(args: Array<String>) {

    args.forEach {
        println(it)
    }
}

it mewakili setiap element dari array args.

Jika argument:

Java Kotlin Python

output:

Java
Kotlin
Python

Mengetahui Jumlah Argument

Kita dapat menggunakan property:

args.size

untuk mengetahui jumlah argument.

Contoh:

fun main(args: Array<String>) {

    println("Jumlah argument: ${args.size}")
}

Jika program dijalankan dengan:

Ucup Topekox Palu

output:

Jumlah argument: 3

Contoh Penggunaan Main Parameter

Misalnya kita ingin membuat program sederhana yang menerima nama dari command line.

fun main(args: Array<String>) {

    if (args.isNotEmpty()) {
        println("Hello ${args[0]}")
    } else {
        println("Nama belum diberikan")
    }
}

Jika dijalankan dengan:

Ucup

output:

Hello Ucup

Jika tidak memberikan argument:

Nama belum diberikan

Mengecek args.isNotEmpty()

Pada contoh sebelumnya digunakan:

args.isNotEmpty()

Method tersebut digunakan untuk memastikan bahwa array args memiliki data.

Hal ini penting karena jika kita langsung mengakses:

args[0]

ketika tidak ada argument, program dapat menghasilkan error:

ArrayIndexOutOfBoundsException

Karena itu, lebih aman melakukan pengecekan terlebih dahulu:

if (args.isNotEmpty()) {
    println(args[0])
}

Contoh Program Biodata

Kita dapat membuat program sederhana yang menerima beberapa argument.

fun main(args: Array<String>) {

    if (args.size >= 3) {
        val firstName = args[0]
        val lastName = args[1]
        val city = args[2]

        println("Nama: $firstName $lastName")
        println("Kota: $city")
    } else {
        println("Argument tidak lengkap")
    }
}

Misalnya diberikan argument:

Ucup Topekox Palu

Output:

Nama: Ucup Topekox
Kota: Palu

Argument dari Command Line

Konsepnya dapat digambarkan:

Command Line
     │
     │ argument
     ▼
main(args: Array<String>)
     │
     ├── args[0]
     ├── args[1]
     └── args[2]

Misalnya:

java Main Ucup Topekox Palu

maka:

args[0] → Ucup
args[1] → Topekox
args[2] → Palu

Parameter main() Harus Bertipe String

Parameter main() untuk menerima command-line arguments menggunakan:

Array<String>

Contoh:

fun main(args: Array<String>) {
    // ...
}

Argument dari command line pada awalnya selalu diterima sebagai String.

Jika kita ingin menggunakan nilai tersebut sebagai Int, kita perlu melakukan konversi.

Konversi Argument ke Int

Misalnya kita ingin menerima umur:

fun main(args: Array<String>) {

    val age = args[0].toInt()

    println("Usia: $age")
}

Jika diberikan argument:

30

maka:

args[0]

berisi:

"30"

Setelah:

.toInt()

menjadi:

30

yang bertipe Int.

Contoh Kalkulator Sederhana

Kita dapat menggunakan main parameter untuk membuat program sederhana.

fun main(args: Array<String>) {

    val a = args[0].toInt()
    val b = args[1].toInt()

    val result = a + b

    println("$a + $b = $result")
}

Jika argument yang diberikan:

10 20

maka:

a = 10
b = 20

Output:

10 + 20 = 30

Perbedaan main() dan main(args: Array<String>)

Kotlin mendukung bentuk main() tanpa parameter:

fun main() {
    println("Hello World")
}

Dan bentuk dengan parameter:

fun main(args: Array<String>) {
    println("Hello ${args[0]}")
}

Perbedaannya:

fun main()
    ↓
Tidak menerima command-line argument secara langsung.

fun main(args: Array<String>)
    ↓
Menerima command-line argument melalui args.

Contoh Program Lengkap

fun main(args: Array<String>) {

    if (args.isEmpty()) {
        println("Tidak ada argument")
        return
    }

    println("Jumlah argument: ${args.size}")

    for (arg in args) {
        println("Argument: $arg")
    }
}

Jika dijalankan dengan:

Kotlin Java Python

output:

Jumlah argument: 3
Argument: Kotlin
Argument: Java
Argument: Python

Kesimpulan

main() adalah function yang menjadi titik awal eksekusi program Kotlin.

Bentuk sederhana:

fun main() {
    println("Hello World")
}

Sedangkan jika ingin menerima command-line argument:

fun main(args: Array<String>) {
    println(args[0])
}

args memiliki tipe:

Array<String>

Setiap argument dapat diakses menggunakan index:

args[0]
args[1]
args[2]

Index array dimulai dari 0.

Jika argument:

Ucup Topekox Palu

maka:

args[0] → "Ucup"
args[1] → "Topekox"
args[2] → "Palu"

Jika argument ingin digunakan sebagai tipe data lain, kita perlu melakukan konversi.

Contoh:

val age = args[0].toInt()

Jadi, prinsip sederhananya:

tip

Main Parameter memungkinkan program Kotlin menerima data dari command line melalui parameter Array<String>.