Lambda-Funktionen in Kotlin

In Kotlin gibt es eine Funktion namens Lambda, die auch als anonyme Funktion bezeichnet wird. Eine Lambda-Funktion ist eine kurze und einfache Art, eine Funktion ohne einen expliziten Namen zu definieren.

Eine Lambda-Funktion wird in Klammern geschrieben und hat einen einzigen Ausdruck, der als Rückgabewert verwendet wird. Hier ist ein einfaches Beispiel einer Lambda-Funktion in Kotlin:

{println("Hello Kotlin!")}

Ein Lambda-Ausdruck kann in eine normale Variable gespeichert und dann wie eine gewöhnliche Funktion über den Namen dieser Variable aufgerufen werden.

fun main() {
    val greeting = {println("Hello Kotlin!")}
    greeting()
    greeting()
    greeting()
}

In diesem Beispiel definieren wir eine Lambda-Funktion {println(„Hello Kotlin!“)} und speichern sie in der Variablen greeting. Wir können die Lambda-Funktion dann aufrufen, indem wir den Namen der Variablen greeting und eine leere Argumentliste () verwenden. In diesem Beispiel rufen wir die Funktion dreimal auf und alle drei Male wird ‚Hello Kotlin!‘ ausgegeben. Da ein Lambda-Ausdruck eine verkürzte Form einer Funktion darstellt, hat die Variable greeting den Funktionstyp () -> Unit.

val greeting: ()->Unit = {println("Hello Kotlin!")}

Ein Lambda-Ausdruck kann auch wie eine normale Funktion ausgeführt werden, indem man runde Klammern verwendet.

fun main() {
    {println("Hello Kotlin!")}()
}

Übergabe von Parametern an Lambda

Lambdas können, wie Funktionen auch, Parameter annehmen. Um Parameter an einen Lambda-Ausdruck zu übergeben, wird der Pfeil -> verwendet. Die Parameter werden links vom Pfeil angegeben, und der Körper des Lambda-Ausdrucks, also der auszuführende Code, steht rechts vom Pfeil.

fun main() {
    val outputText = {yourText: String -> println(yourText)}
    outputText("I like Kotlin!")
    outputText("I like hotdogs!")
}

Ein Lambda-Ausdruck kann direkt bei seiner Definition aufgerufen werden, indem man die Parameterwerte in Klammern hinter dem Ausdruck angibt. Dies ist nützlich, wenn man eine Funktion nur einmal ausführen möchte und keine separate Variable zur Speicherung der Funktion benötigt.

fun main() {
    {outputText: String -> println(outputText)} ("Lambdas are great!")
}

Wenn ein Lambda-Ausdruck mehrere Parameter hat, werden sie links vom Pfeil durch Kommas getrennt:

Hier ist ein Beispiel in Kotlin, das einen Lambda-Ausdruck mit mehreren Parametern veranschaulicht:

fun main() {
    val multiParameterLambda = { x: Int, y: Int, z: Int -> println(x + y + z) }

    multiParameterLambda(1, 1, 1)  // 3
    multiParameterLambda(1, 2, 3)  // 6
}

Wenn in einem Lambda-Ausdruck mehrere Anweisungen ausgeführt werden sollen, können diese Anweisungen auf separaten Zeilen nach dem Pfeil angeordnet werden. Nachstehend ist ein Beispiel, das einen Lambda-Ausdruck mit mehreren Aktionen veranschaulicht:

fun main() {
    val sumOfNumbers = { x: Int, y: Int ->
        val result = x + y
        println("$x + $y = $result")
    }

    sumOfNumbers(2,3)  // 2 + 3 = 5
    sumOfNumbers(5,7)  // 5 + 7 = 12
}

Lambda-Ausdrücke als Argumente in Funktionen

Lambda-Ausdrücke können als Argumente für Funktionen verwendet werden, wenn sie denselben Funktionstyp repräsentieren. Hier ist ein eigenes Beispiel in Kotlin, das diese Verwendung von Lambda-Ausdrücken zeigt:

fun main() {
    val multiply = { x: Int, y: Int -> x * y }
    val divide = { x: Int, y: Int -> x / y }

    performOperation(6, 3, multiply)  // 18
    performOperation(6, 3, divide)    // 2
}

fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int) {
    val result = operation(x, y)
    println(result)
}

