Scala for Backend Engineering & Functional Programming · Lektion

map und flatMap auf Option

Sicher kombinieren

map und flatMap auf Option ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Ein Option transformieren

Oft haben Sie ein Option und möchten den Wert nur dann transformieren, wenn er vorhanden ist, während None unverändert bleibt.

Die Methode map erledigt genau das, ohne dass Sie den Wert manuell auspacken müssen.

map verwenden

map wendet eine Funktion auf den Wert in einem Some an und gibt ein neues Some zurück. Bei None tut es nichts und gibt None zurück.

object Main {
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(10)
    val doubled = n.map(x => x * 2)
    println(doubled)
  }
}

map auf None

Wenn das Option None ist, überspringt map die Funktion vollständig und bleibt None.

Das ist die entscheidende Sicherheitseigenschaft: Transformationen sind bei fehlenden Werten wirkungslos.

object Main {
  def main(args: Array[String]): Unit = {
    val empty: Option[Int] = None
    val result = empty.map(x => x * 2)
    println(result)
  }
}

Den Typ ändern

map kann wie bei Collections in einen anderen Typ transformieren. Hier wird ein Option[Int] zu einem Option[String].

object Main {
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(7)
    val label = n.map(x => s"value=$x")
    println(label)
  }
}

Das Verschachtelungsproblem

Was passiert, wenn Ihre Funktion selbst ein Option zurückgibt? Mit map erhalten Sie ein verschachteltes Option[Option[A]], was umständlich ist.

Hier kommt flatMap ins Spiel.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(8)
    val nested = n.map(half)
    println(nested)
  }
}

flatMap verwenden

flatMap wendet eine Funktion an, die ein Option zurückgibt, und flacht das Ergebnis zu einem einzelnen Option ab.

Vergleichen Sie diese Ausgabe mit der verschachtelten Version aus der vorherigen Szene.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val n: Option[Int] = Some(8)
    val flat = n.flatMap(half)
    println(flat)
  }
}

flatMap verketten

Da jeder Schritt ein Option zurückgibt, können Sie mehrere Aufrufe von flatMap verketten. Wenn ein Schritt None liefert, wird die gesamte Kette zu None.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val result = Some(16).flatMap(half).flatMap(half)
    println(result)
  }
}

Bei None vorzeitig abbrechen

Wenn ein mittlerer Schritt None zurückgibt, werden spätere Schritte übersprungen und das Endergebnis ist None.

Dieser automatische Abbruch macht manuelle Nullprüfungen überflüssig.

object Main {
  def half(x: Int): Option[Int] = if (x % 2 == 0) Some(x / 2) else None
  def main(args: Array[String]): Unit = {
    val result = Some(8).flatMap(half).flatMap(half)
    println(result)
  }
}

map und flatMap kombinieren

Verwenden Sie flatMap für Schritte, die ein Option zurückgeben, und map für die abschließende einfache Transformation.

object Main {
  def parse(s: String): Option[Int] = s.toIntOption
  def main(args: Array[String]): Unit = {
    val result = Some("21").flatMap(parse).map(_ * 2)
    println(result)
  }
}

Warum map und flatMap?

Mit diesen Methoden können Sie:

Werte transformieren, ohne sie auszupacken
Arbeit bei None automatisch überspringen
Operationen verketten, die fehlschlagen können
Verschachtelte Option[Option[A]] mit flatten vermeiden

Alles zusammenführen

Eine realistische Kette: Einen Schlüssel nachschlagen, ihn parsen und anschließend sicher transformieren.

object Main {
  val config = Map("port" -> "8080")
  def main(args: Array[String]): Unit = {
    val port = config.get("port").flatMap(_.toIntOption).map(_ + 1)
    println(port)
    val missing = config.get("host").flatMap(_.toIntOption)
    println(missing)
  }
}

Kurze Prüfung

Testen Sie Ihr Verständnis von map und flatMap.

Zusammenfassung

Sie haben gelernt, Options zu kombinieren:

map transformiert den Wert innerhalb von Some und lässt None unverändert
flatMap wendet eine Funktion an, die ein Option zurückgibt, und flacht das Ergebnis ab
Eine Verkettung bricht bei None in einem beliebigen Schritt mit None ab
Verwenden Sie flatMap für Schritte, die ein Option zurückgeben, und map für einfache Schritte

Häufig gestellte Fragen

Ist die Lektion „map und flatMap auf Option“ kostenlos?

Ja — der vollständige Text von „map und flatMap auf Option“ 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 „map und flatMap auf Option“?

Sicher 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 4.

Wie lange dauert die Lektion „map und flatMap auf Option“?

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