Either kombinieren
map und flatMap
Either kombinieren ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 3 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.
Berechnungen kombinieren
In realen Programmen werden mehrere fehleranfällige Schritte verkettet: parsen, validieren, nachschlagen, berechnen. Mit Either können Sie diese so kombinieren, dass der erste Fehler die gesamte Kette abbricht.
Die Werkzeuge dafür sind map, flatMap und for-Comprehensions.
flatMap reiht Eithers aneinander
flatMap wendet eine Funktion an, die selbst ein Either zurückgibt. Ist der Empfänger ein Left, wird die Funktion nie aufgerufen und das Left weitergegeben.
object Main {
def positive(n: Int): Either[String, Int] =
if (n > 0) Right(n) else Left("not positive")
def main(args: Array[String]): Unit = {
val r = Right(5).flatMap(positive)
val l = Right(-1).flatMap(positive)
println(r)
println(l)
}
}Kurzschlussverhalten
Wenn Sie mehrere flatMap-Aufrufe verketten, beendet das erste Left die gesamte Verarbeitung. Nachfolgende Schritte werden übersprungen, und dieser Fehler wird zum Endergebnis.
object Main {
def step(label: String, n: Int): Either[String, Int] = {
println(s"running $label")
Right(n + 1)
}
def main(args: Array[String]): Unit = {
val result = Left("early error").asInstanceOf[Either[String, Int]]
.flatMap(n => step("A", n))
.flatMap(n => step("B", n))
println(result)
}
}for-Comprehension über Either
Da Either Right-biased ist, können Sie es in einer for-Comprehension verwenden. Jedes <- entpackt ein Right; ein Left beendet die Comprehension und wird zum Ergebnis.
object Main {
def parse(s: String): Either[String, Int] =
s.toIntOption.toRight(s"bad: $s")
def main(args: Array[String]): Unit = {
val sum = for {
a <- parse("3")
b <- parse("4")
} yield a + b
println(sum)
}
}Eine fehlschlagende for-Comprehension
Liefert ein Schritt der Comprehension ein Left, besteht der gesamte Ausdruck aus diesem Left und nachfolgende Schritte werden nicht ausgeführt.
object Main {
def parse(s: String): Either[String, Int] =
s.toIntOption.toRight(s"bad: $s")
def main(args: Array[String]): Unit = {
val sum = for {
a <- parse("3")
b <- parse("oops")
c <- parse("5")
} yield a + b + c
println(sum)
}
}Validierungen verketten
Eine realistische Pipeline: Parsen Sie einen String, prüfen Sie anschließend eine Geschäftsregel und transformieren Sie dann das Ergebnis. Jede Stufe gibt ein Either zurück.
object Main {
def parse(s: String): Either[String, Int] = s.toIntOption.toRight("not a number")
def checkRange(n: Int): Either[String, Int] =
if (n >= 1 && n <= 100) Right(n) else Left("out of range")
def process(s: String): Either[String, Int] =
parse(s).flatMap(checkRange).map(_ * 10)
def main(args: Array[String]): Unit = {
println(process("7"))
println(process("500"))
println(process("x"))
}
}map im Vergleich zu flatMap
Verwenden Sie map, wenn Ihre Funktion einen einfachen Wert zurückgibt. Verwenden Sie flatMap, wenn sie ein weiteres Either zurückgibt, um ein verschachteltes Either[String, Either[String, Int]] zu vermeiden.
@main def run(): Unit = {
val withMap: Either[String, Int] = Right(2).map(_ + 1)
val nested: Either[String, Either[String, Int]] = Right(2).map(n => Right(n + 1))
val flat: Either[String, Int] = Right(2).flatMap(n => Right(n + 1))
println(withMap)
println(nested)
println(flat)
}Unabhängige Werte kombinieren
Eine for-Comprehension funktioniert auch dann, wenn jeder Schritt nicht vom vorherigen abhängt. Alle Schritte müssen erfolgreich sein, damit das abschließende yield ausgeführt wird.
object Main {
def parse(s: String): Either[String, Int] = s.toIntOption.toRight(s"bad: $s")
def main(args: Array[String]): Unit = {
val combined = for {
x <- parse("10")
y <- parse("20")
z <- parse("30")
} yield List(x, y, z).sum
println(combined)
}
}Fehlertransformation im leftMap-Stil
Die Standardbibliothek bietet für Either kein leftMap. Sie können den Fehler jedoch mit swap.map(...).swap oder durch Mapping innerhalb eines fold transformieren. So bleiben die Fehlertypen in einer Pipeline konsistent.
@main def run(): Unit = {
val e: Either[String, Int] = Left("low-level error")
val mapped = e.swap.map(msg => s"context: $msg").swap
println(mapped)
}Alles zusammenführen
Eine kleine Taschenrechner-Pipeline, die zwei Zahlen parst und dividiert und jeden Fehler als typisierten Fehler meldet.
object Main {
def parse(s: String): Either[String, Int] = s.toIntOption.toRight(s"bad number: $s")
def divide(a: Int, b: Int): Either[String, Int] =
if (b == 0) Left("division by zero") else Right(a / b)
def calc(x: String, y: String): Either[String, Int] =
for {
a <- parse(x)
b <- parse(y)
r <- divide(a, b)
} yield r
def main(args: Array[String]): Unit = {
println(calc("20", "4"))
println(calc("20", "0"))
println(calc("x", "4"))
}
}Warum das wichtig ist
Durch das Kombinieren von Either erhalten Sie railway-oriented programming: Der Erfolgsweg verläuft durch Right, während jeder Fehler auf das Left-Gleis abzweigt und den Rest umgeht. Keine Exceptions, keine Null-Prüfungen, nur Werte.
Kurze Überprüfung
Testen Sie Ihr Verständnis vom Kombinieren von Either.
Zusammenfassung
Sie haben gelernt, Either zu kombinieren:
flatMapreiht fehleranfällige Schritte aneinander und bricht beim erstenLeftab.for-Comprehensions sind für mehrstufige Pipelines übersichtlich lesbar.- Verwenden Sie
mapfür einfache Ergebnisse undflatMapfür Funktionen, die Either zurückgeben. - Transformieren Sie Fehler mit
swap.map(...).swap.
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 „Either kombinieren“ kostenlos?
Ja — der vollständige Text von „Either kombinieren“ 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 kombinieren“?
map und flatMap 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 4.
Wie lange dauert die Lektion „Either kombinieren“?
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
- Either für Fehler
- Try, Success, Failure
- Either kombinieren
- Zwischen Typen konvertieren