In diesem Beispiel werden zwei Lambda-Ausdrücke definiert: multiply und divide. Beide Lambda-Ausdrücke nehmen zwei Integer-Parameter entgegen und geben einen Integer-Wert zurück. Die Funktion performOperation hat ebenfalls zwei Integer-Parameter x und y sowie einen weiteren Parameter operation, der eine Funktion repräsentiert, die zwei Integer-Parameter annimmt und einen Integer-Wert zurückgibt.

Innerhalb der performOperation-Funktion wird die übergebene Operation (multiply oder divide) mit den Parametern x und y aufgerufen, und das Ergebnis wird auf der Konsole ausgegeben.

In der main-Funktion wird performOperation zweimal aufgerufen, einmal mit der multiply-Lambda und einmal mit der divide-Lambda.

Typisierung von Lambda-Parametern

Wenn eine Lambda einem Parameter oder einer Variable mit explizit angegebenem Typ zugewiesen wird, können die Typen der Parameter im Lambda-Ausdruck weggelassen werden. Hier ist ein eigenes Beispiel in Kotlin, das die Typinferenz für Lambda-Parameter zeigt:

fun main() {
    val subtract: (Int, Int) -> Int = { x, y -> x - y }
    performOperation(9, 6, { a, b -> a * b })
}

fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int) {
    val result = operation(x, y)
    println(result)
}

In diesem Beispiel wird der Lambda-Ausdruck subtract einer Variable mit dem explizit angegebenen Typ (Int, Int) -> Int zugewiesen. Da Kotlin erkennt, dass sowohl der erste als auch der zweite Parameter vom Typ Int sind, können die Typen der Parameter im Lambda-Ausdruck weggelassen werden: { x, y -> x – y }. Kotlin versteht automatisch, dass die Parameter x und y vom Typ Int sind.

Dasselbe gilt für den Aufruf der Funktion performOperation(). Bei der Übergabe der Lambda an diese Funktion erkennt Kotlin automatisch den Typ der Parameter. Im Beispiel wird die Funktion performOperation mit den Werten 9 und 6 sowie einer Lambda-Ausdruck aufgerufen, der die beiden Parameter multipliziert.

trailing lambda

In Kotlin bezieht sich der Begriff trailing lambda auf eine Syntaxkonvention, bei der ein Lambda-Ausdruck, der als Argument für eine Funktion dient, nach der Parameterliste der Funktion geschrieben wird, anstatt innerhalb der Klammern. Diese Syntax wird verwendet, wenn der Funktionsparameter, der das Lambda akzeptiert, der letzte in der Parameterliste ist.

Die Verwendung einer trailing lambda kann den Code lesbarer und sauberer gestalten, insbesondere wenn der Lambda-Ausdruck mehrere Zeilen oder komplexere Logik enthält. Ein Beispiel für die Verwendung von trailing lambda in Kotlin:

fun main() {
    performOperation(10, 5) { a, b -> a + b } // 15
}

fun performOperation(x: Int, y: Int, operation: (Int, Int) -> Int) {
    val result = operation(x, y)
    println(result)
}

In diesem Beispiel hat die Funktion performOperation einen Parameter operation, der ein Lambda-Ausdruck ist. Da dieser Parameter der letzte in der Parameterliste ist, kann der Lambda-Ausdruck nach der Parameterliste geschrieben werden, anstatt in den Klammern:

performOperation(10, 5) { a, b -> a + b } // 15

Anstatt der traditionellen Schreibweise:

performOperation(10, 5, { a, b -> a + b }) // 15

Lambda-Ausdruck als Rückgabewert aus einer Funktion

Eine Funktion kann auch ein Lambda-Ausdruck als Rückgabewert zurückgeben, der dem Rückgabetyp der Funktion entspricht. Hier ist ein Beispiel in Kotlin, das zeigt, wie eine Funktion ein Lambda-Ausdruck zurückgeben kann:

fun main() {
    val adder = createAdder(5)
    val result = adder(3)
    println(result) // 8
}

fun createAdder(x: Int): (Int) -> Int {
    return { y -> x + y }
}

In diesem Beispiel haben wir eine Funktion createAdder, die einen Integer-Parameter x akzeptiert und ein Lambda-Ausdruck zurückgibt, der wiederum einen Integer-Parameter akzeptiert und einen Integer-Wert zurückgibt. Der Rückgabetyp der Funktion ist (Int) -> Int.

