Fehlerbehandlung in IO
handleError
Fehlerbehandlung in IO ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Fehler als Werte
In Cats Effect kann ein IO fehlschlagen. Der Fehler ist Bestandteil des Werts, sodass Sie ihn untersuchen und behandeln können, ohne ein unstrukturiertes try/catch zu verwenden.
Fehler auslösen
Verwenden Sie IO.raiseError, um ausdrücklich ein fehlgeschlagenes IO mit einer ausgewählten Ausnahme zu erstellen.
import cats.effect.IO
val failed: IO[Int] =
IO.raiseError(new RuntimeException("boom"))handleError
handleError behandelt ein fehlgeschlagenes IO, indem es einen aus dem Fehler berechneten Ersatzwert liefert. Das Ergebnis ist an dieser Stelle ein IO, das nicht fehlschlagen kann.
import cats.effect.IO
val safe: IO[Int] =
IO.raiseError[Int](new RuntimeException("x"))
.handleError(_ => -1)handleErrorWith
handleErrorWith behandelt den Fehler mit einem anderen IO, sodass der Ersatz selbst einen Effekt haben kann (z. B. Protokollieren, Wiederholen oder Zurückgeben eines Standardwerts).
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 wandelt ein IO[A] in IO[Either[Throwable, A]] um und macht den Fehler zu einem Wert, sodass Sie ihn per Pattern Matching verarbeiten können.
import cats.effect.IO
val e: IO[Either[Throwable, Int]] =
IO.raiseError[Int](new RuntimeException("oops")).attemptPattern Matching mit attempt
Nach attempt können Sie mit einem normalen flatMap über das Either zwischen Erfolg und Fehler verzweigen.
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 behandelt beide Zweige in einem Aufruf: eine Funktion für den Fehler und eine für den Erfolg, wobei beide einen normalen Wert zurückgeben.
import cats.effect.IO
val label: IO[String] =
IO(42).redeem(e => s"failed: $e", v => s"value: $v")redeemWith
redeemWith funktioniert wie redeem, aber jeder Zweig gibt ein IO zurück, sodass sowohl die Erfolgs- als auch die Fehlerbehandlung Effekte haben kann.
import cats.effect.IO
val prog: IO[Unit] = IO(42).redeemWith(
e => IO.println(s"err: $e"),
v => IO.println(s"got: $v")
)Aufräumen mit guarantee
guarantee führt einen abschließenden Bereinigungsschritt aus, unabhängig davon, ob der Effekt erfolgreich ist oder fehlschlägt – ideal zum Freigeben von Ressourcen oder Protokollieren des Abschlusses.
import cats.effect.IO
val prog: IO[Int] =
IO(compute()).guarantee(IO.println("done"))
def compute(): Int = 7Bei Fehlern wiederholen
Sie können eine einfache Wiederholung aufbauen, indem Sie mit handleErrorWith rekursiv behandeln und einen Zähler verringern, bis er null erreicht.
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))Einfaches Scala try/catch
Vergleichen Sie dies mit der klassischen, sofort ausgewerteten Fehlerbehandlung in einfachem Scala. Die Kombinatoren von IO bieten dieselbe Sicherheit, jedoch als kombinierbare, reine Werte.
object Main {
def main(args: Array[String]): Unit = {
val result = try { 10 / 0 } catch { case _: ArithmeticException => -1 }
println(s"result: $result")
}
}Kurztest
Welche Methode wandelt ein IO[A] in IO[Either[Throwable, A]] um?
Zusammenfassung
Sie haben Fehler in IO behandelt mit:
raiseErrorzum ausdrücklichen Auslösen von FehlernhandleError/handleErrorWithzur Fehlerbehandlungattempt, umEitherals Wert verfügbar zu machenredeem/redeemWithfür beide Zweigeguaranteezum Aufräumen
Sie haben den Cats-und-IO-Kurs abgeschlossen.
Lerne Scala mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 39
- Lektionen
- 143
Häufig gestellte Fragen
Ist die Lektion „Fehlerbehandlung in IO“ kostenlos?
Ja — der vollständige Text von „Fehlerbehandlung in IO“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Fehlerbehandlung in IO“?
handleError Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Fehlerbehandlung in IO“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Cats-Typeclasses
- Die IO-Monade
- IO kombinieren
- Fehlerbehandlung in IO