Kotlin: Kuasai if-else dan when Expression

Pengantar: Gerbang Logika dalam Pemrograman Kotlin

Dalam dunia pemrograman, kemampuan untuk membuat keputusan dan mengarahkan alur eksekusi kode adalah fundamental. Di Kotlin, dua struktur kontrol yang paling sering digunakan untuk mencapai hal ini adalah if-else dan when expression. Memahami dan menguasai keduanya tidak hanya akan membuat kode Anda lebih fleksibel, tetapi juga lebih ringkas, mudah dibaca, dan efisien. Artikel ini akan membimbing Anda melalui seluk-beluk kedua fitur ini, dari dasar hingga tips lanjutan yang akan meningkatkan keahlian pemrograman Kotlin Anda.

1. if-else Statement: Pilihan Biner yang Kuat

Pernyataan if-else adalah blok kode paling dasar untuk membuat keputusan. Ia mengevaluasi suatu kondisi dan menjalankan blok kode yang berbeda berdasarkan apakah kondisi tersebut bernilai true atau false.

Sintaks Dasar

if (kondisi) {
    // Kode yang dijalankan jika kondisi bernilai true
} else {
    // Kode yang dijalankan jika kondisi bernilai false
}

Contoh: Memeriksa apakah suatu angka genap atau ganjil.

fun checkEvenOrOdd(number: Int) {
    if (number % 2 == 0) {
        println("$number adalah bilangan genap.")
    } else {
        println("$number adalah bilangan ganjil.")
    }
}

fun main() {
    checkEvenOrOdd(10) // Output: 10 adalah bilangan genap.
    checkEvenOrOdd(7)  // Output: 7 adalah bilangan ganjil.
}

if-else if-else: Pilihan Berganda

Anda bisa menggabungkan beberapa kondisi menggunakan else if untuk menangani lebih dari dua kemungkinan.

fun checkGrade(score: Int) {
    if (score >= 90) {
        println("Nilai Anda A")
    } else if (score >= 80) {
        println("Nilai Anda B")
    } else if (score >= 70) {
        println("Nilai Anda C")
    } else {
        println("Nilai Anda D")
    }
}

fun main() {
    checkGrade(95) // Output: Nilai Anda A
    checkGrade(82) // Output: Nilai Anda B
    checkGrade(65) // Output: Nilai Anda D
}

if-else sebagai Expression (Sangat Kotlin-esque!)

Salah satu fitur paling kuat dan idiomatik di Kotlin adalah kemampuan untuk menggunakan if-else sebagai expression. Ini berarti if-else dapat mengembalikan nilai, yang kemudian bisa Anda tetapkan ke variabel.

fun getStatus(isLoggedIn: Boolean): String {
    return if (isLoggedIn) {
        "Welcome back!"
    } else {
        "Please log in."
    }
}

fun main() {
    val userStatus = getStatus(true)
    println(userStatus) // Output: Welcome back!

    val anotherStatus = getStatus(false)
    println(anotherStatus) // Output: Please log in.
}

Tips Praktis:

• Gunakan if-else sebagai Expression untuk nilai yang dapat ditetapkan: Ini membuat kode lebih ringkas daripada membuat variabel di dalam blok if atau else.
• Hindari blok if-else yang sangat panjang: Jika logika menjadi terlalu kompleks, pertimbangkan untuk mengekstraknya ke dalam fungsi terpisah atau menggunakan when.

2. when Expression: Kekuatan Pencocokan Pola yang Fleksibel

when expression adalah alternatif yang lebih kuat dan serbaguna untuk if-else if-else chain, terutama ketika Anda perlu mencocokkan sebuah nilai terhadap serangkaian kemungkinan nilai atau pola.

Sintaks Dasar

when dapat digunakan sebagai statement (tidak mengembalikan nilai) atau sebagai expression (mengembalikan nilai).

when sebagai Statement

