当定义一个使用外部作用域变量的内部函数时,我应该将变量作为参数传递给内部函数吗?
在我的例子中,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
}
最佳答案
When defining a inner function which utilizes the variables of outer scope, should I pass the variables to the inner function as parameters?
这取决于你想要实现什么。
你所说的“函数中的函数”实际上被称为“闭包”(有些人称之为“lambda”)。
闭包从外部词法范围捕获变量,在其主体中引用。在 Go 中,这种捕获是“通过引用”或“通过名称”完成的,这基本上意味着每次调用闭包时,它都会“看到”它关闭的变量的当前值,而不是这些值变量在创建闭包时有——观察程序:
package main
import (
"fmt"
)
func main() {
i := 42
fn := func() {
fmt.Println(i)
}
fn()
i = 12
fn()
}
会输出
42
12
相反,当您将值作为参数传递给闭包调用时,每次调用都会准确看到传递给它的值。
我希望您现在明白,选择什么策略在很大程度上取决于您想要什么。
从概念上讲,您可以将闭包视为临时匿名 struct
数据类型的实例,其字段是指向闭包关闭的变量的指针,并且每次调用该闭包类似于调用该类型提供的某些(匿名的,唯一的)方法(实际上,这就是编译器通常在您背后执行闭包的操作)。
这样的“方法”可能有参数,它是否应该有参数,什么应该进入类型的字段以及该方法的参数应该是什么,可以使用您对常规类型采用的常用方法来判断。
关于go - 在函数内部定义函数,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/56262723/