书接上回,上回书说到,结构体,一言之重在于体。一体之重在于经。经之重甚于骨。这张就说go的经络—函数。
文章目录
- 函数
- 函数如何定义
- 参数
- 可变参数
- 返回值
- 多返回值
- 函数类型与变量
- 高阶函数
- 函数作为参数
- 函数作为返回值
- 匿名函数
- 闭包
- defer语句
- 底层逻辑
- 内置函数
- panic/recover(错误处理)
函数
函数是组织好的、可重复使用的、用于执行指定任务的代码块。
Go语言中支持函数、匿名函数和闭包。
函数如何定义
Go语言中定义函数使用func关键字(其实吧,我认为这个里面的所有都是要加func,当然结构体不加)
func 函数名(参数)(返回值){
函数体
}
注意
- 函数名:由字母、数字、下划线组成。
- 函数名的第一个字母不能是数字
- 在同一个包内,函数名也称不能重名
- 参数:参数由参数变量和参数变量的类型组成,多个参数之间使用,分隔。
- 返回值:返回值由返回值变量和其变量类型组成,也可以只写返回值的类型,
多个返回值
必须用()包裹,并用,分隔。(这个就有点牛了) - 函数体:实现指定功能的代码块。
函数的参数和返回值都是可选的。
func sayHello() {
fmt.Println("Hello")
}
定义了函数之后,我们可以通过函数名()的方式调用函数。 调用有返回值的函数时,可以不接收其返回值。
func main() {
sayHello()
}
参数
函数的参数中如果相邻变量的类型相同,则可以省略类型
func intSum(x, y int) int {
return x + y
}
可变参数
可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加…来标识。这种方式在java中是通过重写来实现。但是这里似乎就不许要这么麻烦。
注意:可变参数通常要作为函数的最后一个参数。
func intSum2(x ...int) int {
fmt.Println(x) //x是一个切片
sum := 0
for _, v := range x {
sum = sum + v
}
return sum
}
ret1 := intSum2()
ret2 := intSum2(10)
ret3 := intSum2(10, 20)
ret4 := intSum2(10, 20, 30)
fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60
注意
固定参数搭配可变参数使用时,可变参数要放在固定参数的后面
实际上:函数的可变参数是通过切片来实现的。
返回值
Go语言中通过return关键字向外输出返回值。其实这个大差不差,毕竟语言差别都差不多
多返回值
Go语言中函数支持多返回值,函数如果有多个返回值时必须用()将所有返回值包裹起来
func calc(x, y int) (int, int) {
sum := x + y
sub := x - y
return sum, sub
}
其实这个括号的返回参数的类型,可以为任意属性,但是在return的返回值时,也必须按照这个返回顺序返回。
当我们的一个函数返回值类型为slice时,nil可以看做是一个有效的slice,没必要显示返回一个长度为0的切片。
func someFunc(x string) []int {
if x == "" {
return nil // 没必要返回[]int{}
}
...
}
函数定义时可以给返回值命名,并在函数体中直接使用这些变量,最后通过return关键字返回
func calc(x, y int) (sum, sub int) {
sum = x + y
sub = x - y
return
}
函数类型与变量
我们可以使用type关键字来定义一个函数类型:
type calculation func(int, int) int
定义了一个calculation类型,它是一种函数类型,这种函数接收两个int类型的参数并且返回一个int类型的返回值。
凡是满足这个条件的函数都是calculation类型的函数。
type calculation func(int, int) int
func add(x, y int) int {
return x + y
}
func sub(x, y int) int {
return x - y
}
var c calculation
func main() {
c = add
fmt.Println(c(10, 20))
c = sub
fmt.Println(c(10, 20))
}
高阶函数
高阶函数分为函数作为参数
和函数作为返回值
这两部分两部分。
函数作为参数
func add(x, y int) int {
return x + y
}
func calc(x, y int, op func(int, int) int) int {
return op(x, y)
}
func main() {
ret2 := calc(10, 20, add)
fmt.Println(ret2) //30
}
函数作为返回值
func do(s string) (func(int, int) int, error) {
switch s {
case "+":
return add, nil
case "-":
return sub, nil
default:
err := errors.New("无法识别的操作符")
return nil, err
}
}
匿名函数
当函数作为返回值时,在Go语言中函数内部就不能像之前那样定义函数了,只能定义匿名函数,匿名函数就是没有函数名的函数。
func(参数)(返回值){
函数体
}
匿名函数因为没有函数名,所以没办法像普通函数那样调用,所以匿名函数需要保存到某个变量或者作为立即执行函数(这种方式多用于回调函数和闭包):
func main() {
// 将匿名函数保存到变量
add := func(x, y int) {
fmt.Println(x + y)
}
add(10, 20) // 通过变量调用匿名函数
//自执行函数:匿名函数定义完加()直接执行
func(x, y int) {
fmt.Println(x + y)
}(10, 20)
}
闭包
闭包指的是一个函数和与其相关的引用环境组合而成的实体。
闭包 = 函数 + 引用环境
func adder() func(int) int {
var x int
return func(y int) int {
x += y
return x
}
}
func main() {
var f = adder()
fmt.Println(f(10)) //10+0
fmt.Println(f(20)) //30 = 10 + 20
fmt.Println(f(50)) //80 = 50 + 30
f2 := adder()
fmt.Println(f2(60)) //60 = 0 + 60
fmt.Println(f2(30)) //90 = 30 + 60
}
变量f是一个函数并且它引用了其外部作用域中的x变量,此时f就是一个闭包。 在main方法中f
成为了adder
函数的指针,此时,他作为一个函数,x 是 属于第二个函数的全局变量。在这种情况下,在 f
的生命周期没有结束,此时x中的有效值就会一直存在。
闭包其实并不复杂,只要牢记闭包=函数+引用环境
当然在结合上面普通的函数特点我们就可以将闭包升级。
在函数中添加参数
func adder2(x int) func(int) int {
return func(y int) int {
x += y
return x
}
}
在匿名函数中做逻辑判断
func makeSuffixFunc(suffix string) func(string) string {
return func(name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
}
return name
}
}
返回多个函数
func calc(base int) (func(int) int, func(int) int) {
add := func(i int) int {
base += i
return base
}
sub := func(i int) int {
base -= i
return base
}
return add, sub
}
defer语句
Go语言中的defer语句会将其后面跟随的语句进行延迟处理。
在defer归属的函数即将返回时,将延迟处理的语句按defer定义的逆序进行执行。
先被defer的语句最后被执行,最后被defer的语句,最先被执行。
func main() {
fmt.Println("start")
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
fmt.Println("end")
}
这就最先执行defer,最后执行的意思
底层逻辑
在Go语言的函数中return语句在底层并不是原子操作,它分为给返回值赋值和RET指令两步。
而 defer
执行的时机就在返回值赋值操作后。
看一道题:
func calc(index string, a, b int) int {
ret := a + b
fmt.Println(index, a, b, ret)
return ret
}
func main() {
x := 1
y := 2
defer calc("AA", x, calc("A", x, y))
x = 10
defer calc("BB", x, calc("B", x, y))
y = 20
}
想一想打印什么?
发现没有,在7,8中有一个问题,就是x的值,此时的8的x的值是之前没有变成 10 之前的。
内置函数
内置函数 | 介绍 |
---|---|
close | 主要用来关闭channel |
len | 用来求长度,比如string、array、slice、map、channel |
new | 用来分配内存,主要用来分配值类型,比如int、struct。返回的是指针 |
make | 用来分配内存,主要用来分配引用类型,比如chan、map、slice |
append | 用来追加元素到数组、slice中 |
panic和recover | 用来做错误处理 |
panic/recover(错误处理)
Go语言中目前是没有异常机制,但是使用panic/recover模式来处理错误。panic可以在任何地点引发,但recover只有在defer调用的函数中有效。
func funcA() {
fmt.Println("func A")
}
func funcB() {
panic("panic in B")
}
func funcC() {
fmt.Println("func C")
}
func main() {
funcA()
funcB()
funcC()
}
程序运行期间funcB中引发了panic导致程序崩溃,异常退出了。但是我们要如何像java中那样去抛出异常呢?
这个时候我们就可以通过recover将程序恢复回来,继续往后执行
func funcA() {
fmt.Println("func A")
}
func funcB() {
defer func() {
err := recover()
//如果程序出出现了panic错误,可以通过recover恢复过来
if err != nil {
fmt.Println("recover in B")
}
}()
panic("panic in B")
}
func funcC() {
fmt.Println("func C")
}
func main() {
funcA()
funcB()
funcC()
}
注意
:这个就有一点像Java的 try…catch
- recover()必须搭配defer使用。
- defer一定要在可能引发panic的语句之前定义。