函数

函数的定义

函数是Go里面的核心设计,它通过关键字func来声明,它的格式如下:

  1. func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
  2. //这里是处理逻辑代码
  3. //返回多个值
  4. return value1, value2
  5. }

上面的代码可以看出

  • 关键字func用来声明一个函数funcName
  • 函数可以有一个或者多个参数,每个参数后面带有类型,通过,分隔

  • 函数可以返回多个值

  • 上面返回值声明了两个变量output1output2,如果不想声明也可以,直接就两个类型

  • 如果只有一个返回值且不声明返回值变量,那么可以省略 包括返回值的括号

  • 如果没有返回值,那么就直接省略最后的返回信息

  • 如果有返回值, 那么必须在函数的外层添加return语句

下面来看一个实际应用函数的例子(用来计算Max值)

  1. package main
  2. import "fmt"
  3. // 返回a、b中最大值.
  4. func max(a, b int) int {
  5. if a > b {
  6. return a
  7. }
  8. return b
  9. }
  10. func main() {
  11. x := 3
  12. y := 4
  13. z := 5
  14. max_xy := max(x, y) //调用函数max(x, y)
  15. max_xz := max(x, z) //调用函数max(x, z)
  16. fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
  17. fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
  18. fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // 也可在这直接调用它
  19. }

上面这个里面可以看到max函数有两个参数,它们的类型都是int,那么第一个变量的类型可以省略(即 a,b int,而非 a int, b int),默认为离它最近的类型,同理多于2个同类型的变量或者返回值。同时注意到它的返回值就是一个类型,这个就是省略写法。

多个返回值

Go语言比C更先进的特性,其中一点就是函数能够返回多个值。

直接看例子

  1. package main
  2. import "fmt"
  3. //返回 A+B 和 A*B
  4. func SumAndProduct(A, B int) (int, int) {
  5. return A+B, A*B
  6. }
  7. func main() {
  8. x := 3
  9. y := 4
  10. xPLUSy, xTIMESy := SumAndProduct(x, y)
  11. fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
  12. fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
  13. }

上面的例子可以看到直接返回了两个参数,当然也可以命名返回参数的变量,这个例子里面只是用了两个类型,也可以改成如下这样的定义,然后返回的时候不用带上变量名,因为直接在函数里面初始化了。但如果函数是导出的(首字母大写),官方建议:最好命名返回值,因为不命名返回值,虽然使得代码更加简洁了,但是会造成生成的文档可读性差。

  1. func SumAndProduct(A, B int) (add int, Multiplied int) {
  2. add = A+B
  3. Multiplied = A*B
  4. return
  5. }

变参

Go函数支持变参。接受变参的函数是有着不定数量的参数的。为了做到这点,首先需要定义函数使其接受变参:

  1. func myfunc(arg ...int) {}

arg ...int告诉Go这个函数接受不定数量的参数。注意,这些参数的类型全部是int。在函数体中,变量arg是一个intslice

  1. for _, n := range arg {
  2. fmt.Printf("And the number is: %d\n", n)
  3. }

传值与传指针

传一个参数值到被调用函数里面时,实际上是传了这个值的一份copy,当在被调用函数中修改参数值的时候,调用函数中相应实参不会发生任何变化,因为数值变化只作用在copy上。

为了验证上面的说法,来看一个例子

  1. package main
  2. import "fmt"
  3. //简单的一个函数,实现了参数+1的操作
  4. func add1(a int) int {
  5. a = a+1 // 改变了a的值
  6. return a //返回一个新值
  7. }
  8. func main() {
  9. x := 3
  10. fmt.Println("x = ", x) // 应该输出 "x = 3"
  11. x1 := add1(x) //调用add1(x)
  12. fmt.Println("x+1 = ", x1) // 应该输出"x+1 = 4"
  13. fmt.Println("x = ", x) // 应该输出"x = 3"
  14. }

虽然调用了add1函数,并且在add1中执行a = a+1操作,但是上面例子中x变量的值没有发生变化

理由很简单:因为当调用add1的时候,add1接收的参数其实是x的copy,而不是x本身。

如果真的需要传这个x本身,该怎么办呢?

