Local functions in Kotlin

In Kotlin there is local functions, which can be defined within a larger function. These functions are only visible within this larger function and cannot be accessed from outside.

Local functions have the advantage of making code more readable and clear by packaging complex subtasks within a larger function. This can also help avoid code duplication and improve code maintainability.

A local function is defined as follows:

// Syntax einer lokalen Funktion
fun bigFunction() {
    fun localFunction() {   // Lokale Funktion, die bestimmte Teilaufgabe übernimmt
        // Code to run
    }
}

Below is an example of a function that checks the validity of user input:

fun main() {
    validateUserInput("Kotlin")  // Benutzereingabe 'Kotlin' ist gültig.
    validateUserInput("ab")      // Ungültige Benutzereingabe 'ab', da weniger als 3 Zeichen beinhaltet.

}

fun validateUserInput(input: String) {
    fun isValid(input: String): Boolean {                  // Beginn lokaler Funktion, die angegebene Daten überprüft.
        return input.isNotEmpty() && input.length >= 3     // Rückgabe 'true', wenn das Argument 'input' nicht leer ist UND das Argument 'input' mindestens 3 Zeichen lang ist.
    }

    if (isValid(input)) {
        println("User input \'$input\' is valid")
    } else {
        println("Invalid user input \'$input\'")
    }
}

In this example the local function isValid within the function validateUserInput Are defined. The local function checks whether the passed string is valid, that is, whether it is not empty and is at least 3 characters long. The validateUserInputfunction then uses the local function to check the validity of the user input and output an appropriate message.

A try the local function isValid outside the function validateUserInput Calling it results in an error:

fun main() {
   isValid("Kotlin")  // Aufruf der Funktion 'isValid' außerhalb außerhalb der Funktion 'validateUserInput'
}

fun validateUserInput(input: String) {
    fun isValid(input: String): Boolean {         
        return input.isNotEmpty() && input.length >= 3 
    }

    if (isValid(input)) {
        println("User input \'$input\' is valid")
    } else {
        println("Invalid user input \'$input\'")
    }
}

For what purpose are local functions used?

Local functions in Kotlin serve multiple purposes and can improve code quality in various aspects:

• Logic encapsulation: Local functions help encapsulate the logic within a specific function by performing well-defined and specialized tasks within the surrounding function. 
• readability: Local functions improve code readability by creating clearly defined, named blocks that serve a specific purpose.
• Reusability: Local functions can be reused within the surrounding function without having to write redundant code. This can help reduce sources of errors and make code more consistent and maintainable.
• Accessing the context of the surrounding function: A local function has access to the parameters and variables of the surrounding function. This allows interaction between the local function and its context without having to pass additional parameters to the local function.