Scala for Backend Engineering & Functional Programming · Lektion

Zwischen Typen konvertieren

Option, Either, Try

Lektion 4 von 413 Schritte

Zwischen Typen konvertieren 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.

Drei Fehlermodelle

Scala bietet drei sich ergänzende Typen für Abwesenheit und Fehler:

Option — vorhanden oder nicht vorhanden (ohne Begründung).
Either — Erfolg oder ein typisierter Fehler.
Try — Erfolg oder eine ausgelöste Exception.

Wenn Sie wissen, wie diese Typen ineinander konvertiert werden, können Sie eine API an eine andere anpassen.

Option in Either umwandeln

toRight wandelt ein Option in ein Either um und liefert für den Fall None einen Left-Fehler. toLeft führt die umgekehrte Zuordnung durch.

@main def run(): Unit = {
  val some: Option[Int] = Some(5)
  val none: Option[Int] = None
  println(some.toRight("missing"))
  println(none.toRight("missing"))
}

Either zu Option

toOption verwirft den Fehler: Right(x) wird zu Some(x) und Left(_) zu None. Verwenden Sie dies, wenn der Grund des Fehlschlags keine Rolle mehr spielt.

@main def run(): Unit = {
  val r: Either[String, Int] = Right(42)
  val l: Either[String, Int] = Left("err")
  println(r.toOption)
  println(l.toOption)
}

Try zu Option

Try.toOption wandelt ein Success in Some und ein Failure in None um und verschluckt dabei die Exception.

import scala.util.Try

@main def run(): Unit = {
  println(Try("7".toInt).toOption)
  println(Try("x".toInt).toOption)
}

Try zu Either

Try.toEither erzeugt ein Either[Throwable, T]: Success wird zu Right, Failure zu Left(throwable). Dadurch bleibt die Exception als typisierter linker Wert erhalten.

import scala.util.Try

@main def run(): Unit = {
  val ok = Try("7".toInt).toEither
  val no = Try("x".toInt).toEither
  println(ok)
  println(no.left.map(_.getMessage))
}

Either zu Try

Für die Umwandlung von Either zu Try mit einem einfachen Fehler gibt es keine direkte integrierte Funktion. Sie können eine solche Funktion jedoch selbst erstellen: Verpacken Sie ein Right in Success und ein Left in ein Failure, das eine Exception enthält.

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

object Main {
  def toTry(e: Either[String, Int]): Try[Int] = e match {
    case Right(v) => Success(v)
    case Left(m)  => Failure(new RuntimeException(m))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Right(1)))
    println(toTry(Left("bad")))
  }
}

Option zu Try

Wandeln Sie ein Option in ein Try um, indem Sie für den leeren Fall eine Exception auswählen. Das ist nützlich, wenn eine API ein Try erwartet.

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

object Main {
  def toTry[A](o: Option[A]): Try[A] = o match {
    case Some(v) => Success(v)
    case None    => Failure(new NoSuchElementException("empty"))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Some(9)))
    println(toTry(None))
  }
}

Eine Pipeline vereinheitlichen

Das Mischen von Typen führt zu Reibung. Ein gängiger Ansatz besteht darin, frühzeitig alles in ein Either mit einem einheitlichen Fehlertyp umzuwandeln und anschließend frei zu kombinieren.

import scala.util.Try

object Main {
  def parse(s: String): Either[String, Int] =
    Try(s.toInt).toEither.left.map(_ => s"invalid: $s")

  def lookup(n: Int): Either[String, String] =
    Map(1 -> "one", 2 -> "two").get(n).toRight(s"no entry for $n")

  def main(args: Array[String]): Unit = {
    val result = for {
      n <- parse("2")
      w <- lookup(n)
    } yield w
    println(result)
  }
}

getOrElse für verschiedene Typen

Alle drei Typen unterstützen getOrElse, um einen Wert zu extrahieren oder einen Standardwert bereitzustellen. Dies ist oft der letzte Schritt, mit dem Sie die Welt der Fehlerbehandlung verlassen.

import scala.util.Try

@main def run(): Unit = {
  val a = Some(1).getOrElse(0)
  val b = (Right(2): Either[String, Int]).getOrElse(0)
  val c = Try("x".toInt).getOrElse(0)
  println(s"$a $b $c")
}

Den passenden Typ auswählen

Richtlinien:

Verwenden Sie Option, wenn das Fehlen keiner Erklärung bedarf.
Verwenden Sie Either, wenn Sie einen domänenspezifischen Fehlerwert benötigen.
Verwenden Sie Try an den Grenzen zu Java- oder Bibliothekscode, der Exceptions auslöst.

Beispiel von Anfang bis Ende

Lesen von Code, der Exceptions auslöst, mit Try, Umwandeln in Either für Domänenfehler und schließlich in Option für einen Aufrufer, der sich nur dafür interessiert, ob ein Wert vorhanden ist.

import scala.util.Try

object Main {
  def safeDiv(a: Int, b: Int): Option[Int] =
    Try(a / b).toEither.left.map(_ => "math error").toOption

  def main(args: Array[String]): Unit = {
    println(safeDiv(10, 2))
    println(safeDiv(10, 0))
  }
}

Kurze Überprüfung

Testen Sie Ihr Wissen über Umwandlungen.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben gelernt, zwischen Option, Either und Try umzuwandeln:

Option.toRight → Either; Either.toOption → Option.
Try.toOption und Try.toEither bilden eine Brücke zwischen Exceptions und Werten.
Vereinheitlichen Sie eine Pipeline frühzeitig auf einen Fehlertyp.
Wählen Sie den Typ, der dem benötigten Detailgrad der Fehler entspricht.

Kostenlos starten

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

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Zwischen Typen konvertieren“ kostenlos?

Ja — der vollständige Text von „Zwischen Typen konvertieren“ 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 „Zwischen Typen konvertieren“?

Option, Either, Try 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 „Zwischen Typen konvertieren“?

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

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