Scala for Backend Engineering & Functional Programming · Lektion

Funktionen höherer Ordnung und Currying

Erkunden Sie fortgeschrittene funktionale Konzepte wie Funktionen höherer Ordnung und Currying, um flexiblen und wiederverwendbaren Code zu erstellen.

Funktionen höherer Ordnung und Currying 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.

Höherwertige Funktionen erschließen

Willkommen zu Lektion 2! In der funktionalen Programmierung sind Funktionen besonders leistungsfähig. Sie dienen nicht nur dazu, Werte zu berechnen, sondern können auch wie alle anderen Daten behandelt werden.

Das bedeutet, dass Funktionen als Argumente an andere Funktionen übergeben oder sogar als Ergebnisse von ihnen zurückgegeben werden können. Wenn eine Funktion dies tut, wird sie als höherwertige Funktion (HOF) bezeichnet.

HOFs akzeptieren eine oder mehrere Funktionen als Argumente.
HOFs geben eine Funktion als Ergebnis zurück.
Oder beides!

HOF in Aktion: `map`

Eine der am häufigsten verwendeten HOFs in Scala ist map. Sie transformiert jedes Element einer Collection, indem sie eine bestimmte Funktion darauf anwendet, und gibt eine neue Collection zurück.

Führen Sie dieses einfache Beispiel aus:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    val doubledNumbers = numbers.map(x => x * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubledNumbers")
  }
}

HOF in Aktion: `filter`

Eine weitere nützliche HOF ist filter. Sie wählt aus einer Collection die Elemente aus, die eine bestimmte Bedingung erfüllen (eine Funktion, die einen booleschen Wert zurückgibt), und erstellt daraus eine neue Collection.

So können Sie filter verwenden, um gerade Zahlen zu finden:

object Main {
  def main(args: Array[String]): Unit = {
    val allNumbers = List(1, 2, 3, 4, 5, 6)
    val evenNumbers = allNumbers.filter(x => x % 2 == 0)
    println(s"All: $allNumbers")
    println(s"Even: $evenNumbers")
  }
}

Eigene HOF definieren

Sie sind nicht auf integrierte HOFs beschränkt! Sie können eigene Funktionen definieren, die andere Funktionen als Parameter akzeptieren. Die Syntax für einen Funktionstyp lautet (InputType => ReturnType).

In diesem Beispiel wird eine Funktion applyOperation definiert, die ein Int und eine weitere Funktion op akzeptiert (die ein Int übernimmt und ein Int zurückgibt).

object Main {
  // A HOF that applies an operation to a number
  def applyOperation(x: Int, op: Int => Int): Int = {
    op(x)
  }

  def main(args: Array[String]): Unit = {
    val result = applyOperation(10, _ * 3) // Pass an anonymous function
    println(s"Result of 10 * 3: $result")

    val anotherResult = applyOperation(7, _ + 5)
    println(s"Result of 7 + 5: $anotherResult")
  }
}

Anonyme Funktionen und Kurzschreibweisen

Wenn Sie Funktionen an HOFs übergeben, verwenden Sie häufig anonyme Funktionen (auch Lambdas genannt). Scala bietet dafür kompakte Schreibweisen.

x => x * 2: Vollständige anonyme Funktion.
_ * 2: Kurzschreibweise für eine anonyme Funktion mit einem Parameter.

Beide Schreibweisen sind üblich und machen Ihren Code kürzer und lesbarer.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(10, 20, 30)

    // Using full anonymous function syntax
    val dividedByTwo = numbers.map(x => x / 2)
    println(s"Divided by two: $dividedByTwo")

    // Using shorthand `_` syntax
    val plusOne = numbers.map(_ + 1)
    println(s"Plus one: $plusOne")
  }
}

Currying kennenlernen

Currying ist eine Technik, bei der eine Funktion mit mehreren Argumenten in eine Folge von Funktionen umgewandelt wird, die jeweils ein einzelnes Argument übernehmen.

Benannt ist die Technik nach dem Logiker Haskell Curry. In Scala werden Funktionen mit mehreren Parameterlisten automatisch per Currying umgewandelt.

