Scala for Backend Engineering & Functional Programming · Lektion

Komposition

andThen und compose

Komposition 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.

Funktionen kombinieren

Bei der Komposition von Funktionen wird eine neue Funktion erstellt, indem zwei vorhandene verbunden werden, sodass die Ausgabe der einen zur Eingabe der nächsten wird. Scala stellt dafür andThen und compose bereit.

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val double = (x: Int) => x * 2
    val both = addOne andThen double
    println(both(5))
  }
}

andThen: von links nach rechts

f andThen g führt zuerst f, dann g aus. Das Lesen von links nach rechts entspricht der Ausführungsreihenfolge und ist für viele intuitiv.

(f andThen g)(x) == g(f(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne andThen triple
    println(pipeline(4))  // (4 + 1) * 3
  }
}

compose: von rechts nach links

f compose g führt zuerst g, dann f aus – in der mathematischen Reihenfolge f(g(x)).

(f compose g)(x) == f(g(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne compose triple
    println(pipeline(4))  // (4 * 3) + 1
  }
}

andThen und compose

Die beiden Methoden sind Spiegelbilder:

f andThen g = g compose f
f compose g = g andThen f

Wählen Sie die Variante, die in Ihrem Fall natürlicher lesbar ist.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x + 10
    val g = (x: Int) => x * 2
    println((f andThen g)(3))
    println((g compose f)(3))
  }
}

Mehrere Funktionen verketten

Sie können viele Funktionen durch wiederholtes andThen verketten und so eine längere Pipeline aufbauen, die von oben nach unten verläuft.

object Main {
  def main(args: Array[String]): Unit = {
    val clean = (s: String) => s.trim
    val lower = (s: String) => s.toLowerCase
    val bang  = (s: String) => s + "!"
    val process = clean andThen lower andThen bang
    println(process("  HELLO  "))
  }
}

Komposition verändert Typen

Die komponierten Funktionen müssen kompatible Typen haben: Der Ausgabetyp der ersten Funktion muss zum Eingabetyp der zweiten passen. Die Pipeline kann ihre Typen unterwegs verändern.

object Main {
  def main(args: Array[String]): Unit = {
    val length = (s: String) => s.length
    val isLong = (n: Int) => n > 5
    val check = length andThen isLong
    println(check("scala"))
    println(check("functional"))
  }
}

Die Identitätsfunktion

identity gibt seine Eingabe unverändert zurück. Es ist das neutrale Element der Komposition: f andThen identity == f. Nützlich als Standardwert in Faltungen und Bedingungen.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x * 2
    val same = f andThen identity[Int]
    println(same(7))
  }
}

Komposition mit reduce

Da Funktionen Werte sind, können Sie mehrere Funktionen in einer Liste speichern und sie mit reduce und andThen zu einer Komposition verbinden.

object Main {
  def main(args: Array[String]): Unit = {
    val steps: List[Int => Int] = List(_ + 1, _ * 2, _ - 3)
    val pipeline = steps.reduce(_ andThen _)
    println(pipeline(5))  // ((5+1)*2)-3
  }
}

Wiederverwendbare Pipelines erstellen

Komposition fördert kleine Funktionen mit jeweils einer einzigen Aufgabe, die Sie zu einem umfassenderen Verhalten zusammensetzen – ein zentraler Gedanke der funktionalen Programmierung.

object Main {
  def main(args: Array[String]): Unit = {
    val sanitize = (s: String) => s.trim.toLowerCase
    val capitalize = (s: String) => s.capitalize
    val format = sanitize andThen capitalize
    println(format("  aLiCe "))
  }
}

Komposition mit map

Eine zusammengesetzte Funktion ist einfach eine Funktion. Sie können sie daher direkt an map übergeben, um die gesamte Pipeline auf eine Collection anzuwenden.

object Main {
  def main(args: Array[String]): Unit = {
    val transform = ((x: Int) => x + 1) andThen ((x: Int) => x * x)
    println(List(1, 2, 3).map(transform))
  }
}

Die Reihenfolge der Komposition genau lesen

Ein häufiger Fehler besteht darin, andThen und compose zu verwechseln. Denken Sie immer daran: andThen = zuerst diese, dann jene Funktion; compose = die umgekehrte Reihenfolge.

object Main {
  def main(args: Array[String]): Unit = {
    val inc = (x: Int) => x + 1
    val sqr = (x: Int) => x * x
    println((inc andThen sqr)(2))  // (2+1)^2 = 9
    println((inc compose sqr)(2))  // (2^2)+1 = 5
  }
}

Kurzer Test

Was berechnet (f andThen g)(x) für gegebene Funktionen f und g?

Zusammenfassung

Sie haben die Funktionskomposition kennengelernt:

f andThen g → g(f(x)) (von links nach rechts)
f compose g → f(g(x)) (von rechts nach links)
Sie sind spiegelbildlich zueinander
identity ist das neutrale Element
Listen von Funktionen mit reduce(_ andThen _) komponieren

Häufig gestellte Fragen

Ist die Lektion „Komposition“ kostenlos?

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

andThen und compose 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 „Komposition“?

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