Verwendung mit Option und Future
Monadische Verkettung
Verwendung mit Option und Future 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.
Über Collections hinaus
For-Comprehensions sind nicht auf Listen beschränkt. Jeder Typ, der map und flatMap bereitstellt, kann verwendet werden, darunter Option, Either, Try und Future. Das nennt man monadisches Verketten.
object Main {
def main(args: Array[String]): Unit = {
val sum = for {
a <- Some(10)
b <- Some(20)
} yield a + b
println(sum)
}
}Option bricht bei None frühzeitig ab
Bei Option erzeugt die Comprehension nur dann ein Ergebnis, wenn jeder Generator Some liefert. Ist einer davon None, lautet das gesamte Ergebnis None, und die späteren Schritte werden übersprungen.
object Main {
def main(args: Array[String]): Unit = {
val ok = for {
a <- Some(2)
b <- Some(3)
} yield a * b
val missing = for {
a <- Some(2)
b <- None: Option[Int]
} yield a * b
println(ok)
println(missing)
}
}Optionale Lookups verketten
Ein häufiges Muster besteht darin, Schlüssel in einer Map nachzuschlagen, wobei jeder Lookup ein Option zurückgibt. Die For-Comprehension liefert nur dann einen Wert, wenn alle Lookups erfolgreich sind.
object Main {
def main(args: Array[String]): Unit = {
val prices = Map("apple" -> 3, "bread" -> 5)
val total = for {
a <- prices.get("apple")
b <- prices.get("bread")
} yield a + b
println(total)
val missing = for {
a <- prices.get("apple")
c <- prices.get("milk")
} yield a + c
println(missing)
}
}Warum das besser ist als verschachteltes If-Else
Ohne For-Comprehensions müssten Sie Pattern-Matches oder Nullprüfungen verschachteln. Die monadische Form macht aus dieser Pyramide eine übersichtliche lineare Abfolge.
object Main {
def parse(s: String): Option[Int] = s.toIntOption
def main(args: Array[String]): Unit = {
val result = for {
x <- parse("40")
y <- parse("2")
} yield x + y
println(result)
}
}Guards funktionieren auch mit Option
Ein Guard innerhalb einer Option-Comprehension macht aus einem Wert None, wenn die Bedingung nicht erfüllt ist, und dient damit als direkt eingebettete Validierung.
object Main {
def main(args: Array[String]): Unit = {
def validate(age: Int): Option[Int] =
for {
a <- Some(age)
if a >= 18
} yield a
println(validate(25))
println(validate(15))
}
}Future kennenlernen
Ein Future steht für einen Wert, der später verfügbar sein wird. Wie Option verfügt es über map und flatMap, sodass For-Comprehensions asynchrone Schritte sequenzieren können.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._
object Main {
def main(args: Array[String]): Unit = {
val f = for {
a <- Future(10)
b <- Future(20)
} yield a + b
println(Await.result(f, 2.seconds))
}
}Futures werden hier nacheinander ausgeführt
Wenn ein Generator innerhalb einer For-Comprehension von einem anderen abhängt, werden die Futures nacheinander ausgeführt, weil jedes flatMap auf das vorherige Ergebnis wartet.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._
object Main {
def main(args: Array[String]): Unit = {
val f = for {
a <- Future(5)
b <- Future(a * 2)
} yield a + b
println(Await.result(f, 2.seconds))
}
}Futures parallel ausführen
Um Futures parallel auszuführen, starten Sie sie vor der For-Comprehension und kombinieren Sie sie anschließend. Unabhängige Arbeit läuft überlappend, statt aufeinander zu warten.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration._
object Main {
def main(args: Array[String]): Unit = {
val fa = Future(100)
val fb = Future(200)
val combined = for {
a <- fa
b <- fb
} yield a + b
println(Await.result(combined, 2.seconds))
}
}Either für aussagekräftigere Fehler
Either[E, A] enthält im Fehlerfall einen Fehlerwert. In einer For-Comprehension bricht das erste Left die Verarbeitung ab und wird zurückgegeben.
object Main {
def parse(s: String): Either[String, Int] =
s.toIntOption.toRight(s"not a number: $s")
def main(args: Array[String]): Unit = {
val good = for { a <- parse("3"); b <- parse("4") } yield a + b
val bad = for { a <- parse("3"); b <- parse("x") } yield a + b
println(good)
println(bad)
}
}Dieselbe Form für viele Typen
Beachten Sie, dass die Comprehension identisch aussieht, unabhängig davon, ob Sie Option, Either, Try oder Future verwenden. Nur die Fehlersemantik unterscheidet sich. Diese Einheitlichkeit ist die Stärke des monadischen Verkettens.
import scala.util.Try
object Main {
def main(args: Array[String]): Unit = {
val result = for {
a <- Try("21".toInt)
b <- Try("2".toInt)
} yield a * b
println(result)
}
}Das Kombinieren von Typen ist nicht erlaubt
Alle Generatoren in einer Comprehension müssen dieselbe Monade verwenden. Sie können einen Option-Generator nicht direkt mit einem Future-Generator kombinieren. Konvertieren Sie zuerst einen davon, etwa mit Future.fromTry, oder verpacken Sie den Option.
object Main {
def main(args: Array[String]): Unit = {
// Convert the Option to keep types consistent
val maybe: Option[Int] = Some(7)
val result = for {
a <- maybe
b <- maybe.map(_ + 1)
} yield a + b
println(result)
}
}Schnelltest
Was geschieht in einer Option-For-Comprehension, wenn ein Generator None liefert?
Zusammenfassung
Sie haben monadisches Verketten mit For-Comprehensions kennengelernt:
- Funktioniert mit jedem Typ, der
mapundflatMapbesitzt Optionbricht beiNonefrühzeitig abEitherundTrybrechen bei Fehlern frühzeitig ab und führen Fehlerinformationen mitFutureführt asynchrone Schritte nacheinander aus; starten Sie sie frühzeitig, um Parallelität zu erreichen- Alle Generatoren müssen denselben Monaden-Typ verwenden
Häufig gestellte Fragen
Ist die Lektion „Verwendung mit Option und Future“ kostenlos?
Ja — der vollständige Text von „Verwendung mit Option und Future“ 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 „Verwendung mit Option und Future“?
Monadische Verkettung 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 „Verwendung mit Option und Future“?
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
- for desugaren
- Mit if filtern
- Mehrere Generatoren
- Verwendung mit Option und Future