Kotlin Academy · Pelajaran

Penanganan Error Fungsional

Petakan dan pulihkan

Penanganan Error Fungsional adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 4 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.

Kesalahan sebagai Aliran Data

Penanganan kesalahan fungsional memperlakukan kegagalan sebagai nilai yang dapat Anda ubah, rangkai, dan pulihkan—sama seperti Anda mengubah nilai yang berhasil. Result bawaan menyediakan operator khusus untuk hal ini.

map

map mengubah nilai success dan membiarkan failure tetap utuh, lalu meneruskannya tanpa perubahan.

fun main() {
    val r = Result.success(5).map { it * 2 }
    println(r.getOrNull())
    val f = Result.failure<Int>(Exception("x")).map { it * 2 }
    println(f.getOrNull())
}

mapCatching

Jika transformasinya sendiri mungkin melempar pengecualian, mapCatching menangkap pengecualian tersebut ke dalam hasil alih-alih membiarkannya keluar.

fun main() {
    val r = Result.success("10").mapCatching { it.toInt() }
    println(r.getOrNull())
    val bad = Result.success("oops").mapCatching { it.toInt() }
    println(bad.isFailure)
}

recover

recover mengubah failure kembali menjadi success dengan menghitung nilai dari pengecualian. Success diteruskan tanpa perubahan.

fun main() {
    val r = Result.failure<Int>(Exception("down")).recover { 0 }
    println(r.getOrNull())
    val ok = Result.success(7).recover { 0 }
    println(ok.getOrNull())
}

recoverCatching

Saat logika pemulihan juga mungkin gagal, recoverCatching membungkus percobaan tersebut, sehingga semuanya tetap menjadi hasil.

fun main() {
    val r = Result.failure<Int>(Exception()).recoverCatching {
        "5".toInt()
    }
    println(r.getOrNull())
}

onSuccess dan onFailure

Fungsi ini menjalankan efek samping tanpa mengubah hasil, lalu mengembalikannya untuk rangkaian berikutnya. Cocok untuk pencatatan.

fun main() {
    runCatching { "3".toInt() }
        .onSuccess { println("ok " + it) }
        .onFailure { println("fail " + it.message) }
        .also { println("done") }
}

Merangkai Alur

Operator-operator dirangkai menjadi alur yang rapi: menangkap, mengubah, dan memulihkan, semuanya tanpa try/catch bersarang.

fun main() {
    val result = runCatching { "21".toInt() }
        .map { it * 2 }
        .recover { -1 }
        .getOrThrow()
    println(result)
}

fold ke Nilai Akhir

Akhiri alur dengan fold untuk menggabungkan kedua cabang menjadi satu nilai konkret, misalnya pesan yang ditujukan kepada pengguna.

fun main() {
    val msg = runCatching { "x".toInt() }
        .map { it + 1 }
        .fold(
            onSuccess = { "result: " + it },
            onFailure = { "failed: " + it.message }
        )
    println(msg)
}

Memetakan Tipe Kustom

Anda dapat memberikan tipe hasil tersegel buatan sendiri kemudahan penggunaan yang sama dengan menulis fungsi ekstensi seperti map.

sealed class Res<out T> {
    data class Ok<T>(val v: T) : Res<T>()
    data class Err(val msg: String) : Res<Nothing>()
}

fun <T, R> Res<T>.map(f: (T) -> R): Res<R> = when (this) {
    is Res.Ok -> Res.Ok(f(v))
    is Res.Err -> this
}

fun main() {
    val r = Res.Ok(4).map { it * 3 }
    println(r)
}

Mengapa Gaya Fungsional

Penanganan galat fungsional menjaga jalur sukses tetap mudah dibaca, sementara galat mengalir secara deklaratif. Tidak ada try/catch yang tersebar, dan sistem tipe melacak kegagalan dari awal hingga akhir.

Menyatukan Semuanya

Anda sekarang memiliki perangkat lengkap:

map / mapCatching untuk mengubah
recover / recoverCatching untuk memulihkan
onSuccess / onFailure untuk efek samping
fold untuk menyelesaikan

Pemeriksaan Singkat

Uji pemahaman Anda tentang penanganan galat fungsional.

Ringkasan

Anda telah mempelajari penanganan galat fungsional:

Ubah dengan map / mapCatching
Pulihkan dengan recover / recoverCatching
Amati dengan onSuccess / onFailure
Selesaikan dengan fold

Dengan demikian, kursus pemodelan hasil dan galat ini selesai.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penanganan Error Fungsional” gratis?

Ya — teks lengkap “Penanganan Error Fungsional” 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 “Penanganan Error Fungsional”?

Petakan dan pulihkan 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 4 dari 4.

Berapa lama pelajaran “Penanganan Error Fungsional” 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

← Kembali ke Kotlin Academy