Golang支持头等函数的机制。
头等函数:支持头等函数的编程语言，可以把函数赋值给变量，也可以把函数作为其他函数的参数或返回值。
匿名函数
func main(){
a:=func(){
fmt.Println("Hello World!")
}
a()
fmt.Printf("%T",a)
}
- 这是把函数赋值给变量的语法，给a赋值的函数没有函数名称，这类函数称为匿名函数。
2.调用该函数的唯一方式就是使用变量a。打印出的a的类型是func()。
3.要调用一个匿名函数且不赋值给变量，可以这样写：
package main
import(
"fmt"
)
func main(){
func(){
fmt.Println("hello world!")
}()
}
自定义的函数类型
就是取别名，这样写
type add func(a int, b int)int
创建的新的函数类型就是add，参数是两个int变量，返回一个int类型。
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(s)
}
高阶函数
满足下列条件之一的函数就是高阶函数：
1.接收一个或多个函数作为参数
2.返回值就是一个函数
函数作为其他函数的参数
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)
}
函数作为返回值
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))
}
闭包
闭包是匿名函数的一个特例。当一个匿名函数所访问的变量定义在函数体外时，就称这样的匿名函数为闭包
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("!"))
}
头等函数的实用
1.过滤一个students切片，筛选条件
选出grade是B的
type student struct { firstName string lastName string grade string country string
}
unc 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)
}
2.筛选India的student
c := filter(s, func(s student) bool {
if s.country == "India" {
return true
}
return false })
fmt.Println(c)
