Scala for Backend Engineering & Functional Programming · Lektion

Falten und Reduzieren

foldLeft und reduce

Falten und Reduzieren 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.

Elemente zu einem Wert zusammenfassen

Manchmal müssen Sie alle Elemente einer Collection zu einem einzigen Wert zusammenfassen, etwa zu einer Summe oder einer Verkettung. Scala stellt dafür fold, foldLeft, foldRight und reduce bereit.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    println(nums.sum)
    println(nums.product)
  }
}

reduce: Zusammenfassen ohne Startwert

reduce fasst Elemente paarweise mithilfe einer binären Funktion zusammen. Es benötigt mindestens ein Element, andernfalls wird eine Exception ausgelöst.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val total = nums.reduce((a, b) => a + b)
    println(total)
    val max = nums.reduce((a, b) => if (a > b) a else b)
    println(max)
  }
}

foldLeft: Zusammenfassen mit Startwert

foldLeft übernimmt einen initialen Startwert und eine Funktion. Bei leeren Collections ist es sicher (es gibt den Startwert zurück), und der Ergebnistyp darf sich vom Elementtyp unterscheiden.

Syntax: xs.foldLeft(seed)((acc, x) => ...).

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val sum = nums.foldLeft(0)((acc, x) => acc + x)
    println(sum)
    val empty = List.empty[Int].foldLeft(0)(_ + _)
    println(empty)
  }
}

Das Akkumulator-Muster

Bei einem Fold ist das erste Argument der Akkumulator, der das laufende Ergebnis enthält, und das zweite das aktuelle Element. In jedem Schritt wird der Akkumulator aktualisiert.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("Scala", "is", "great")
    val sentence = words.foldLeft("")((acc, w) => acc + w + " ")
    println(sentence.trim)
  }
}

Der Ergebnistyp darf sich unterscheiden

Eine leistungsfähige Eigenschaft von foldLeft: Der Akkumulatortyp darf sich vom Elementtyp unterscheiden. Hier falten wir eine Liste von Zahlen zu einem String.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3)
    val joined = nums.foldLeft("nums:")((acc, n) => acc + " " + n)
    println(joined)
  }
}

foldRight: von rechts

foldRight verarbeitet Elemente von rechts nach links. Der Akkumulator ist das zweite Argument: (x, acc) => .... Bei nicht kommutativen Operationen ist die Richtung wichtig.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val left = nums.foldLeft("")((acc, x) => acc + x)
    val right = nums.foldRight("")((x, acc) => acc + x)
    println("foldLeft:  " + left)
    println("foldRight: " + right)
  }
}

Links oder rechts und Performance

foldLeft ist endrekursiv und bei großen Listen stapelsicher. foldRight kann bei sehr großen Eingaben auf einer List einen Stack Overflow verursachen. Bevorzugen Sie foldLeft, sofern die Reihenfolge nichts anderes erzwingt.

object Main {
  def main(args: Array[String]): Unit = {
    val big = (1 to 100000).toList
    val total = big.foldLeft(0L)((acc, x) => acc + x)
    println(total)
  }
}

Eine Collection mit fold aufbauen

Folds sind allgemein genug, um Collections zu erzeugen. Hier kehren wir eine Liste um, indem wir jedes Element an den Anfang einer Akkumulatorliste setzen.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val reversed = nums.foldLeft(List.empty[Int])((acc, x) => x :: acc)
    println(reversed)
  }
}

reduceOption für mehr Sicherheit

Da reduce bei leeren Collections fehlschlägt, gibt reduceOption stattdessen ein Option zurück: Some(result) bei einer nicht leeren und None bei einer leeren Collection.

object Main {
  def main(args: Array[String]): Unit = {
    println(List(3, 1, 4).reduceOption(_ + _))
    println(List.empty[Int].reduceOption(_ + _))
  }
}

fold: eine symmetrische Variante

fold ähnelt foldLeft, aber der Akkumulator muss denselben Typ wie die Elemente haben. Es wird häufig mit parallelen Collections verwendet.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4)
    val total = nums.fold(0)(_ + _)
    println(total)
  }
}

Mit foldLeft zählen

Folds können auch komplexere Ergebnisse berechnen, etwa in einem einzigen Durchlauf zählen, wie viele Elemente eine Bedingung erfüllen.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(4, 7, 2, 9, 6, 1)
    val evenCount = nums.foldLeft(0)((acc, x) => if (x % 2 == 0) acc + 1 else acc)
    println(s"even numbers: $evenCount")
  }
}

Kurze Überprüfung

Was ist der wesentliche Unterschied zwischen reduce und foldLeft?

Zusammenfassung

Sie haben Falten und Reduzieren kennengelernt:

reduce — paarweises Zusammenfassen, kein Startwert, schlägt bei einer leeren Collection fehl
reduceOption — sichere Variante, die ein Option zurückgibt
foldLeft — Startwert und Akkumulator, stapelsicher, flexibler Ergebnistyp
foldRight — von rechts nach links, bei großen Listen auf den Stack achten
Mit Folds lassen sich sogar neue Collections aufbauen

Häufig gestellte Fragen

Ist die Lektion „Falten und Reduzieren“ kostenlos?

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

foldLeft und reduce 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 „Falten und Reduzieren“?

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