Go Closure#

Go closure is a nested function that allows us to access variables of the outer function even after the outer function is closed.

Before we learn about closure, let's first revise the following concepts:

• Nested Functions
• Returning a function

#Nested function in Golang

In Go, we can create a function inside another function. This is known as a nested function. For example,

package main
import "fmt"

// outer function
func greet(name string) {

  // inner function
  var displayName = func() {
    fmt.Println("Hi", name)
  }

  // call inner function
  displayName()

}

func main() {

  // call outer function
  greet("John")  // Hi John

}

In the above example, we have created an anonymous function inside the greet() function.

Here, var displayName = func() {...} is a nested function. The nested function works similar to the normal function. It executes when displayName() is called inside the function greet().

#Returning a function in Go

We can create a function that returns an anonymous function. For example,

package main
import "fmt"

func greet() func() {

  return func() {
    fmt.Println("Hi John")
  }

}

func main() {

  g1 := greet()
  g1()
}

Output

Hi John

In the above example, we have created the greet() function.

func greet() func() {...}

Here, func() before the curly braces indicates that the function returns another function.

Also, if you look into the return statement of this function, we can see the function is returning a function.

From main(), we call the greet() function.

g1 := greet()

Here, the returned function is now assigned to the g1 variable. Hence, g1() executes the nested anonymous function.

#Go Closures

As we have already discussed, closure is a nested function that helps us access the outer function's variables even after the outer function is closed. Let's see an example.

package main
import "fmt"

// outer function
func greet() func() string {

  // variable defined outside the inner function
  name := "John"

  // return a nested anonymous function
  return func() string {
    name = "Hi " + name
    return name
  }
}

func main() {

  // call the outer function
  message := greet()

  // call the inner function
  fmt.Println(message())

}

Output

Hi John

In the above example, we have created a function named greet() that returns a nested anonymous function.

Here, when we call the function from main().

message := greet()

The returned function is now assigned to the message variable.

At this point, the execution of the outer function is completed, so the name variable should be destroyed. However, when we call the anonymous function using

fmt.Println(message())

we are able to access the name variable of the outer function.

It's possible because the nested function now acts as a closure that closes the outer scope variable within its scope even after the outer function is executed.

Let's see one more example to make this concept clear for you.

#Example: Print Odd Numbers using Golang Closure

package main
import "fmt"

func calculate() func() int {
  num := 1

  // returns inner function
  return func() int {
    num = num + 2
    return num
  }

}

func main() {

  // call the outer function
  odd := calculate()

  // call the inner function
  fmt.Println(odd())
  fmt.Println(odd())
  fmt.Println(odd())

  // call the outer function again
  odd2 := calculate()
  fmt.Println(odd2())

}

Output

3
5
7
3

In the above example,

odd := calculate()

This code executes the outer function calculate() and returns a closure to the odd number. That's why we can access the num variable of calculate() even after completing the outer function.

Again, when we call the outer function using

odd2 := calculate()

a new closure is returned. Hence, we get 3 again when we call odd2().

#Closure helps in Data Isolation

As we see in the previous example, a new closure is returned every time we call the outer function. Here, each returned closure is independent of one another, and the change in one won't affect the other.

This helps us to work with multiple data in isolation from one another. Let's see an example.

package main
import "fmt"

func displayNumbers() func() int {
  number := 0

  // inner function
  return func() int {
  number++
  return number
  }

}

func main() {

  // returns a closure
  num1 := displayNumbers()

  fmt.Println(num1())
  fmt.Println(num1())
  fmt.Println(num1())

  // returns a new closure
  num2 := displayNumbers()
  fmt.Println(num2())
  fmt.Println(num2())

}

Output

1
2
3
1
2

In the above example, the displayNumbers() function returns an anonymous function that increases the number by 1.

return func() int {
  number++
  return number
}

Inside the main() function, we assign the function call to num1 and num2 variables.

Here, we first call the closure function using num1(). In this case, we get outputs 1, 2, and 3.

Again, we call it using num2(). In this case, the value of the number variable doesn't start from 3; instead, it starts from 1 again.

This shows that the closure returned from displayNumbers() is isolated from one another.