Scala for Backend Engineering & Functional Programming · Lektion

getOrElse und fold

Werte extrahieren

getOrElse und fold 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.

Einen Wert auslesen

Irgendwann müssen Sie einen einfachen Wert aus einem Option auslesen und etwas Sinnvolles angeben, wenn es None ist.

Scala stellt dafür sichere Auslesemethoden wie getOrElse und fold bereit.

getOrElse verwenden

getOrElse gibt den Wert in einem Some zurück oder einen von Ihnen angegebenen Standardwert, wenn es None ist.

Die Methode liefert immer einen einfachen Wert, niemals ein Option.

object Main {
  def main(args: Array[String]): Unit = {
    val a: Option[Int] = Some(5)
    val b: Option[Int] = None
    println(a.getOrElse(0))
    println(b.getOrElse(0))
  }
}

Der Standardwert ist lazy

Der Standardwert in getOrElse wird nur ausgewertet, wenn das Option None ist. Ein aufwendiger Standardwert verursacht daher keine Kosten, wenn ein Wert vorhanden ist.

object Main {
  def expensiveDefault(): Int = { println("computing default"); 99 }
  def main(args: Array[String]): Unit = {
    val present: Option[Int] = Some(7)
    println(present.getOrElse(expensiveDefault()))
  }
}

get vermeiden

Option besitzt eine get-Methode, die bei None jedoch eine Exception auslöst. Damit wird der Zweck der Verwendung von Option zunichtegemacht.

Verwenden Sie stattdessen bevorzugt getOrElse, fold oder Pattern Matching.

orElse für Fallback-Optionen

orElse funktioniert anders: Es gibt das erste Option zurück, wenn es ein Some ist, andernfalls ein Ersatz-Option.

Verwenden Sie es, um Alternativen auszuprobieren, die selbst leer sein können.

object Main {
  def main(args: Array[String]): Unit = {
    val primary: Option[Int] = None
    val backup: Option[Int] = Some(42)
    println(primary.orElse(backup))
  }
}

fold einführen

fold behandelt beide Fälle in einem Aufruf. Zuerst geben Sie einen Standardwert für None an, danach eine Funktion für den Some-Wert.

Die Methode liefert ein einzelnes Ergebnis und transformiert den Wert, wenn er vorhanden ist.

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

fold bei None

Wenn das Option None ist, gibt fold den zuerst angegebenen Standardwert zurück und ignoriert die Transformationsfunktion.

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

fold in einen anderen Typ

Beide Zweige von fold müssen denselben Typ zurückgeben, aber dieser Typ darf sich vom Werttyp des Options unterscheiden.

Hier wandeln wir ein Option[Int] in einen String um.

object Main {
  def describe(o: Option[Int]): String =
    o.fold("missing")(x => s"value $x")
  def main(args: Array[String]): Unit = {
    println(describe(Some(8)))
    println(describe(None))
  }
}

Zwischen den Möglichkeiten wählen

Kurzübersicht:

getOrElse: einen Standardwert desselben Typs angeben
orElse: ein Ersatz-Option angeben
fold: den Wert transformieren und in einem Schritt einen Standardwert angeben
Pattern Matching: wenn jeder Fall mehr Logik benötigt

Mit map kombinieren

Ein gängiges Idiom ist, zuerst mit map zu transformieren und anschließend mit getOrElse einen einfachen Wert zu erhalten.

object Main {
  def main(args: Array[String]): Unit = {
    val name: Option[String] = Some("ada")
    val display = name.map(_.toUpperCase).getOrElse("ANON")
    println(display)
  }
}

Alles zusammenführen

Einen Konfigurationswert nachschlagen, ein Ersatz-Option bereitstellen und anschließend mit getOrElse auf einen Standardwert zurückfallen.

object Main {
  val env = Map("timeout" -> "30")
  def main(args: Array[String]): Unit = {
    val timeout = env.get("timeout")
      .flatMap(_.toIntOption)
      .getOrElse(60)
    println(timeout)
    val retries = env.get("retries").fold(3)(_.toInt)
    println(retries)
  }
}

Kurze Prüfung

Testen Sie Ihr Verständnis des Auslesens von Option-Werten.

Zusammenfassung

Sie haben gelernt, Option-Werte sicher auszulesen:

getOrElse(default) gibt den Wert oder einen Standardwert zurück (lazy ausgewertet)
orElse(fallback) gibt das erste Some oder ein Ersatz-Option zurück
fold(default)(f) transformiert ein Some und verwendet in einem Schritt einen Standardwert für None
Vermeiden Sie get, da es bei None eine Exception auslöst

Häufig gestellte Fragen

Ist die Lektion „getOrElse und fold“ kostenlos?

Ja — der vollständige Text von „getOrElse und fold“ 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 „getOrElse und fold“?

Werte extrahieren 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 „getOrElse und fold“?

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