在函数内部定义函数

积累知识，胜过积蓄金银！毕竟在Golang开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《在函数内部定义函数》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

定义使用外部作用域变量的内部函数时，是否应该将变量作为参数传递给内部函数？

在我的示例中，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
}

解决方案

定义使用外部作用域变量的内部函数时，是否应该将变量作为参数传递给内部函数？

这取决于您想要实现的目标。

你所谓的“函数内的函数”实际上称为“闭包”（有些人称之为“lambda”）。

闭包捕获来自外部词法范围的变量，并在其主体中引用。在 go 中，这种捕获是“通过引用”或“通过名称”完成的，这基本上意味着每次调用闭包时，它将“看到”它所关闭的变量的当前值，而不是这些值创建闭包时的变量——观察程序：

package main

import (
    "fmt"
)

func main() {
    i := 42

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

    fn()
    i = 12
    fn()
}

会输出

42
12

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

我希望您现在明白选择什么策略很大程度上取决于您想要什么。

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

在这种情况下，两个函数之间不存在功能差异。正如您所注意到的，局部函数可以访问局部变量而无需显式传递它们。在您的示例中，您可能更喜欢使用generate1以便于阅读。

以上就是《在函数内部定义函数》的详细内容，更多关于的资料请关注golang学习网公众号！