How do closures work in Go?

How do closures work in Go language?

Closure is a special function. In Go language, closure is widely used in functional programming and concurrent programming. So, what is a closure and how does it work?

Definition of closure

A closure refers to a function that contains free variables. This function can access and modify variables outside its own scope. Simply put, a closure defines a function inside a function, and the inner function can access local variables in the outer function.

For example, here is an example of a closure:

func add(x int) func(int) int {
    return func(y int) int {
        return x + y
    }
}

In this example, the add function returns a closure. add The function accepts an integer parameter x and returns a function. This function also accepts an integer parameter y and returns the value of x y. Since inner functions can access variables in outer functions, in this example, inner functions can access variables x in the add function.

How closures work

When a function returns a closure, the closure will contain references to all free variables. This means that when the outer function returns, its local variables are not destroyed. Instead, they will remain in the closure until the closure is destroyed.

Here is a sample code illustrating how closures work:

func main() {
    c := counter()
    fmt.Println(c())
    fmt.Println(c())
    fmt.Println(c())
}

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

In this example, the counter function returns a closure. This closure contains a reference to the variable count. In the closure, the value of the count variable is incremented and the incremented value is returned. When the outer function returns, the variable count is not destroyed, but is saved in the closure. Therefore, every time the closure is called, the value of the count variable will be incremented.

Summary

In the Go language, closure is a powerful function type that can access and modify variables outside its own scope. By using closures, we can write more flexible and reusable code.

The above is the detailed content of How do closures work in Go?. For more information, please follow other related articles on the PHP Chinese website!