Go 语言函数

函数是 Go 里面的基本代码块，Go 函数的功能非常强大，以至于被认为拥有函数式编程语言的多种特性。由于函数内容较多，这里将会分为多个章节去讲解：

defer 和追踪

关键字 defer 允许我们在函数返回之前（或 return 语句之后）才执行某个语句或函数。

关键字 defer 的用法类似于面向对象编程语言 Java 和 C# 的 finally 语句块，它一般用于释放某些已分配的资源。

示例 defer.go：

package main
import "fmt"
func main() {
    function1()
}
func function1() {
    fmt.Printf("In function1 at the top\n")
    defer function2()
    fmt.Printf("In function1 at the bottom!\n")
}
func function2() {
    fmt.Printf("Function2: Deferred until the end of the calling function!")
}

运行一下

输出：

In Function1 at the top
In Function1 at the bottom!
Function2: Deferred until the end of the calling function!

你可以将 defer 关键字去掉后，再对比输出结果有什么不痛。

使用 defer 的语句同样可以接受参数，下面这个例子就会在执行 defer 语句时打印 0：

func a() {
    i := 0
    defer fmt.Println(i)
    i++
    return
}

当函数内存在多个 defer 关键字时，它们会以逆序执行（类似栈，后进先出）：

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

上面的代码将会输出：4 3 2 1 0。

关键字 defer 允许我们进行一些函数执行完成后的收尾工作，例如：

1、关闭文件流

// open a file
defer file.Close()

2、解锁一个加锁的资源

mu.Lock()
defer mu.Unlock()

3、打印最终报告

printHeader()
defer printFooter()

4、关闭数据库链接

// open a database connection
defer disconnectFromDB()

合理使用 defer 语句能够使代码更加简洁。

以下代码模拟了上面描述的第 4 种情况（关闭数据库链接）：

package main
import "fmt"
func main() {
    doDBOperations()
}
func connectToDB() {
    fmt.Println("ok, connected to db")
}
func disconnectFromDB() {
    fmt.Println("ok, disconnected from db")
}
func doDBOperations() {
    connectToDB()
    fmt.Println("Defering the database disconnect.")
    defer disconnectFromDB() //function called here with defer
    fmt.Println("Doing some DB operations ...")
    fmt.Println("Oops! some crash or network error ...")
    fmt.Println("Returning from function here!")
    return //terminate the program
    // deferred function executed here just before actually returning, even if
    // there is a return or abnormal termination before
}

运行一下

输出：

ok, connected to db
Defering the database disconnect.
Doing some DB operations ...
Oops! some crash or network error ...
Returning from function here!
ok, disconnected from db

使用 defer 语句实现代码追踪

一个基础但十分实用的实现代码执行追踪的方案，在进入和离开某个函数时打印相关的消息，可以提炼为下面两个函数：

func trace(s string) { fmt.Println("entering:", s) }
func untrace(s string) { fmt.Println("leaving:", s) }

以下代码展示了何时调用这两个函数：

package main
import "fmt"
func trace(s string)   { fmt.Println("entering:", s) }
func untrace(s string) { fmt.Println("leaving:", s) }
func a() {
    trace("a")
    defer untrace("a")
    fmt.Println("in a")
}
func b() {
    trace("b")
    defer untrace("b")
    fmt.Println("in b")
    a()
}
func main() {
    b()
}

运行一下

输出：

entering: b
in b
entering: a
in a
leaving: a
leaving: b

上面的代码还可以修改为更加简便的版本：

package main
import "fmt"
func trace(s string) string {
    fmt.Println("entering:", s)
    return s
}
func un(s string) {
    fmt.Println("leaving:", s)
}
func a() {
    defer un(trace("a"))
    fmt.Println("in a")
}
func b() {
    defer un(trace("b"))
    fmt.Println("in b")
    a()
}
func main() {
    b()
}

运行一下

使用 defer 语句来记录函数的参数与返回值

下面的代码展示了另一种在调试时使用 defer 语句的写法：

package main
import (
    "io"
    "log"
)
func func1(s string) (n int, err error) {
    defer func() {
        log.Printf("func1(%q) = %d, %v", s, n, err)
    }()
    return 7, io.EOF
}
func main() {
    func1("Go")
}

运行一下

输出：

Output: 2011/10/04 10:46:11 func1("Go") = 7, EOF

Go 语言函数

defer 和追踪

使用 defer 语句实现代码追踪

使用 defer 语句来记录函数的参数与返回值

分类导航