defining function inside of function

Question

When defining a inner function which utilizes the variables of outer scope, should I pass the variables to the inner function as parameters?

In my example, generate and generate2 both give me same result, is there a reason I should choose any one of them?

The code picks key 1 to generate combinations with key 3,4,5, then picks key 2 to generate combinations with key 3,4,5.

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello, playground")

    src := map[int][]string{
        1: []string{"1", "11", "111"},
        2: []string{"2", "22"},
        3: []string{"3"},
        4: []string{"4"},
        5: []string{"5", "55"},
    }

    result2 := generate2(src)

    fmt.Println(result2)

    result := generate(src)

    fmt.Println(result)

}

func generate(src map[int][]string) []string {
    var combo []string
    var add = func(f []string) {
        for _, v := range f {

            for _, p := range src[3] {
                for _, q := range src[4] {
                    for _, r := range src[5] {
                        combo = append(combo, v+p+q+r)
                    }
                }
            }

        }
    }

    add(src[1])
    add(src[2])
    return combo
}

func generate2(src map[int][]string) []string {
    var combo []string
    var add = func(f []string, combo []string, src map[int][]string) []string {
        for _, v := range f {
            for _, p := range src[3] {
                for _, q := range src[4] {
                    for _, r := range src[5] {
                        combo = append(combo, v+p+q+r)
                    }
                }
            }
        }
        return combo
    }

    combo = add(src[1], combo, src)
    combo = add(src[2], combo, src)
    return combo
}

Answer 1

When defining a inner function which utilizes the variables of outer scope, should I pass the variables to the inner function as parameters?

It depends on what you want to achieve.

What you call "a function inside a function" is actually called "a closure" (and some people call it "lambda").

Closures capture variables from the outer lexical scope, referenced in its body. In Go, this capturing is done "by reference" or "by name" which basically means each time a closure is called it will "see" current values of the variables it closes over, not the values these variables had at the time the closure was created—observe that the program:

package main

import (
    "fmt"
)

func main() {
    i := 42

    fn := func() {
      fmt.Println(i)
    }

    fn()
    i = 12
    fn()
}

would output

42
12

Conversely, when you pass values as arguments to calls to a closure, each call will see exactly the values passed to it.

I hope you now see that what strategy to pick largely depends on what you want.

从概念上讲，您可能将闭包视为即席匿名struct数据类型的实例，其字段是指向闭包所关闭的变量的指针，并且对该闭包的每次调用都类似于调用某些（匿名，唯一）类型提供的方法（实际上，这就是编译器通常会在背后实现闭包的方式）。此类“方法”可能具有参数，是否应该具有参数，以及应该进入类型字段的内容以及该方法的参数应该是什么，可以使用您对常规类型使用的常用方法来判断。