Scala for Backend Engineering & Functional Programming · Lektion

Option, Try und Either für Fehler

Implementieren Sie eine robuste Fehlerbehandlung mit `Option` für fehlende Werte, `Try` für Ausnahmen und `Either` für getrennte Fehler- und Erfolgspfade.

Option, Try und Either für Fehler ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. 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 3 Lektionen.

Fehler elegant behandeln

Beim Programmieren läuft nicht immer alles nach Plan. Dateien existieren möglicherweise nicht, Netzwerk-Anfragen können fehlschlagen oder Berechnungen zu ungültigen Ergebnissen führen.

Wie schreiben wir robusten Code, der solche Situationen elegant behandeln kann?
Scala bietet leistungsfähige Werkzeuge, um Fehler und fehlende Werte zu verwalten, ohne überall auf `null` zurückzugreifen oder Ausnahmen auszulösen.

Das Problem mit Null

Viele Sprachen verwenden null, um das Fehlen eines Werts darzustellen. null ist jedoch eine häufige Fehlerquelle, etwa für die gefürchtete NullPointerException.

Scala rät von der Verwendung von null ab. Stattdessen bietet Scala Typen, die ausdrücklich angeben, ob ein Wert fehlen kann. Dadurch wird Ihr Code sicherer und verständlicher.

Scala Option kennenlernen

Option[A] ist ein Container, der entweder einen Wert vom Typ A (dargestellt durch Some[A]) oder überhaupt keinen Wert (dargestellt durch None) enthalten kann.

Sie müssen den Fall berücksichtigen, dass ein Wert fehlen könnte.
Dadurch werden unerwartete NullPointerExceptions verhindert und Ihr Code wird ausdrücklicher.

Option in Aktion: Some und None

Sehen wir uns an, wie Option funktioniert. Wir definieren eine Funktion, die abhängig von einer ID möglicherweise einen Namen zurückgibt.

object Main {
  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }

  def main(args: Array[String]): Unit = {
    val user1 = findUser(1) // Some("Alice")
    val user2 = findUser(2) // None

    println(s"User 1: $user1")
    println(s"User 2: $user2")
  }
}

Mit Option arbeiten: map und getOrElse

Sie können den Wert innerhalb eines Option mit map transformieren oder mit getOrElse einen Standardwert angeben, falls es None ist.

object Main {
  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }

  def main(args: Array[String]): Unit = {
    val userGreeting = findUser(1).map(name => s"Hello, $name!")
    val defaultGreeting = findUser(2).map(name => s"Hello, $name!").getOrElse("Hello, Guest!")

    println(s"User greeting: $userGreeting")
    println(s"Default greeting: $defaultGreeting")
  }
}

Scala Try kennenlernen

Während Option fehlende Werte behandelt, ist Try[A] für Berechnungen gedacht, die eine Ausnahme auslösen könnten.

Ein Try kann entweder ein Success[A] sein (wenn die Berechnung normal abgeschlossen wird) oder ein Failure[Throwable] (wenn eine Ausnahme auftritt).
Es kapselt Ausnahmen und ermöglicht es Ihnen, diese auf funktionale Weise zu behandeln.

Try in Aktion: Success und Failure

Definieren wir eine Funktion, die eine Ausnahme auslösen könnte (zum Beispiel bei einer Division durch null), und kapseln ihre Ausführung in einem Try.

import scala.util.{Try, Success, Failure}

object Main {
  def divide(a: Int, b: Int): Try[Int] = Try {
    a / b
  }

  def main(args: Array[String]): Unit = {
    val result1 = divide(10, 2) // Success(5)
    val result2 = divide(10, 0) // Failure(java.lang.ArithmeticException: / by zero)

    println(s"Result 1: $result1")
    println(s"Result 2: $result2")
  }
}

Mit Try arbeiten: recover und fold

Try bietet Methoden wie recover, um bestimmte Ausnahmen zu behandeln, oder fold, um Erfolgs- und Fehlerfälle übersichtlich zu verarbeiten.

import scala.util.{Try, Success, Failure}

object Main {
  def parseNumber(s: String): Try[Int] = Try(s.toInt)

  def main(args: Array[String]): Unit = {
    val num1 = parseNumber("123").getOrElse(0)
    val num2 = parseNumber("abc").getOrElse(0)

    val message = parseNumber("456").fold(
      ex => s"Failed to parse: ${ex.getMessage}",
      num => s"Parsed number: $num"
    )

    println(s"Parsed num1: $num1")
    println(s"Parsed num2: $num2")
    println(s"Message: $message")
  }
}

Scala Either kennenlernen

Either[L, R] ist ein Typ, der einen von zwei möglichen Werten darstellt. Üblicherweise gilt:

Left[L] stellt einen Fehler (oder den Fehlertyp L) dar.
Right[R] stellt einen Erfolg (oder den Ergebnistyp R) dar.

Im Gegensatz zu Try können Sie mit Either einen aussagekräftigen Typ für Ihren Fehler angeben, nicht nur einen Throwable.

Either in Aktion: Left und Right

Hier ist eine Funktion, die eine E-Mail-Adresse validiert. Sie gibt entweder eine String-Fehlermeldung (Left) oder die validierte E-Mail-Adresse (Right) zurück.

object Main {
  def validateEmail(email: String): Either[String, String] = {
    if (email.contains("@") && email.contains(".")) Right(email)
    else Left("Invalid email format")
  }

  def main(args: Array[String]): Unit = {
    val email1 = validateEmail("test@example.com") // Right("test@example.com")
    val email2 = validateEmail("invalid-email")   // Left("Invalid email format")

    println(s"Email 1: $email1")
    println(s"Email 2: $email2")
  }
}

Schnelltest: Fehlerbehandlung

Sie schreiben eine Funktion, die einen Konfigurationswert aus einer Map liest. Wenn der Schlüssel existiert, möchten Sie seinen Zeichenkettenwert in eine Ganzzahl umwandeln. Fehlt der Schlüssel oder schlägt die Konvertierung fehl, möchten Sie den Standardwert 0 zurückgeben.

Welche Kombination aus Scala-Typen und -Methoden wäre für diese Aufgabe am geeignetsten?

Zusammenfassung: Option, Try und Either

Wir haben drei leistungsfähige Scala-Typen für eine robuste Fehlerbehandlung kennengelernt:

Option[A]: Für den Umgang mit dem Fehlen eines Werts (Some[A] oder None).
Try[A]: Zum Kapseln von Berechnungen, die Ausnahmen auslösen könnten (Success[A] oder Failure[Throwable]).
Either[L, R]: Zur Darstellung zweier unterschiedlicher Ergebnisse, typischerweise eines Fehlertyps L und eines Erfolgstyps R (Left[L] oder Right[R]).

Durch die Verwendung dieser Typen wird Ihr Scala-Code sicherer, ausdrücklicher und funktionaler!

Häufig gestellte Fragen

Ist die Lektion „Option, Try und Either für Fehler“ kostenlos?

Ja — der vollständige Text von „Option, Try und Either für Fehler“ 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 3 Lektionen.

Was lerne ich in „Option, Try und Either für Fehler“?

Implementieren Sie eine robuste Fehlerbehandlung mit `Option` für fehlende Werte, `Try` für Ausnahmen und `Either` für getrennte Fehler- und Erfolgspfade. 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 3 von 3.

Wie lange dauert die Lektion „Option, Try und Either für Fehler“?

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

Vertiefung zu unveränderlichen Collections
Funktionale Operationen auf Collections
Option, Try und Either für Fehler

← Zurück zu Scala for Backend Engineering & Functional Programming