函数内部定义函数

Question

当定义一个利用外部作用域变量的内部函数时，应该将这些变量作为参数传递给内部函数吗？

在我的例子中，generate和generate2都给出了相同的结果，我是否应该选择其中的任何一个？

代码选择键1生成键3、4、5的组合，然后选择键2生成键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

当定义一个利用外部作用域变量的内部函数时，应该将这些变量作为参数传递给内部函数吗？

这取决于你想要实现什么。

你所说的“函数内部的函数”实际上称为“闭包”(有些人称它为"lambda")。

闭包从外部词法范围捕获变量，并在其正文中引用。在Go中，这种捕获是“通过引用”或“按名称”完成的，这基本上意味着每次调用闭包时，它都会“看到”它关闭的变量的当前值，而不是这些变量在创建闭包时拥有的值--请注意程序：

package main

import (
    "fmt"
)

func main() {
    i := 42

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

    fn()
    i = 12
    fn()
}

会输出

42
12

相反，当将值作为参数传递给对闭包的调用时，每个调用都会看到传递给它的值。

我希望你们现在看到，选择什么策略主要取决于你想要什么。

从概念上讲，您可能会认为闭包是一个特殊匿名struct数据类型的实例，其字段是指向闭包关闭的变量的指针，而对该闭包的每次调用都类似于调用该类型提供的某个(匿名的、唯一的)方法(实际上，编译器通常是在后台实现闭包的)。这种“方法”可能有参数，以及它是否应该有它们，什么应该进入类型的字段，以及该方法的参数应该是什么，可以使用常规类型所采用的通常方法来判断。

Answer 2

在这种情况下，这两种功能之间没有功能上的区别。正如您注意到的，本地函数可以访问局部变量，而无需显式传递它们。在您的示例中，您可能更喜欢使用generate1来更容易地阅读。