0Pricing
Scala for Backend Engineering & Functional Programming · Lektion

Either für Fehler

Left und Right

Either für Fehler ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Warum Either?

Either repräsentiert einen Wert, der eine von zwei Möglichkeiten sein kann. Es ist die idiomatische Art, Berechnungen zu modellieren, die möglicherweise fehlschlagen, und dabei Informationen über den Fehler liefern.

  • Left enthält üblicherweise den Fehler.
  • Right enthält üblicherweise den Erfolgswert.

Im Gegensatz zu Option, das nur angibt, dass etwas fehlt, teilt Either Ihnen mit, was schiefgelaufen ist.

Der Either-Typ

Either[A, B] ist ein versiegeltes Trait mit zwei Untertypen: Left[A] und Right[B].

Die Eselsbrücke lautet: Right is right (richtig), Left steht für den Fehler. Dank dieser Konvention arbeiten map und flatMap automatisch auf der Erfolgsseite.

val ok: Either[String, Int] = Right(42)
val err: Either[String, Int] = Left("boom")
println(ok)
println(err)

Either aus einer Funktion zurückgeben

Eine Funktion, die fehlschlagen kann, gibt statt einer Exception ein Either zurück. Der Aufrufer kann anschließend beide Ergebnisse explizit behandeln.

object Main {
  def parseAge(s: String): Either[String, Int] =
    s.toIntOption match {
      case Some(n) if n >= 0 => Right(n)
      case Some(_)          => Left("age cannot be negative")
      case None             => Left("not a number")
    }

  def main(args: Array[String]): Unit = {
    println(parseAge("30"))
    println(parseAge("-5"))
    println(parseAge("x"))
  }
}

Pattern Matching auf Either

Die direkteste Möglichkeit, ein Either zu verarbeiten, ist Pattern Matching. Behandeln Sie Left und Right getrennt.

@main def run(): Unit = {
  val result: Either[String, Int] = Right(10)
  val msg = result match {
    case Right(value) => s"Got value: $value"
    case Left(error)  => s"Failed: $error"
  }
  println(msg)
}

fold: Beide Seiten zusammenführen

fold nimmt zwei Funktionen entgegen: eine für Left und eine für Right, und erzeugt ein einzelnes Ergebnis eines gemeinsamen Typs.

Wenn Sie einen Wert zurückerhalten möchten, ist dies eine kompakte Alternative zu Pattern Matching.

@main def run(): Unit = {
  val r: Either[String, Int] = Right(7)
  val label = r.fold(
    err => s"error: $err",
    num => s"double is ${num * 2}"
  )
  println(label)
}

map arbeitet auf Right

map transformiert den Right-Wert und lässt ein Left unverändert. Dies ist das Right-biased-Verhalten von Scalās Either (seit 2.12).

@main def run(): Unit = {
  val ok: Either[String, Int]  = Right(5)
  val no: Either[String, Int]  = Left("missing")
  println(ok.map(_ + 1))
  println(no.map(_ + 1))
}

getOrElse und Standardwerte

getOrElse extrahiert den Right-Wert oder gibt einen Ersatzwert zurück, wenn das Either ein Left ist.

@main def run(): Unit = {
  val ok: Either[String, Int] = Right(99)
  val no: Either[String, Int] = Left("oops")
  println(ok.getOrElse(0))
  println(no.getOrElse(0))
}

swap: Seiten vertauschen

swap vertauscht Left und Right. Das ist hilfreich, wenn Sie mithilfe von Right-biased-Methoden auf der Fehlerseite arbeiten möchten.

@main def run(): Unit = {
  val err: Either[String, Int] = Left("bad input")
  val swapped = err.swap.map(_.toUpperCase)
  println(swapped)
}

isLeft und isRight

Mit kurzen booleschen Prüfungen können Sie verzweigen, ohne vollständiges Pattern Matching zu verwenden.

  • isRight gibt bei einem Erfolg true zurück.
  • isLeft gibt bei einem Fehler true zurück.
@main def run(): Unit = {
  val r: Either[String, Int] = Right(1)
  println(r.isRight)
  println(r.isLeft)
}

toOption: Den Fehler verwerfen

Wenn Sie nicht mehr wissen müssen, warum etwas fehlgeschlagen ist, konvertiert toOption ein Either in ein Option: Right(x) wird zu Some(x) und Left(_) zu None.

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

Ein Validierungsbeispiel

Fügen wir alles zusammen: Validieren Sie einen Benutzernamen und geben Sie bei einem Fehler einen typisierten Fehler zurück.

object Main {
  def validate(name: String): Either[String, String] =
    if (name.isEmpty) Left("empty name")
    else if (name.length > 10) Left("name too long")
    else Right(name)

  def main(args: Array[String]): Unit = {
    println(validate("alice"))
    println(validate(""))
    println(validate("verylongusername"))
  }
}

Kurze Überprüfung

Testen Sie Ihr Verständnis der Either-Konventionen.

Zusammenfassung

Sie haben gelernt, Fehler mit Either zu modellieren:

  • Right = Erfolg, Left = Fehler (Right-biased).
  • Verarbeiten Sie die Werte mit Pattern Matching oder fold.
  • Transformieren Sie den Erfolg mit map; stellen Sie mit getOrElse Standardwerte bereit.
  • Vertauschen Sie die Seiten mit swap; konvertieren Sie mit toOption.

Als Nächstes behandeln Sie Exceptions mit Try.

Häufig gestellte Fragen

Ist die Lektion „Either für Fehler“ kostenlos?

Ja — der vollständige Text von „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 4 Lektionen.

Was lerne ich in „Either für Fehler“?

Left und Right 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 1 von 4.

Wie lange dauert die Lektion „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

  1. Either für Fehler
  2. Try, Success, Failure
  3. Either kombinieren
  4. Zwischen Typen konvertieren
← Zurück zu Scala for Backend Engineering & Functional Programming