0Pricing
Scala for Backend Engineering & Functional Programming · Lektion

Funktionen als Werte

Funktionen erster Klasse

Funktionen als Werte ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 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 sind Werte

In Scala sind Funktionen erstklassige Werte. Sie können sie in Variablen speichern, als Argumente übergeben und von anderen Funktionen zurückgeben lassen – genau wie Zahlen oder Strings.

object Main {
  def main(args: Array[String]): Unit = {
    val increment: Int => Int = x => x + 1
    println(increment(5))
  }
}

Syntax von Funktionstypen

Der Typ Int => String bezeichnet eine Funktion, die ein Int übernimmt und einen String zurückgibt. Für mehrere Parameter werden Klammern verwendet: (Int, Int) => Int.

object Main {
  def main(args: Array[String]): Unit = {
    val add: (Int, Int) => Int = (a, b) => a + b
    val label: Int => String = n => s"value=$n"
    println(add(3, 4))
    println(label(7))
  }
}

Syntax von Lambdas (anonymen Funktionen)

Eine anonyme Funktion oder ein Lambda wird als (params) => body geschrieben. Sie hat keinen Namen und wird häufig direkt an eine andere Funktion übergeben.

object Main {
  def main(args: Array[String]): Unit = {
    val square = (x: Int) => x * x
    println(square(6))
  }
}

Funktionen höherer Ordnung

Eine Funktion höherer Ordnung übernimmt eine Funktion als Parameter oder gibt eine Funktion zurück. map und filter sind klassische Beispiele.

object Main {
  def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
  def main(args: Array[String]): Unit = {
    println(applyTwice(_ + 3, 10))
  }
}

Funktionen an Methoden übergeben

Collection-Methoden akzeptieren Funktionen. Sie können ein Lambda direkt oder einen benannten Funktionswert übergeben.

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

Funktionen zurückgeben

Eine Funktion kann eine andere Funktion zurückgeben. Hier gibt multiplier eine Funktion zurück, die mit einem festen Faktor multipliziert – eine kleine Funktionsfabrik.

object Main {
  def multiplier(factor: Int): Int => Int = x => x * factor
  def main(args: Array[String]): Unit = {
    val timesTen = multiplier(10)
    println(timesTen(5))
  }
}

Methoden und Funktionen

Mit def wird eine Methode definiert. Sie können eine Methode mit dem Eta-Expansion-Unterstrich in einen Funktionswert umwandeln: methodName _, oder sie einfach dort verwenden, wo eine Funktion erwartet wird.

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

Funktionen ohne Parameter

Eine Funktion kann ohne Argumente auskommen. Ihr Typ wird als () => T geschrieben. Das ist nützlich, um die Berechnung aufzuschieben.

object Main {
  def main(args: Array[String]): Unit = {
    val greeting: () => String = () => "Hello!"
    println(greeting())
  }
}

Funktionen in Collections speichern

Da Funktionen Werte sind, können Sie sie in Listen oder Maps speichern und dynamisch nachschlagen, um so einen kleinen Befehlsverteiler aufzubauen.

object Main {
  def main(args: Array[String]): Unit = {
    val ops: Map[String, (Int, Int) => Int] = Map(
      "add" -> (_ + _),
      "mul" -> (_ * _)
    )
    println(ops("add")(3, 4))
    println(ops("mul")(3, 4))
  }
}

Funktionen als Konfiguration

Durch die Übergabe einer Funktion können Aufrufer das Verhalten anpassen. Hier wendet transformAll eine beliebige Funktion auf eine Liste an.

object Main {
  def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
  def main(args: Array[String]): Unit = {
    println(transformAll(List(1, 2, 3), _ + 100))
    println(transformAll(List(1, 2, 3), _ * 10))
  }
}

Ein saubereres Beispiel für Anpassung

Hier ist dieselbe Idee sauber umgesetzt: Aufrufer stellen die Transformation bereit, wodurch der Helfer allgemein und wiederverwendbar bleibt.

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

Kurze Überprüfung

Was ist eine Funktion höherer Ordnung?

Zusammenfassung

Sie haben gelernt, dass Funktionen erstklassige Werte sind:

  • Funktionen in vals, Listen und Maps speichern
  • Funktionstypen wie Int => String
  • Lambdas: (x) => body und die Kurzschreibweise _
  • Funktionen höherer Ordnung übernehmen Funktionen oder geben sie zurück
  • Methoden werden durch Eta-Expansion zu Funktionswerten

Häufig gestellte Fragen

Ist die Lektion „Funktionen als Werte“ kostenlos?

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

Funktionen erster Klasse 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 1 von 4.

Wie lange dauert die Lektion „Funktionen als Werte“?

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

  1. Funktionen als Werte
  2. Currying
  3. Komposition
  4. Closures
← Zurück zu Scala for Backend Engineering & Functional Programming