An Interest In:
Web News this Week
- April 2, 2024
- April 1, 2024
- March 31, 2024
- March 30, 2024
- March 29, 2024
- March 28, 2024
- March 27, 2024
Go Series: Closure
A closure is the combination of a function and the lexical environment within which that function was declared.
This environment consists of any local variables that were in-scope at the time the closure was created.
The closure concept exists in many languages, in JS for example , it is heavily used for many cases. In go, closure is commonly used for defer and goroutines - we'll explore more of these topics in upcoming series.
The function adder returns another function when invoked, the lexical scope includes the sum variable which is accessible by the returned function. Note that in Go, a closure is always an anonymous function.
func adder() func(int) int { sum := 0 // this is a closure, it has access to sum variable // each closure has its own sum variable return func(x int) int { sum += x return sum }}
every time adder is invoked, it creates a new function with closure.
addFn := adder() fmt.Println(addFn(1)) // initial sum value of 0 is added to 1 fmt.Println(addFn(2)) // returns 3, sum variable is maintained by addFn closure // calling adder like below will not work as intended as the closure from first line is not being used by the second line, instead, creating a new one fmt.Println(adder()(1)) // returns 1 fmt.Println(adder()(100)) // returns 100
Another example of closure below where the closure is assigned to a variable first
func namer() func() string { name := "my name" // name variable still exists in fn even after namer is finished fn := func() string { return name } return fn}
With the fundamental understanding of closure, let's explore defer in the next post - one of the unique things in Go compared to other popular languages
Original Link: https://dev.to/achristoph/go-series-closure-52ef
Dev To
An online community for sharing and discovering great ideas, having debates, and making friendsMore About this Source Visit Dev To