[译] part 33: golang 头等函数
https://juejin.im/post/5cb32868e51d456e431ada2a
- 原文地址:Part 33: First Class Functions
- 原文作者:Naveen R
- 译者:咔叽咔叽 转载请注明出处。
什么是头等函数
支持头等函数的语言允许将函数赋值给变量,作为参数传递给其他函数并从其他函数返回。 Go 支持头等函数功能。
在本教程中,我们将讨论头等函数的语法和各种用例。
匿名函数
让我们从一个简单的例子开始,它将一个函数赋给变量。
package main
import (
"fmt"
)
func main() {
a := func() {
fmt.Println("hello world first class function")
}
a()
fmt.Printf("%T", a)
}
在上面的程序中的第 8 行,我们为变量a
分配了一个函数。 这是将函数赋值给变量的语法。如果你仔细观察的话会发现,分配给a
的函数没有名称。这些没有名称的函数称为匿名函数。
调用此函数的唯一方法是使用变量a
。我们使用 a()
调用该函数,将打印hello world first class function
。在第 12 行,我们打印变量a
的类型,将打印func()
。
运行该程序,将输出,
hello world first class function
func()
也可以不赋值给变量来调用匿名函数,让我们看看以下示例中怎么完成的此操作。
package main
import (
"fmt"
)
func main() {
func() {
fmt.Println("hello world first class function")
}()
}
在上面的程序中,我们在第 8 行定义了一个匿名函数。 在函数定义之后,我们在行号中使用()
调用函数。 该程序将输出,
hello world first class function
也可以像任何其他函数一样将参数传递给匿名函数。
package main
import (
"fmt"
)
func main() {
func(n string) {
fmt.Println("Welcome", n)
}("Gophers")
}
在上面的程序中的第 10 行,将字符串参数传递给匿名函数。运行此程序将打印,
Welcome Gophers
用户定义的函数类型
就像定义自己的结构类型一样,我们也可以定义自己的函数类型。
type add func(a int, b int) int
上面的代码片段创建了一个新的函数类型add
,它接受两个整数参数并返回一个整数。现在我们可以定义add
类型的变量。
让我们编写一个定义add
类型变量的程序。
package main
import (
"fmt"
)
type add func(a int, b int) int
func main() {
var a add = func(a int, b int) int {
return a + b
}
s := a(5, 6)
fmt.Println("Sum", s)
}
在上面的程序的第 10 行,我们定义了一个类型为add
的变量a
,并为其赋予与add
类型匹配的函数。在第 13 行,我们调用该函数,并将结果分配给s
。该程序将打印,
Sum 11
高阶函数
wiki)上高阶函数的定义是满足以下至少一个条件
- 将一个或多个函数作为参数
- 返回一个函数作为结果
让我们看一下上述两种情况的一些简单示例。
将函数作为参数传递给其他函数
package main
import (
"fmt"
)
func simple(a func(a, b int) int) {
fmt.Println(a(60, 7))
}
func main() {
f := func(a, b int) int {
return a + b
}
simple(f)
}
在上面的例子中的第 7 行,我们定义一个函数simple
,它接受一个函数,该函数接受两个int
参数并返回一个int
作为参数。在 main 函数里面,我们创建了一个匿名函数f
,其与函数simple
的参数匹配。我们调用simple
,并在下一行中将f
作为参数传递给它。该程序打印67
作为输出。
从其他函数返回函数
现在让我们重写上面的程序并从simple
函数返回一个函数。
package main
import (
"fmt"
)
func simple() func(a, b int) int {
f := func(a, b int) int {
return a + b
}
return f
}
func main() {
s := simple()
fmt.Println(s(60, 7))
}
在上面程序中的第 7 行,simple
函数返回一个函数,该函数接受两个int
参数并返回一个int
参数。
在第 15 行调用了simple
函数,然后将返回值分配给s
。现在s
包含simple
函数返回的函数。我们调用s
并传递两个int
参数。 该程序将输出67
。
闭包
闭包是匿名函数的特例。闭包是匿名函数,用于访问该匿名函数体外定义的变量。
用个例子了解一下它,
package main
import (
"fmt"
)
func main() {
a := 5
func() {
fmt.Println("a =", a)
}()
}
在上面程序中的第 10 行,匿名函数访问函数体外定义的变量a
。因此,这个匿名函数是一个闭包。
每个闭包都把变量绑定到它周围的变量。让我们通过一个简单的例子来理解这是什么意思。
package main
import (
"fmt"
)
func appendStr() func(string) string {
t := "Hello"
c := func(b string) string {
t = t + " " + b
return t
}
return c
}
func main() {
a := appendStr()
b := appendStr()
fmt.Println(a("World"))
fmt.Println(b("Everyone"))
fmt.Println(a("Gopher"))
fmt.Println(b("!"))
}
在上面的程序中,函数appendStr
返回一个闭包。该闭包绑定到变量t
。
变量a
和b
分别在第 17 和 18 行中声明为闭包,它们与自己的t
值绑定。
我们先用参数World
调用a
。现在,a
闭包t
的值变成了Hello World
。
在第 20 行,我们用参数Everyone
调用b
。由于b
绑定到自己的变量t
,因此b
闭包的初始值为Hello
。在此函数调用之后,b
闭包变量t
的值将变为Hello Everyone
。
程序将输出,
Hello World
Hello Everyone
Hello World Gopher
Hello Everyone !
头等函数的实际用法
到目前为止,我们已经定义了头等函数,并且我们已经编写了一些例子来了解它们的工作原理。现在让我们编写一个具体的程序,它揭示了头等函数的实际用法。
我们将创建一个程序,根据某些标准过滤一部分学生。让我们一步一步地解决这个问题。
首先定义学生类型,
type student struct {
firstName string
lastName string
grade string
country string
}
下一步是编写filter
函数。该函数的入参为student
结构的切片和一个确认student
是否符合条件的函数。编写这个函数,能让我们更好地理解。让我们继续吧。
func filter(s []student, f func(student) bool) []student {
var r []student
for _, v := range s {
if f(v) == true {
r = append(r, v)
}
}
return r
}
在上面的函数中,第二个参数是一个以student
为参数并返回bool
的函数。此函数是为了确认该student
是否符合条件。我们在第 3 行中迭代student
切片,然后将每个student
作为参数传递给函数f
。如果返回true
,则表示student
符合过滤条件,并将其添加到结果切片r
中。你可能对此功能的实际使用感到有些困惑,继续完成该程序就会更清楚。我添加了 main 函数,并在下面提供了完整的程序。
package main
import (
"fmt"
)
type student struct {
firstName string
lastName string
grade string
country string
}
func filter(s []student, f func(student) bool) []student {
var r []student
for _, v := range s {
if f(v) == true {
r = append(r, v)
}
}
return r
}
func main() {
s1 := student{
firstName: "Naveen",
lastName: "Ramanathan",
grade: "A",
country: "India",
}
s2 := student{
firstName: "Samuel",
lastName: "Johnson",
grade: "B",
country: "USA",
}
s := []student{s1, s2}
f := filter(s, func(s student) bool {
if s.grade == "B" {
return true
}
return false
})
fmt.Println(f)
}
在 main 函数中,我们首先创建两个student
类型的变量s1
和s2
,并将它们添加到切片s
中作为参数传递给filter
函数。现在我想找出所有B
级的学生。我们在上面的程序中通过一个函数来检查学生是否有B
级,如果是,那么返回true
。上述程序将打印,
[{Samuel Johnson B USA}]
假设我们想找到所有来自印度的学生。将filter
函数参数改变一下,可以轻松完成此操作。
我提供了以下代码,
c := filter(s, func(s student) bool {
if s.country == "India" {
return true
}
return false
})
fmt.Println(c)
请将其添加到 main 函数并检查输出。
让我们再写一个程序来结束本节。该程序将对切片的每个元素执行相同的操作并返回结果。例如,如果我们想要将切片中的所有整数乘以 5 并返回输出,则可以使用头等函数轻松完成。这些对集合的每个元素进行操作的函数称为map
函数(译者注:map/reduce 函数)。我提供了以下程序。
package main
import (
"fmt"
)
func iMap(s []int, f func(int) int) []int {
var r []int
for _, v := range s {
r = append(r, f(v))
}
return r
}
func main() {
a := []int{5, 6, 7, 8, 9}
r := iMap(a, func(n int) int {
return n * 5
})
fmt.Println(r)
}
上述程序将输出,
[25 30 35 40 45]
快速回顾一下本教程的内容,
- 什么是头等函数
- 匿名函数
- 用户定义的函数类型
- 高阶函数
- 将函数作为参数传递给其他函数
- 从其他函数返回函数
- 闭包
- 头等函数的实际用法
ft_update_time2019-08-03 16:41