本节学习几种函数
- 匿名函数
- 高阶函数
- 闭包
- 头等函数的作用
匿名函数
什么是匿名函数？
通俗的讲就是没有函数名的函数
package main
import "fmt"
func main() {
add := func (x,y int)int{
return x+y
}
fmt.Println(add(1,2))
}
让变量add 等于一个匿名函数 使用这个函数的唯一方法就是 add（）
其实匿名函数也可以不用存储给变量的,可以立即执行如下
package main
import "fmt"
func main() {
result := func (x,y int)int{
return x+y
}(1,2)
fmt.Println(result)
}
func (x,y int)int{ return x+y }(1,2) 这代码前半句,是创建了一个匿名函数后面使用（1，2）是直接执行这个函数
匿名函数就讲到这里,下面我们来玩一个有意思的自定义函数
package main
import "fmt"
type Add func(int,int)int
func main() {
var add Add = func(i int, i2 int) int {
return i + i2
}
fmt.Println(add(1,2))
}
type Add func(int,int)int 这个就是我们自定义的一个函数类型,给其命名Add
var add Add 我们就可以把变量a 声明为Add 类型,只要后面的定义是这种类型就可以了
下面我们就看一下这个自定义函数的实际使用场景
高阶函数
什么是高级函数？
满足下面任意一个条件的就是高级函数
- 接收一个或多个函数作为参数
- 返回值是一个函数
我们先看第一种 接收一个或多个函数作为参数
package main
import (
"errors"
"fmt"
)
// 1
type Operator func(int,int)int
// 2
func add(x,y int)int{
return x + y
}
// 3
func calculate(x,y int,op Operator)(int,error){
if(op == nil){
return 0,errors.New("无效的操作符")
}
return op(x,y),nil
}
func main() {
result,ok := calculate(4,2,add)
// 4
if(ok == nil){
fmt.Println(result)
}
}
1.我们自定义了一个两个输入参数都是int类型,返回值是一个int 类型的函数,命名Operator 代表操作符函数
2.我们定义了一个两个整数进行相加运算的算法函数
3.这个就是我们定义的高级函数,接受两个参数和一个操作符,注意一句代码 if(op == nil) 为什么这里我们要进行判断呢？ 因为函数都是引用类型,所以可以把一个空地址赋值给引用类型,如nil 所以我们在这里进行判断
这里延伸一下,那些类型是引用类名呢？常见的通道 切片都是引用类型
如下定义是不会报错的
var ch chan int = nil
var s []string = nil
但是数组赋值nil 就会报错
var s [3]string = nil
4.在获取值的使用，最好先检测一下返回值有没有错误，可能你会出自己写的代码难道还会传一个nil吗? 测试可是喜欢用各种异常情况整治你们的,所以你应该让自己的代码,无懈可击才对
第二种 代码中返回函数
package main
import (
"errors"
"fmt"
)
// 1
type Operator func(int,int)int
// 2
func GetOperator(command string)(Operator,error){
add := func(i int, i2 int) int {
return i + i2
}
minus := func(i int, i2 int) int {
return i - i2
}
switch command {
case "+": return add, nil
case "-": return minus,nil
default:
return nil,errors.New("无效的命令")
}
}
// 3
func calculate(x,y int,op string)(int,error){
v,err := GetOperator(op)
if(err == nil){
return v(x,y),nil
}
return 0,err
}
func main() {
result,ok := calculate(4,2,"-")
if(ok == nil){
fmt.Println(result)
}
}
2 就是我们定义的函数值当做返回值的类型，根据用户传入的命令 返回一个对应的函数作，如果是无效的字符串,我们就返回一个错误类型,提醒用户
result,ok := calculate(4,2,"-") 这就是我们最终使用的方式,这个也就是函数式编程的思想
闭包?
package main
import (
"fmt"
)
func main() {
a := 5
func() {
fmt.Println("a =", a)
}()
}
什么是闭包?
闭包（Closure）是匿名函数的一个特例。当一个匿名函数所访问的变量定义在函数体的外部时，就称这样的匿名函数为闭包
下面分析一个案例
package main
import (
"fmt"
)
func appendStr() func(string) string {
t := "Hello"
// 1.
c := func(b string) string {
t = t + " " + b
return t
}
return c
}
func main() {
a := appendStr()
fmt.Println(a("World"))
fmt.Println(a("my name is xj"))
}
appendStr 函数返回的是一个闭包,c变量引用了一个匿名函数,这个匿名中访问了它外面的一个变量t,所以它就是闭包,这个变量t 就和闭包绑定在了一起
下面看一下执行的过程
a := appendStr()执行完毕之后 返回的 a其实就是一个匿名函数，这个时候调用 a("World")，就完成了匿名函数的执行，此时绑定的变量t的值会变成 Hello world ,下面我们继续调用了 a("my name is xj") 那么,t 有进行的拼接,变成了Hello world my name is xj
头等函数
支持头等函数（First Class Function）的编程语言，可以把函数赋值给变量，也可以把函数作为其它函数的参数或者返回值。Go 语言支持头等函数的机制
头等函数的作用很广,map函数你
package main
import "fmt"
// 1
func IMap(list []int,f func(int)int)[]int{
for index,value := range list{
list[index] = f(value)
}
return list
}
func main() {
list := []int{1,2,3,4,5,6}
// 2
IMap(list, func(i int) int {
return i * i
})
fmt.Println(list)
}
我们定义了一个IMap 函数,对一个数组的元素进行f 操作,然后把值返回出来,由于list 是切片 是一个引用类型,所以我么直接在其上面修改值即可,这样我们的源切片的值,就会被直接改,节省了内存空间,但是这个其实违背了函数式编程的思想,函数式编程要求,不能修改输入的值。