这就牵扯到了所谓的指针。变量在内存中是存放于一定地址上的,修改变量实际是修改变量地址处的内存。只有add1函数知道x变量所在的地址,才能修改x变量的值。所以需要将x所在地址&x传入函数,并将函数的参数的类型由int改为*int,即改为指针类型,才能在函数中修改x变量的值。此时参数仍然是按copy传递的,只是copy的是一个指针。请看下面的例子

  1. package main
  2. import "fmt"
  3. //简单的一个函数,实现了参数+1的操作
  4. func add1(a *int) int { // 请注意,
  5. *a = *a+1 // 修改了a的值
  6. return *a // 返回新值
  7. }
  8. func main() {
  9. x := 3
  10. fmt.Println("x = ", x) // 应该输出 "x = 3"
  11. x1 := add1(&x) // 调用 add1(&x) 传x的地址
  12. fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
  13. fmt.Println("x = ", x) // 应该输出 "x = 4"
  14. }

这样,就达到了修改x的目的。那么到底传指针有什么好处呢?

  • 传指针使得多个函数能操作同一个对象。
  • 传指针比较轻量级 (8bytes),只是传内存地址,可以用指针传递体积大的结构体。如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销(内存和时间)。所以当要传递大的结构体的时候,用指针是一个明智的选择。

  • Go语言中channelslicemap这三种类型的实现机制类似指针,所以可以直接传递,而不用取地址后传递指针。(注:若函数需改变slice的长度,则仍需要取地址传递指针)

defer

Go语言中有种不错的设计,即延迟(defer)语句,可以在函数中添加多个defer语句。当函数执行到最后时,这些defer语句会按照逆序执行,最后该函数返回。特别是当进行一些打开资源的操作时,遇到错误需要提前返回,在返回前需要关闭相应的资源,不然很容易造成资源泄露等问题。如下代码所示,一般写打开一个资源是这样操作的:

  1. func ReadWrite() bool {
  2. file.Open("file")
  3. // 做一些工作
  4. if failureX {
  5. file.Close()
  6. return false
  7. }
  8. if failureY {
  9. file.Close()
  10. return false
  11. }
  12. file.Close()
  13. return true
  14. }

上面有很多重复的代码,Go的defer有效解决了这个问题。使用它后,不但代码量减少了很多,而且程序变得更优雅。在defer后指定的函数会在函数退出前调用。

  1. func ReadWrite() bool {
  2. file.Open("file")
  3. defer file.Close()
  4. if failureX {
  5. return false
  6. }
  7. if failureY {
  8. return false
  9. }
  10. return true
  11. }

如果有很多调用defer,那么defer是采用后进先出模式,所以如下代码会输出4 3 2 1 0

  1. for i := 0; i < 5; i++ {
  2. defer fmt.Printf("%d ", i)
  3. }

通常来说,defer会用在释放数据库连接,关闭文件等需要在函数结束时处理的操作。

函数作为值、类型

在Go中函数也是一种变量,可以通过type来定义它,它的类型就是所有拥有相同的参数,相同的返回值的一种类型

  1. type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...])

函数作为类型到底有什么好处呢?那就是可以把这个类型的函数当做值来传递,请看下面的例子

  1. package main
  2. import "fmt"
  3. type testInt func(int) bool // 声明了一个函数类型
  4. func isOdd(integer int) bool {
  5. if integer%2 == 0 {
  6. return false
  7. }
  8. return true
  9. }
  10. func isEven(integer int) bool {
  11. if integer%2 == 0 {
  12. return true
  13. }
  14. return false
  15. }
  16. // 声明的函数类型在这个地方当做了一个参数
  17. func filter(slice []int, f testInt) []int {
  18. var result []int
  19. for _, value := range slice {
  20. if f(value) {
  21. result = append(result, value)
  22. }
  23. }
  24. return result
  25. }
  26. func main(){
  27. slice := []int {1, 2, 3, 4, 5, 7}
  28. fmt.Println("slice = ", slice)
  29. odd := filter(slice, isOdd) // 函数当做值来传递了
  30. fmt.Println("Odd elements of slice are: ", odd)
  31. even := filter(slice, isEven) // 函数当做值来传递了
  32. fmt.Println("Even elements of slice are: ", even)
  33. }

函数当做值和类型在写一些通用接口的时候非常有用,通过上面例子看到testInt这个类型是一个函数类型,然后两个filter函数的参数和返回值与testInt类型是一样的,但是可以实现很多种的逻辑,这样使得程序变得非常的灵活。