Innerhalb der Funktion createAdder wird ein Lambda-Ausdruck zurückgegeben, der den Wert x mit einem anderen Integer-Wert y addiert. Da das Lambda den erwarteten Rückgabetyp der Funktion entspricht, kann es als Rückgabewert verwendet werden.

In der main-Funktion rufen wir createAdder mit dem Wert 5 auf und weisen das zurückgegebene Lambda der Variablen adder zu. Dann rufen wir adder mit dem Wert 3 auf und geben das Ergebnis 8 auf der Konsole aus.

Unbenutzte Parameter

In manchen Fällen kann ein Lambda-Ausdruck Parameter enthalten, die nicht im Körper des Lambda-Ausdrucks verwendet werden. In solchen Situationen können in Kotlin die unbenutzten Parameter durch Unterstriche _ ersetzt werden, um den Code sauberer und leichter verständlich zu gestalten. Dieses Beispiel zeigt, wie unbenutzte Parameter in Lambda-Ausdrücken in Kotlin durch Unterstriche ersetzt werden können, um den Code sauberer und leichter verständlich zu gestalten.

fun main() {
    val action = selectAction(4)
    val result = action(5, 3)
    println(result) // 0
}

fun selectAction(number: Int): (Int, Int) -> Int {
    return when (number) {
        1 -> { x, y -> x + y }
        2 -> { x, y -> x * y }
        else -> { _, _ -> 0 }
    }
}

In diesem Beispiel haben wir eine Funktion selectAction, die einen Integer-Parameter number akzeptiert und ein Lambda-Ausdruck zurückgibt, der zwei Integer-Parameter akzeptiert und einen Integer-Wert zurückgibt. Der Rückgabetyp der Funktion ist (Int, Int) -> Int.

Innerhalb der Funktion selectAction verwenden wir eine when-Anweisung, um unterschiedliche Lambda-Ausdrücke basierend auf dem Wert von number zurückzugeben. Wenn number weder 1 noch 2 ist, wird ein Lambda-Ausdruck zurückgegeben, der einfach den Wert 0 zurückgibt. Da die Parameter in diesem Lambda-Ausdruck nicht verwendet werden, können sie durch Unterstriche ersetzt werden:

else -> { _, _ -> 0 }

In der main-Funktion rufen wir selectAction mit dem Wert 4 auf und weisen das zurückgegebene Lambda der Variablen action zu. Dann rufen wir action mit den Werten 5 und 3 auf und geben das Ergebnis 0 auf der Konsole aus.

Welche Vorteile bieten Lambda-Ausdrücke?

Lambda-Ausdrücke bieten folgende Vorteile:

Kürzere und klarere Syntax: Lambdas ermöglichen eine kompakte und ausdrucksstarke Schreibweise für Funktionen, insbesondere für kurze und einfache Funktionen. Sie erlauben es, Funktionen als Ausdrücke zu definieren, was den Code kürzer und einfacher zu lesen macht.
Anonyme Funktionen: Lambda-Ausdrücke sind anonyme Funktionen, das heißt, sie haben keinen Namen. Dies ist nützlich, wenn eine Funktion nur an einer bestimmten Stelle im Code benötigt wird und nicht wiederverwendet wird. Anstatt eine separate, benannte Funktion zu erstellen, kann ein Lambda-Ausdruck direkt an der benötigten Stelle definiert und verwendet werden.
Funktionale Programmierung: Lambda-Ausdrücke unterstützen funktionale Programmierkonzepte wie höhere Ordnungsfunktionen und das Arbeiten mit Sammlungen. Sie ermöglichen es, Funktionen als Parameter an andere Funktionen zu übergeben oder Funktionen als Rückgabewerte zu verwenden. In funktionalen Programmiersprachen oder bei der Verwendung funktionaler Programmierparadigmen sind Lambda-Ausdrücke ein grundlegendes Werkzeug.
Einfachere Manipulation von Datenstrukturen: Lambda-Ausdrücke werden oft in Verbindung mit Sammlungen und Datenstrukturen verwendet, um Operationen wie Filtern, Transformieren oder Aggregieren von Daten zu vereinfachen. Mit Lambdas können solche Operationen auf einfache und intuitive Weise ausgedrückt werden. Hier ist ein einfaches Code-Beispiel für Collection List:

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)

    // Filtern von geraden Zahlen
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println(evenNumbers) // [2, 4, 6]
}