Statt f(arg1, arg2) schreiben Sie f(arg1)(arg2).

Currying-Beispiel: mehrere Parameterlisten

Sehen wir uns Currying in Aktion an. Beachten Sie, dass add seine Argumente in zwei getrennten Parameterlisten übernimmt.

Dadurch können Sie die Funktion teilweise anwenden und neue Funktionen erstellen, indem Sie einige Argumente festlegen.

object Main {
  // A curried function with two parameter lists
  def add(a: Int)(b: Int): Int = {
    a + b
  }

  def main(args: Array[String]): Unit = {
    // Call the function normally
    println(s"5 + 3 = ${add(5)(3)}")

    // Partially apply the first argument
    val addFive = add(5)_ // `_` tells Scala to treat it as a partially applied function
    println(s"5 + 10 = ${addFive(10)}")
    println(s"5 + 20 = ${addFive(20)}")
  }
}

Vorteile von Currying

Warum sollten Sie Currying verwenden? In der funktionalen Programmierung bietet es mehrere Vorteile:

Partielle Anwendung: Erstellen Sie spezialisierte Varianten einer Funktion, indem Sie einige Argumente festlegen. Das verbessert die Wiederverwendbarkeit des Codes.
Funktionskomposition: Curried Functions lassen sich häufig leichter mit anderen Funktionen kombinieren.
Typinferenz: Currying kann manchmal die Typinferenz von Scala unterstützen, insbesondere bei der Arbeit mit komplexen generischen Typen.

Currying für benutzerdefinierte Logger

Stellen Sie sich vor, Sie möchten für verschiedene Stufen (z. B. INFO und ERROR) unterschiedliche Logging-Funktionen erstellen, aber dieselbe grundlegende Logik verwenden. Dafür ist Currying ideal!

Sie können eine allgemeine Funktion log definieren und sie anschließend teilweise anwenden, um spezifische Logger zu erstellen.

object Main {
  def log(level: String)(message: String): Unit = {
    println(s"[$level] $message")
  }

  def main(args: Array[String]): Unit = {
    // Create specialized loggers using partial application
    val infoLogger = log("INFO")_
    val errorLogger = log("ERROR")_

    infoLogger("User logged in successfully.")
    errorLogger("Failed to connect to database!")
  }
}

Kurztest: HOFs und Currying

Betrachten Sie den folgenden Scala-Codeausschnitt:

def calculate(x: Int)(y: Int, op: (Int, Int) => Int): Int = {
  op(x, y)
}

val add = (a: Int, b: Int) => a + b
val multiply = (a: Int, b: Int) => a * b

val result1 = calculate(10)(5, add)
val result2 = calculate(2)(3, multiply)

Welche Werte haben result1 und result2?

Zusammenfassung: HOFs und Currying

Sehr gut! Sie haben zwei leistungsfähige Konzepte der funktionalen Programmierung kennengelernt:

Höherwertige Funktionen (HOFs): Funktionen, die andere Funktionen als Argumente übernehmen oder als Ergebnisse zurückgeben können. Sie ermöglichen flexiblen und wiederverwendbaren Code, etwa mit map und filter.
Currying: Eine Technik, bei der eine Funktion mit mehreren Argumenten in eine Folge von Funktionen umgewandelt wird, die jeweils ein einzelnes Argument übernehmen. Sie eignet sich hervorragend für partielle Anwendungen und zum Erstellen spezialisierter Funktionen.

Diese Konzepte bilden eine wichtige Grundlage für ausdrucksstarken und modularen Scala-Code!

Häufig gestellte Fragen

Ist die Lektion „Funktionen höherer Ordnung und Currying“ kostenlos?

Ja — der vollständige Text von „Funktionen höherer Ordnung und Currying“ 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 „Funktionen höherer Ordnung und Currying“?

Erkunden Sie fortgeschrittene funktionale Konzepte wie Funktionen höherer Ordnung und Currying, um flexiblen und wiederverwendbaren Code zu erstellen. 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 „Funktionen höherer Ordnung und Currying“?

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