when (ekspresi_untuk_dicocokkan) {
    nilai1 -> { // blok kode jika ekspresi == nilai1 }
    nilai2, nilai3 -> { // blok kode jika ekspresi == nilai2 ATAU nilai3 }
    in rentang -> { // blok kode jika ekspresi ada dalam rentang }
    else -> { // blok kode jika tidak ada yang cocok }
}

Contoh: Menentukan hari dalam seminggu.

fun printDayType(day: String) {
    when (day) {
        "Sabtu", "Minggu" -> println("Ini adalah akhir pekan!")
        "Senin", "Selasa", "Rabu", "Kamis", "Jumat" -> println("Ini adalah hari kerja.")
        else -> println("Hari tidak valid.")
    }
}

fun main() {
    printDayType("Sabtu")  // Output: Ini adalah akhir pekan!
    printDayType("Rabu")   // Output: Ini adalah hari kerja.
    printDayType("Funday") // Output: Hari tidak valid.
}

when sebagai Expression

Saat digunakan sebagai expression, when harus exhaustive (mencakup semua kemungkinan). Jika tidak ada branch yang cocok, exception akan dilempar (kecuali Anda menyertakan branch else).

fun getMonthName(monthNumber: Int): String {
    return when (monthNumber) {
        1 -> "Januari"
        2 -> "Februari"
        3 -> "Maret"
        4 -> "April"
        5 -> "Mei"
        6 -> "Juni"
        7 -> "Juli"
        8 -> "Agustus"
        9 -> "September"
        10 -> "Oktober"
        11 -> "November"
        12 -> "Desember"
        else -> "Bulan tidak valid" // Branch else diperlukan untuk exhaustiveness jika rentangnya tidak terbatas
    }
}

fun main() {
    val currentMonth = getMonthName(8)
    println("Bulan ini adalah: $currentMonth") // Output: Bulan ini adalah: Agustus
}

when Tanpa Argumen (Kekuatan Penuh)

Anda juga dapat menggunakan when tanpa argumen, di mana setiap branch adalah kondisi boolean. Ini sangat berguna untuk mengganti if-else if-else chain yang kompleks.

fun processMessage(message: Any): String {
    return when {
        message is String && message.length > 10 -> "Pesan string panjang: $message"
        message is String -> "Pesan string pendek: $message"
        message is Int -> "Ini adalah angka: $message"
        message is Boolean -> "Ini adalah boolean: $message"
        else -> "Tipe pesan tidak dikenal."
    }
}

fun main() {
    println(processMessage("Ini adalah pesan yang cukup panjang."))
    // Output: Pesan string panjang: Ini adalah pesan yang cukup panjang.

    println(processMessage(123))
    // Output: Ini adalah angka: 123

    println(processMessage(false))
    // Output: Ini adalah boolean: false

    println(processMessage(listOf(1, 2, 3)))
    // Output: Tipe pesan tidak dikenal.
}

Tips Praktis yang Jarang Diketahui Pemula:

• Exhaustiveness pada when Expression: Ketika when digunakan sebagai expression dan Anda ingin memastikan semua kemungkinan ditangani, pastikan Anda memiliki branch else. Jika Anda tidak yakin semua kasus tercakup (misalnya, ketika memeriksa enum atau sealed class), Kotlin compiler akan membantu Anda mendeteksinya.
• Kombinasi is dan in: Gunakan is untuk memeriksa tipe data dan in untuk memeriksa apakah nilai berada dalam suatu rentang atau koleksi.
• when untuk sealed class: Ini adalah penggunaan when yang paling kuat. Jika Anda memiliki sealed class dan menggunakan when untuk mencocokkan semua turunannya, Anda tidak memerlukan branch else. Compiler akan menjamin exhaustiveness.

Contoh Implementasi Nyata: Mengelola Status Transaksi

Bayangkan Anda sedang membangun aplikasi pembayaran dan perlu mengelola status transaksi.

enum class TransactionStatus {
    PENDING,
    PROCESSING,
    SUCCESS,
    FAILED,
    CANCELLED
}

fun getTransactionMessage(status: TransactionStatus): String {
    return when (status) {
        TransactionStatus.PENDING -> "Transaksi sedang menunggu konfirmasi."
        TransactionStatus.PROCESSING -> "Transaksi sedang diproses oleh sistem."
        TransactionStatus.SUCCESS -> "Transaksi berhasil diselesaikan."
        TransactionStatus.FAILED -> "Transaksi gagal. Silakan coba lagi."
        TransactionStatus.CANCELLED -> "Transaksi dibatalkan."
    }
}

fun main() {
    val transactionStatus = TransactionStatus.SUCCESS
    val message = getTransactionMessage(transactionStatus)
    println("Status transaksi: $message") // Output: Status transaksi: Transaksi berhasil diselesaikan.
}

Dalam contoh ini, when expression yang mencocokkan enum class memastikan setiap status ditangani dengan rapi, dan karena TransactionStatus adalah enum, when secara otomatis dianggap exhaustive tanpa perlu else.

Kesimpulan: Memilih Alat yang Tepat untuk Pekerjaan

Baik if-else maupun when adalah alat yang tak ternilai dalam toolkit programmer Kotlin.

• Gunakan if-else untuk keputusan biner sederhana atau ketika Anda perlu mengembalikan nilai dari sebuah ekspresi.
• Beralih ke when ketika Anda berhadapan dengan multi-kondisi, pencocokan tipe, atau ketika Anda membutuhkan fleksibilitas pencocokan pola yang lebih canggih.

Dengan mempraktikkan dan menerapkan struktur kontrol ini dalam proyek Anda, Anda akan menemukan diri Anda menulis kode Kotlin yang lebih bersih, lebih ekspresif, dan lebih efisien. Selamat membuat keputusan cerdas dalam kode Anda!