Anonymous functions in Kotlin

In Kotlin, anonymous functions are functions that do not have explicit names and can be defined directly as expressions in another function or expression. They are often used as an alternative way to write lambda expressions and can also be passed as arguments to other functions.

Here is an example of an anonymous function in Kotlin:

fun main() {
// Aufruf der anonymen Funktion
val result = addNumbers(10, 20)
println(result)
}
// Deklaration einer anonymen Funktion
val addNumbers = fun(x: Int, y: Int): Int {
    return x + y
}

This example defines an anonymous function that has two parameters x and y of the type Int accepted and returns their sum. The function is then given the arguments 10 and 20 called and the result is in the variable result saved. Then the variable result on the console using the function println() output.

Another way to define an anonymous function in Kotlin is to use lambda syntax, like the following example:

fun main() {
// Aufruf der anonymen Funktion
    val result = multiplyNumbers(10, 20)
    println(result)
}
// Deklaration einer anonymen Funktion mithilfe der Lambda-Syntax
val multiplyNumbers = { x: Int, y: Int -> x * y }

This example defines an anonymous function that has two parameters x and y of the type Int accepts and returns your product. The function comes with the arguments 10 and 20 called. The result is in the variable result saved and output to the console.

Anonymous functions can also be passed as arguments to other functions to make the code more readable and modular. Here is a simple example:

fun main() {
    // Array mit Zahlen
    val arrayWithNumbers: Array<Int> = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // Deklaration einer ANONYMEN Funktion, die überprüft, ob eine Zahl gerade ist
    val isEven = fun(number: Int): Boolean {
          return number % 2 == 0
    }
    
    // Aufruf der Funktion 'iterateThroughArray' mit dem Array und der anonymen Funktion 'isEven' als Argumente
    iterateThroughArray(arrayWithNumbers, isEven)
}

// Funktion, die einen Array als Argument und eine Funktion mit mathematischer Operation annimmt. 
// Anschließend wird über den Array iteriert und mathematische Operation für jedes Element des Arrays angewendet. 
fun iterateThroughArray(inputArray: Array<Int>, mathOperation: (Int) -> Boolean) {
    for (element in inputArray) {
        val result = mathOperation(element)
        println(result)
    }
}

In Kotlin you can also return an anonymous function from a function. This makes it possible to create higher order functions that create and return other functions. Here is an example of how you can do that:

fun main() {
    val double = createMultiplier(2) // Erstellt eine Funktion, die jeden Wert verdoppelt
    val triple = createMultiplier(3) // Erstellt eine Funktion, die jeden Wert verdreifacht

    println(double(4)) // Ausgabe: 8 (4 * 2)
    println(triple(4)) // Ausgabe: 12 (4 * 3)
}

// Funktion, die eine anonyme Funktion zurückgibt
fun createMultiplier(factor: Int): (Int) -> Int {
    return { number -> number * factor }
}

In this example the function defines createMultiplier an anonymous function that takes one parameter number accepted and this with the handed over factor multiplied. The function createMultiplier returns this anonymous function.

Within the main()-function, we use createMultiplier to create two new functions: double and XNUMXPS. These functions are instances of the anonymous function provided by createMultiplier is returned, with different factors (2 or 3).

This allows us to double and XNUMXPS Use as standalone functions to double or triple numbers. In this example, we double the number 4 with double(4) and triple it with triple(4).

Anonymous functions in Kotlin are useful because they allow functions to be created and used in a simple and compact way without having to explicitly name or declare them.