0Pricing
Kotlin Academy · Pelajaran

runCatching dan Result<T>

Gunakan runCatching untuk membungkus exception dalam Result dan memprosesnya secara fungsional.

runCatching dan Result<T> adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Result<T> Secara Singkat

Result<T> adalah pembungkus Kotlin untuk hasil suatu operasi: berupa keberhasilan dengan nilai bertipe T atau kegagalan dengan Throwable.

Dasar-Dasar runCatching

runCatching { ... } menjalankan blok dan membungkus hasilnya dalam Result.

fun main() {
    val good = runCatching { 10 / 2 }
    val bad  = runCatching { 10 / 0 }
    println("good isSuccess = ${good.isSuccess}")
    println("bad isFailure  = ${bad.isFailure}")
}

Mengekstrak Nilai

getOrNull mengembalikan nilai atau null. getOrThrow melemparkan kembali pengecualian saat terjadi kegagalan. getOrDefault mengembalikan nilai pengganti.

fun main() {
    val r = runCatching { "42".toInt() }
    println(r.getOrNull())          // 42
    println(r.getOrDefault(-1))    // 42
    val bad = runCatching { "x".toInt() }
    println(bad.getOrNull())       // null
    println(bad.getOrDefault(0))   // 0
}

Mengekstrak Pengecualian

exceptionOrNull() mengembalikan pengecualian saat terjadi kegagalan, atau null saat berhasil.

fun main() {
    val r = runCatching { error("boom") }
    println(r.exceptionOrNull()?.message) // boom
}

Mengubah dengan map

map { value -> ... } mengubah nilai keberhasilan. Kegagalan diteruskan tanpa perubahan.

fun main() {
    val r = runCatching { "10" }.map { it.toInt() * 2 }
    println(r.getOrNull()) // 20
}

mapCatching

mapCatching membungkus transformasi dalam try/catch sehingga pengecualian di dalam lambda juga menjadi kegagalan.

fun main() {
    val r = runCatching { "abc" }.mapCatching { it.toInt() }
    println(r.isFailure) // true
    println(r.exceptionOrNull()?.message) // For input string: "abc"
}

recover dan recoverCatching

recover { e -> fallback } mengubah kegagalan menjadi keberhasilan dengan menghitung nilai pemulihan.

fun main() {
    val r = runCatching { "abc".toInt() }
        .recover { -1 }
    println(r.getOrNull()) // -1
}

onSuccess / onFailure

Gunakan onSuccess dan onFailure untuk efek samping tanpa mengubah Result.

fun main() {
    runCatching { "42".toInt() }
        .onSuccess { println("parsed: $it") }
        .onFailure { println("failed: ${it.message}") }
}

fold untuk Kedua Jalur

fold(onSuccess, onFailure) mengembalikan tipe terpadu dari salah satu cabang—berguna untuk mengubahnya menjadi nilai yang siap digunakan UI.

fun main() {
    val r = runCatching { "10".toInt() }
    val msg: String = r.fold(
        onSuccess = { "OK: $it" },
        onFailure = { "ERR: ${it.message}" }
    )
    println(msg)
}

Menggunakan Result sebagai Tipe Pengembalian

Fungsi dapat mengembalikan Result<T> agar penanganan galat menjadi eksplisit di lokasi pemanggilan.

fun parseInt(s: String): Result<Int> = runCatching { s.toInt() }
fun main() {
    parseInt("42").onSuccess { println("got $it") }
    parseInt("xx").onFailure { println("oops: ${it.message}") }
}

Merangkai Operasi

Gabungkan runCatching dengan map, mapCatching, dan recover untuk alur galat yang lancar.

fun fetchUserId(): Result<Int> = runCatching { 42 }
fun loadName(id: Int): String = "User-$id"
fun main() {
    val name = fetchUserId()
        .map { loadName(it) }
        .recover { "Anonymous" }
        .getOrNull()
    println(name)
}

Pemeriksaan Singkat

Builder mana yang menjalankan blok dan membungkus hasilnya (nilai atau pengecualian) dalam Result?

Rangkuman

Result<T> merepresentasikan keberhasilan atau kegagalan. Buat dengan runCatching; ubah dengan map/mapCatching; pulihkan dengan recover; amati dengan onSuccess/onFailure; dan satukan dengan fold. Sangat cocok untuk alur galat yang eksplisit.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “runCatching dan Result<T>” gratis?

Ya — teks lengkap “runCatching dan Result<T>” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “runCatching dan Result<T>”?

Gunakan runCatching untuk membungkus exception dalam Result dan memprosesnya secara fungsional. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “runCatching dan Result<T>” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. try/catch/finally sebagai Ekspresi
  2. Membuat Class Exception Kustom
  3. runCatching dan Result
  4. Melemparkan Ulang dan Merangkai Exception
← Kembali ke Kotlin Academy