Panic和Recover

Go没有像Java那样的异常机制,它不能抛出异常,而是使用了panicrecover机制。一定要记住,应当把它作为最后的手段来使用,也就是说,代码中应当没有,或者很少有panic的东西。这是个强大的工具,请明智地使用它。

Panic

是一个内建函数,可以中断原有的控制流程,进入一个panic状态中。当函数F调用panic,函数F的执行被中断,但是F中的延迟函数会正常执行,然后F返回到调用它的地方。在调用的地方,F的行为就像调用了panic。这一过程继续向上,直到发生panicgoroutine中所有调用的函数返回,此时程序退出。panic可以直接调用panic产生。也可以由运行时错误产生,例如访问越界的数组。

Recover

是一个内建的函数,可以让进入panic状态的goroutine恢复过来。recover仅在延迟函数中有效。在正常的执行过程中,调用recover会返回nil,并且没有其它任何效果。如果当前的goroutine陷入panic状态,调用recover可以捕获到panic的输入值,并且恢复正常的执行。

下面这个函数演示了如何在过程中使用panic

  1. var user = os.Getenv("USER")
  2. func init() {
  3. if user == "" {
  4. panic("no value for $USER")
  5. }
  6. }

下面这个函数检查作为其参数的函数在执行时是否会产生panic

  1. func throwsPanic(f func()) (b bool) {
  2. defer func() {
  3. if x := recover(); x != nil {
  4. b = true
  5. }
  6. }()
  7. f() //执行函数f,如果f中出现了panic,那么就可以恢复回来
  8. return
  9. }

注意:

defer必须在panic语句之前。

recover必须配合defer使用。

main函数和init函数

Go里面有两个保留的函数:init函数(能够应用于所有的package)和main函数(只能应用于package main)。这两个函数在定义时不能有任何的参数和返回值。虽然一个package里面可以写任意多个init函数,但这无论是对于可读性还是以后的可维护性来说,强烈建议用户在一个package中每个文件只写一个init函数。

Go程序会自动调用init()main(),所以不需要在任何地方调用这两个函数。每个package中的init函数都是可选的,但package main就必须包含一个main函数。

程序的初始化和执行都起始于main包。如果main包还导入了其它的包,那么就会在编译时将它们依次导入。有时一个包会被多个包同时导入,那么它只会被导入一次(例如很多包可能都会用到fmt包,但它只会被导入一次,因为没有必要导入多次)。当一个包被导入时,如果该包还导入了其它的包,那么会先将其它包导入进来,然后再对这些包中的包级常量和变量进行初始化,接着执行init函数(如果有的话),依次类推。等所有被导入的包都加载完毕了,就会开始对main包中的包级常量和变量进行初始化,然后执行main包中的init函数(如果存在的话),最后执行main函数。

import

在写Go代码的时候经常用到import这个命令用来导入包文件,经常看到的方式参考如下:

  1. import(
  2. "fmt"
  3. )

然后代码里面可以通过如下的方式调用

  1. fmt.Println("hello world")

上面这个fmt是Go语言的标准库,其实是去GOROOT环境变量指定目录下去加载该模块,当然Go的import还支持如下两种方式来加载自己写的模块:

1、相对路径

  1. import "./model" //当前文件同一目录的model目录,但是不建议这种方式来import

2、绝对路径

  1. import "shorturl/model" //加载gopath/src/shorturl/model模块

上面展示了一些import常用的几种方式,但是还有一些

特殊的import

1、点操作

有时候会看到如下的方式导入包

  1. import(
  2. . "fmt"
  3. )

这个点操作的含义就是这个包导入之后在调用这个包的函数时,可以省略前缀的包名,也就是前面调用的fmt.Println(“hello world”)可以省略的写成Println("hello world")

2、别名操作

别名操作顾名思义可以把包命名成另一个用起来容易记忆的名字

  1. import(
  2. f "fmt"
  3. )

别名操作的话调用包函数时前缀变成了前缀,即f.Println("hello world")

3、_操作

这个操作经常是让很多人费解的一个操作符,请看下面这个import

  1. import (
  2. "database/sql"
  3. _ "github.com/ziutek/mymysql/godrv"
  4. )

_操作其实是引入该包,而不直接使用包里面的函数,而是调用了该包里面的init函数