Scala for Backend Engineering & Functional Programming · Pelajaran

Penanganan Error dalam IO

handleError.

Penanganan Error dalam IO adalah pelajaran Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Kesalahan sebagai Nilai

Dalam Cats Effect, sebuah IO dapat gagal. Kegagalan tersebut merupakan bagian dari nilai, sehingga Anda dapat memeriksa dan memulihkannya tanpa try/catch yang tidak terstruktur.

Membangkitkan Kesalahan

Gunakan IO.raiseError untuk membuat IO yang gagal secara eksplisit dengan pengecualian yang dipilih.

import cats.effect.IO

val failed: IO[Int] =
  IO.raiseError(new RuntimeException("boom"))

handleError

handleError memulihkan IO yang gagal dengan menyediakan nilai pengganti yang dihitung dari kesalahan. Hasilnya adalah IO yang tidak dapat gagal pada tahap ini.

import cats.effect.IO

val safe: IO[Int] =
  IO.raiseError[Int](new RuntimeException("x"))
    .handleError(_ => -1)

handleErrorWith

handleErrorWith memulihkan dengan IO lain, sehingga nilai pengganti itu sendiri dapat menghasilkan efek, misalnya mencatat, mencoba lagi, atau mengembalikan nilai bawaan.

import cats.effect.IO

val recovered: IO[Int] =
  IO(throw new RuntimeException("fail"))
    .handleErrorWith(e => IO.println(s"caught: ${e.getMessage}").as(0))

attempt

attempt mengubah IO[A] menjadi IO[Either[Throwable, A]], dengan mewujudkan kesalahan sebagai nilai agar Anda dapat melakukan pencocokan pola terhadapnya.

import cats.effect.IO

val e: IO[Either[Throwable, Int]] =
  IO.raiseError[Int](new RuntimeException("oops")).attempt

Pencocokan Pola dengan attempt

Setelah attempt, Anda dapat memilih cabang berhasil atau gagal dengan flatMap biasa pada Either.

import cats.effect.IO

val prog: IO[Unit] = IO(10 / 2).attempt.flatMap {
  case Right(v) => IO.println(s"ok: $v")
  case Left(e)  => IO.println(s"err: ${e.getMessage}")
}

redeem

redeem menangani kedua cabang dalam satu pemanggilan: satu fungsi untuk kesalahan dan satu fungsi untuk keberhasilan, yang keduanya mengembalikan nilai biasa.

import cats.effect.IO

val label: IO[String] =
  IO(42).redeem(e => s"failed: $e", v => s"value: $v")

redeemWith

redeemWith mirip dengan redeem, tetapi setiap cabang mengembalikan IO, sehingga penanganan keberhasilan maupun kegagalan dapat menghasilkan efek.

import cats.effect.IO

val prog: IO[Unit] = IO(42).redeemWith(
  e => IO.println(s"err: $e"),
  v => IO.println(s"got: $v")
)

Pembersihan dengan guarantee

guarantee menjalankan finalizer baik saat efek berhasil maupun gagal — sangat cocok untuk melepaskan sumber daya atau mencatat penyelesaian.

import cats.effect.IO

val prog: IO[Int] =
  IO(compute()).guarantee(IO.println("done"))

def compute(): Int = 7

Mencoba Lagi saat Gagal

Anda dapat membuat percobaan ulang sederhana dengan memulihkan secara rekursif menggunakan handleErrorWith, lalu mengurangi penghitung hingga mencapai nol.

import cats.effect.IO

def retry[A](io: IO[A], n: Int): IO[A] =
  if (n <= 0) io
  else io.handleErrorWith(_ => retry(io, n - 1))

try/catch Scala Biasa

Bandingkan dengan penanganan kesalahan klasik yang dievaluasi langsung dalam Scala biasa. Kombinator IO memberikan keamanan yang sama, tetapi sebagai nilai murni yang dapat dikomposisikan.

object Main {
  def main(args: Array[String]): Unit = {
    val result = try { 10 / 0 } catch { case _: ArithmeticException => -1 }
    println(s"result: $result")
  }
}

Pemeriksaan Singkat

Metode mana yang mengubah IO[A] menjadi IO[Either[Throwable, A]]?

Rangkuman

Anda telah menangani kesalahan dalam IO dengan:

raiseError untuk gagal secara eksplisit
handleError / handleErrorWith untuk memulihkan
attempt untuk mewujudkan Either
redeem / redeemWith untuk kedua cabang
guarantee untuk pembersihan

Anda telah menyelesaikan kursus Cats dan IO.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penanganan Error dalam IO” gratis?

Ya — teks lengkap “Penanganan Error dalam IO” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Penanganan Error dalam IO”?

handleError. Kamu berlatih Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming 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 dalam IO” 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 Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming 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

Type Class Cats
Monad IO
Menyusun IO
Penanganan Error dalam IO

← Kembali ke Scala for Backend Engineering & Functional Programming