Difference between golang function closure and anonymous function

The main difference between closures and anonymous functions in the Go language is that closures can access variables outside their creation scope; anonymous functions cannot access variables outside their creation scope.

The difference between function closures and anonymous functions in Go language

Closures

A closure is a function that can access variables outside the scope of its creation. This means that closures can carry references to external variables even if those variables are no longer available after the closure is created.

func createClosure() func() {
    x := 10
    return func() {
        fmt.Println(x)
    }
}

In the above example, the createClosure function returns a closure that has access to the variable x.

Anonymous function

Anonymous function is a function without an explicit name. They are typically used to pass as arguments or as return values ​​from other functions.

func main() {
    fmt.Println(func(x int) int { return x * x }(5))
}

In this example, we create an anonymous function that takes one parameter and returns the square of that parameter.

The difference between the two

The main difference between closures and anonymous functions is that closures can access variables outside the scope of their creation, while anonymous functions Functions cannot. This means that closures can carry references to external variables, while anonymous functions cannot.

Practical case

Closure example:

Imagine that we need a function to calculate the square of a number. We can use closures to create a function that uses constants stored in the outer scope as coefficients for the square operation.

func createSquaringFunction(coefficient int) func(int) int {
    return func(x int) int { return coefficient * x * x }
}

func main() {
    squaringFunction := createSquaringFunction(2)
    fmt.Println(squaringFunction(5)) // 输出：50
}

Anonymous function example:

Imagine that we want to perform some action on each number in the list. We can use anonymous functions to create a function that will be passed to the map function and applied to each element in the list.

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    squaredNumbers := map(func(x int) int { return x * x }, numbers)
    fmt.Println(squaredNumbers) // 输出：map[1:1 2:4 3:9 4:16 5:25]
}

The above is the detailed content of Difference between golang function closure and anonymous function. For more information, please follow other related articles on the PHP Chinese website!