What is Local Function in Kotlin: Simple Explanation and Example

A local function in Kotlin is a function defined inside another function. It helps organize code by keeping helper functions close to where they are used, improving readability and encapsulation.

How It Works

Think of a local function like a small tool you keep inside a bigger toolbox (the outer function). You only use this tool while working inside that toolbox, and it is not visible outside. This means the local function can access variables from the outer function directly, just like you can grab a screw from the toolbox while fixing something.

Local functions help keep your code tidy by grouping related tasks together. Instead of creating many small functions scattered around your program, you keep helper functions inside the main function where they belong. This makes your code easier to understand and maintain.

Example

This example shows a local function greet inside the sayHello function. The local function uses a variable from the outer function and prints a greeting message.

kotlin

fun sayHello(name: String) {
    fun greet() {
        println("Hello, $name!")
    }
    greet()
}

fun main() {
    sayHello("Alice")
}

Output

Hello, Alice!

When to Use

Use local functions when you have a small task that only makes sense inside another function. For example, if you need to repeat a calculation or a check several times inside one function, a local function can keep that code neat and avoid repetition.

They are great for improving code clarity and hiding helper logic that should not be accessible from outside. This is useful in real-world cases like processing user input, formatting data, or breaking down complex operations into smaller steps.

Key Points

• Local functions are defined inside other functions.
• They can access variables from the outer function.
• They help organize code and improve readability.
• Local functions are not visible outside their containing function.

Key Takeaways

Local functions are functions defined inside other functions to keep code organized.

They can use variables from the outer function directly.

Use local functions to hide helper logic and avoid code repetition.

Local functions improve readability by grouping related code together.