Introduction
A closure in Go is a function that references variables from outside its body. This allows the function to capture and “close over” these variables, maintaining their state between calls. Closures are useful for creating function factories, encapsulating state, and more. In this chapter, you will learn the basics of closures in Go, including examples to illustrate how they work and how to use them effectively.
Basics of Closures
In Go, any function can be a closure. A closure can access and modify variables defined outside its own scope.
Example
Basic Closure:
package main
import "fmt"
func main() {
x := 10
increment := func() int {
x++
return x
}
fmt.Println(increment()) // Output: 11
fmt.Println(increment()) // Output: 12
}
In this example, the increment function is a closure that captures and modifies the variable x from the surrounding main function.
Practical Uses of Closures
Function Factories
Closures can be used to create function factories – functions that return other functions.
Example:
package main
import "fmt"
func adder() func(int) int {
sum := 0
return func(x int) int {
sum += x
return sum
}
}
func main() {
add := adder()
fmt.Println(add(10)) // Output: 10
fmt.Println(add(5)) // Output: 15
fmt.Println(add(2)) // Output: 17
}
In this example, the adder function returns a closure that maintains the state of the sum variable between calls.
Encapsulation
Closures can be used to encapsulate state and provide controlled access to it.
Example:
package main
import "fmt"
func counter() (func() int, func() int) {
count := 0
increment := func() int {
count++
return count
}
decrement := func() int {
count--
return count
}
return increment, decrement
}
func main() {
inc, dec := counter()
fmt.Println(inc()) // Output: 1
fmt.Println(inc()) // Output: 2
fmt.Println(dec()) // Output: 1
}
In this example, the counter function returns two closures – increment and decrement – that modify the shared count variable.
Closures and Goroutines
Closures are often used with goroutines to capture variables and pass them to concurrent functions.
Example:
package main
import (
"fmt"
"time"
)
func main() {
for i := 0; i < 5; i++ {
go func(n int) {
fmt.Println(n)
}(i)
}
time.Sleep(1 * time.Second)
}
In this example, each goroutine captures the value of i at the time the closure is created, ensuring that each goroutine prints a different value.
Conclusion
Closures in Go are used to allow functions to capture and manipulate variables from their surrounding context. By understanding how to use closures, you can create more flexible and modular code. Closures are particularly useful for creating function factories, encapsulating state, and working with goroutines. Mastering closures will enhance your ability to write more expressive and maintainable Go programs.