Kotlin Academy · Pelajaran

Either<L, R>: Pengendalian Error Bertaip Tanpa Exception

Gunakan Either untuk mewakili kejayaan dan kegagalan tanpa melontarkan pengecualian.

Pelajaran 1 daripada 413 langkah

Either<L, R>: Pengendalian Error Bertaip Tanpa Exception ialah pelajaran Kotlin Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kotlin Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kotlin Academy merangkumi sejumlah 4 pelajaran.

Masalah Menggunakan Pengecualian untuk Logik Perniagaan

Pengecualian direka untuk kegagalan yang tidak dijangka (penuding null, ralat IO). Menggunakannya untuk menandakan kegagalan perniagaan yang dijangka (kegagalan pengesahan, "tidak ditemui") menjadikan aliran kawalan tidak jelas, memaksa anda menggunakan try/catch di setiap lokasi panggilan, dan menyembunyikan ralat dalam tandatangan fungsi.

Apakah Either<L, R>?

Either ialah jenis jumlah dengan dua kes: Left(value: L) lazimnya menyimpan ralat, manakala Right(value: R) lazimnya menyimpan nilai kejayaan. Fungsi yang memulangkan Either menjadikan kemungkinan kegagalan jelas dalam tandatangannya.

Either Arrow

Tambahkan Arrow pada projek anda untuk mendapatkan Either dan ekosistem lengkap pengendalinya:

// build.gradle.kts
implementation("io.arrow-kt:arrow-core:1.2.4")

// Usage
import arrow.core.Either
import arrow.core.left
import arrow.core.right

Memulangkan Either daripada Fungsi

Memulangkan value.right() untuk kejayaan dan error.left() untuk kegagalan. Pemanggil mesti mengendalikan kedua-dua cabang:

sealed class UserError { object NotFound : UserError(); data class InvalidEmail(val msg: String) : UserError() }

fun findUser(id: Long): Either<UserError, User> =
    if (id <= 0) UserError.NotFound.left()
    else User(id, "Alice").right()

Mengendalikan Either dengan fold

Gunakan fold(ifLeft, ifRight) untuk mengendalikan kedua-dua kes dalam satu ungkapan:

val result = findUser(1L)
val message = result.fold(
    ifLeft  = { error -> "Error: $error" },
    ifRight = { user  -> "Found: ${user.name}" }
)
println(message)

Mengubah Nilai Right dengan map

map { } mengubah nilai Right tanpa menyentuh Left. Ini menjadikan Either sebagai funktor — anda boleh merangkaikan perubahan dengan selamat:

val nameResult: Either<UserError, String> = findUser(1L).map { it.name }

Merangkaikan dengan flatMap

flatMap { } merangkaikan pengiraan yang sendiri memulangkan Either. Jika mana-mana langkah memulangkan Left, rantaian dihentikan serta-merta dan ralat disebarkan tanpa melaksanakan langkah seterusnya:

fun validateEmail(email: String): Either<UserError, String> =
    if (email.contains("@")) email.right()
    else UserError.InvalidEmail("bad format").left()

fun createUser(email: String): Either<UserError, User> =
    validateEmail(email).flatMap { validEmail ->
        User(1L, validEmail).right()
    }

Either.catch untuk Membungkus Pengecualian

Either.catch { } menjalankan satu blok dan membungkus sebarang pengecualian sebagai Left<Throwable>. Gunakannya pada sempadan antara kod legasi yang melontarkan pengecualian dengan domain berasaskan Either anda:

val result: Either<Throwable, User> = Either.catch {
    userRepository.findOrThrow(id)
}

Memulihkan dengan getOrElse dan orElse

getOrElse { default } mengekstrak nilai Right atau mengembalikan nilai lalai. orElse { alternativeEither } menggantikan Left dengan pengiraan lain:

val user: User = findUser(0L).getOrElse { User(-1L, "Guest") }
val user2: Either<UserError, User> = findUser(0L).orElse { User(99L, "Default").right() }

Padanan Corak dengan when

Gunakan when pada kelas seperti Either yang dimeterai atau pada Either itu sendiri dengan is Either.Left / Either.Right untuk mengendalikan semua kes secara menyeluruh:

when (val r = findUser(1L)) {
    is Either.Left  -> println("Error: ${r.value}")
    is Either.Right -> println("User: ${r.value.name}")
}

Either dalam Lapisan Perkhidmatan

Mulangkan Either daripada fungsi repositori dan perkhidmatan. Petakannya kepada respons HTTP pada peringkat laluan Ktor supaya logik perniagaan tidak bergantung pada kebimbangan rangka kerja:

get("/users/{id}") {
    val id = call.parameters["id"]?.toLongOrNull() ?: return@get call.respond(HttpStatusCode.BadRequest)
    userService.findById(id).fold(
        ifLeft  = { call.respond(HttpStatusCode.NotFound) },
        ifRight = { call.respond(it) }
    )
}

Semakan Ringkas

Apakah yang dilakukan oleh flatMap { } pada nilai Either.Left?

Jawab dalam pelajaran interaktif

Ringkasan: Either<L, R>

Perkara utama:

Either menjadikan laluan kegagalan jelas dalam tandatangan fungsi
Right = kejayaan; Left = kegagalan (mengikut kebiasaan)
map { } — ubah nilai kejayaan; flatMap { } — rangkaikan pengiraan yang boleh gagal
fold(ifLeft, ifRight) — kendalikan kedua-dua kes dalam satu ungkapan
Either.catch { } — bungkus kod yang melontarkan pengecualian pada sempadan

Percuma untuk bermula

Pelajari Kotlin dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 51
Pelajaran: 203

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Either<L, R>: Pengendalian Error Bertaip Tanpa Exception” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kotlin Academy, termasuk “Either<L, R>: Pengendalian Error Bertaip Tanpa Exception”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kotlin Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Either<L, R>: Pengendalian Error Bertaip Tanpa Exception”?

Gunakan Either untuk mewakili kejayaan dan kegagalan tanpa melontarkan pengecualian. Anda berlatih Kotlin Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kotlin Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kotlin Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Either<L, R>: Pengendalian Error Bertaip Tanpa Exception” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Either : Pengendalian Error Bertaip Tanpa Exception
DSL Raise Arrow: Menggabungkan Ralat Bertype
Option dan Nullable: Bila Menggunakan Setiap Satu
Pemodelan Domain Fungsian dengan Jenis Teras Arrow

← Kembali ke Kotlin Academy