Scala for Backend Engineering & Functional Programming · Lektion

Asynchrone Operationen kombinieren

Lernen Sie, mehrere `Futures` mithilfe von Methoden wie `map`, `flatMap` und `for`-Comprehensions zu verketten und zu kombinieren.

Asynchrone Operationen kombinieren ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Warum asynchrone Operationen verketten?

Mit Futures können wir Aufgaben ausführen, ohne das Hauptprogramm zu blockieren. Was aber, wenn das Ergebnis einer Aufgabe für eine andere benötigt wird oder wir Ergebnisse mehrerer Aufgaben kombinieren müssen?

Hier kommt das Kombinieren von Futures ins Spiel. Sie lernen, wie Sie diese asynchronen Operationen verketten und kombinieren, damit Ihr Scala-Code leistungsfähiger und reaktionsschneller wird.

`map`: Ergebnis eines Future transformieren

Die Methode map verwenden Sie, wenn Sie ein Future haben und dessen erfolgreiches Ergebnis in einen anderen Wert umwandeln möchten. Die von Ihnen angegebene Transformationsfunktion wird angewendet, sobald das Future erfolgreich abgeschlossen wurde.

Sie gibt immer ein neues Future zurück.
Sie eignet sich ideal für einfache, synchrone Transformationen eines asynchronen Ergebnisses.

`map` in Aktion (Code)

Hier erhalten wir eine Zahl aus einem Future und verdoppeln sie anschließend mit map. Die Transformation findet erst statt, nachdem das ursprüngliche Future abgeschlossen ist.

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val originalFuture: Future[Int] = Future {
      Thread.sleep(100) // Simulate work
      10
    }

    val doubledFuture: Future[Int] = originalFuture.map(value => value * 2)

    val result = Await.result(doubledFuture, 1.second)
    println(s"Doubled value: $result")
  }
}

`flatMap`: Futures verketten

Manchmal soll das erfolgreiche Ergebnis eines Future ein weiteres Future starten. Hier spielt flatMap seine Stärke aus. Es „flacht“ ein Future eines Future (Future[Future[T]]) zu einem einzelnen Future[T] ab.

Verwenden Sie es, wenn Ihre Transformationsfunktion ein Future zurückgibt.
Es ist unverzichtbar für sequenzielle asynchrone Operationen.

`flatMap` in Aktion (Code)

Wir rufen eine Benutzer-ID ab und verwenden diese ID anschließend, um Benutzerdetails abzurufen. Jeder Schritt ist eine asynchrone Operation, die ein Future zurückgibt. flatMap stellt sicher, dass die Schritte nacheinander ausgeführt werden.

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    def fetchUserId(): Future[Int] = Future {
      Thread.sleep(50)
      123
    }

    def fetchUserDetails(userId: Int): Future[String] = Future {
      Thread.sleep(100)
      s"User $userId details"
    }

    val userDetailsFuture: Future[String] = fetchUserId().flatMap { userId =>
      fetchUserDetails(userId)
    }

    val result = Await.result(userDetailsFuture, 1.second)
    println(s"Details: $result")
  }
}

`map` vs. `flatMap`: Der entscheidende Unterschied

Es kommt häufig vor, dass map und flatMap verwechselt werden. Denken Sie daran:

map: Ihre Funktion gibt einen normalen Wert zurück (z. B. Int, String). Future[A].map(A => B) ergibt Future[B].
flatMap: Ihre Funktion gibt ein weiteres Future zurück (z. B. Future[Int], Future[String]). Future[A].flatMap(A => Future[B]) ergibt Future[B].

flatMap dient zum Verketten asynchroner Operationen, während map ein asynchrones Ergebnis synchron transformiert.

`for`-Ausdrücke: Elegantes Verketten

Die for-Ausdrücke von Scala bieten eine übersichtliche und gut lesbare Syntax zum Verketten von Operationen, die map und flatMap verwenden. Sie sind lediglich syntaktischer Zucker, das heißt, der Compiler übersetzt sie in eine Reihe von Aufrufen von map, flatMap und filter.

Wenn Sie mehrere voneinander abhängige Future-Operationen haben, lassen for-Ausdrücke den Code fast synchron aussehen.

Code mit einem `for`-Ausdruck

Dieses Beispiel verwendet einen for-Ausdruck, um dieselbe Logik zum Abrufen der Benutzer-ID und der Benutzerdetails zu verketten, die wir zuvor mit flatMap gesehen haben. Beachten Sie, wie viel übersichtlicher der Code aussieht!

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    def fetchUserId(): Future[Int] = Future {
      Thread.sleep(50)
      123
    }

    def fetchUserName(userId: Int): Future[String] = Future {
      Thread.sleep(100)
      s"Alice (ID: $userId)"
    }

    val userFuture: Future[String] = for {
      id <- fetchUserId()
      name <- fetchUserName(id)
    } yield name

    val result = Await.result(userFuture, 1.second)
    println(s"User name: $result")
  }
}

`zip`: Unabhängige Ergebnisse kombinieren

Was ist, wenn Sie zwei unabhängige Futures haben und ihre Ergebnisse kombinieren möchten, sobald beide abgeschlossen sind? Dafür eignet sich die Methode zip ideal. Sie nimmt ein weiteres Future entgegen und gibt ein neues Future zurück, das ein Paar (ein Tuple) ihrer erfolgreichen Ergebnisse enthält.

Beide Futures werden gleichzeitig ausgeführt, und zip wartet, bis beide abgeschlossen sind.

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val futureA = Future {
      Thread.sleep(100)
      "Hello"
    }

    val futureB = Future {
      Thread.sleep(50)
      "World"
    }

    val combinedFuture: Future[(String, String)] = futureA.zip(futureB)

    val (greeting, subject) = Await.result(combinedFuture, 1.second)
    println(s"$greeting $subject!")
  }
}

Kurzer Test: Futures kombinieren

Betrachten Sie das folgende Scala-Codefragment. Welcher endgültige Wert wird ausgegeben?

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]): Unit = {
    val f1 = Future { 5 }
    val f2 = f1.map(x => x + 2)
    val f3 = f2.flatMap(y => Future { y * 3 })

    val result = Await.result(f3, 1.second)
    println(result)
  }
}

Zusammenfassung: Asynchrone Aufgaben verketten

Sie haben leistungsfähige Möglichkeiten kennengelernt, Scala-Futures zu kombinieren:

map: Transformiert das erfolgreiche Ergebnis eines Future in einen neuen Wert.
flatMap: Verkettet zwei Futures, wobei das Ergebnis des ersten zum Starten des zweiten verwendet wird.
for-Ausdrücke: Bieten eine übersichtliche, synchron wirkende Syntax für flatMap- und map-Verkettungen.
zip: Kombiniert die Ergebnisse zweier unabhängiger Futures zu einem Tupel.

Diese Werkzeuge sind entscheidend für den Aufbau reaktionsschneller und effizienter asynchroner Anwendungen in Scala!

Häufig gestellte Fragen

Ist die Lektion „Asynchrone Operationen kombinieren“ kostenlos?

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

Was lerne ich in „Asynchrone Operationen kombinieren“?

Lernen Sie, mehrere `Futures` mithilfe von Methoden wie `map`, `flatMap` und `for`-Comprehensions zu verketten und zu kombinieren. 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 2 von 3.

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

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