Dawn's Blogs

分享技术 记录成长

0%

GO语言圣经学习笔记 (4) 函数和异常处理

发表于 更新于 分类于

函数

错误处理

对于那些将运行失败看作是预期结果的函数，它们会返回一个额外的返回值，通常是最后一个，来传递错误信息。

如果导致失败的原因只有一个，额外的返回值可以是一个布尔值，通常被命名为ok

1
2
3
4
5
value, ok := cache.Lookup(key)

if !ok {
	// ...cache[key] does not exist…
}

通常，导致失败的原因不止一种，尤其是对I/O操作而言，用户需要了解更多的错误信息。因此，额外的返回值不再是简单的布尔类型，而是error类型

在Go中，函数运行失败时会返回错误信息，这些错误信息被认为是一种预期的值而非异常（exception），这使得Go有别于那些将函数运行失败看作是异常的语言。

在Go中，错误处理有一套独特的编码风格。检查某个子函数是否失败后，我们通常将处理失败的逻辑代码放在处理成功的代码之前。如果某个错误会导致函数返回，那么成功时的逻辑代码不应放在else语句块中，而应直接放在函数体中。Go中大部分函数的代码结构几乎相同，首先是一系列的初始检查，防止错误发生，之后是函数的实际逻辑

错误处理策略

当一次函数调用返回错误时，调用者有应该选择何时的方式处理错误。根据情况不同，有5种不同的处理策略。

  1. 传播错误，这是最常用的方式。函数中某个子程序的失败，会变成该函数的失败。可以用fmt.Errorf函数重新构造错误信息返回
1
2
3
4
5
resp, err := http.Get(url)
if err != nil{
    // 执行失败，直接返回
	return nil, err
}
  1. 如果错误的发生是偶然性的，或由不可预知的问题导致的。一个明智的选择是重新尝试失败的操作。在重试时，我们需要限制重试的时间间隔或重试的次数，防止无限制的重试。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// WaitForServer attempts to contact the server of a URL.
// It tries for one minute using exponential back-off.
// It reports an error if all attempts fail.
func WaitForServer(url string) error {
	const timeout = 1 * time.Minute
	deadline := time.Now().Add(timeout)
    
	for tries := 0; time.Now().Before(deadline); tries++ {
		_, err := http.Head(url)
		if err == nil {
			return nil // success
		}
		log.Printf("server not responding (%s);retrying…", err)
		time.Sleep(time.Second << uint(tries)) // exponential back-off
	}
    
	return fmt.Errorf("server %s failed to respond after %s", url, timeout)
}
  1. 如果错误发生后，程序无法继续运行，可以输出错误信息并结束程序。需要注意的是，这种策略只应在main中执行。对库函数而言，应仅向上传播错误，除非该错误意味着程序内部包含不一致性，即遇到了bug，才能在库函数中结束程序。
1
2
3
4
5
6
7
// (In function main.)
if err := WaitForServer(url); err != nil {
	fmt.Fprintf(os.Stderr, "Site is down: %v\n", err)
	os.Exit(1)
    // 以上两条等价于
    // log.Fatalf("Site is down: %v\n", err)
}
  1. 我们只需要输出错误信息就足够了，不需要中断程序的运行。我们可以通过log包提供函数或者标准错误流输出错误信息
1
2
3
4
if err := Ping(); err != nil {
	log.Printf("ping failed: %v; networking disabled",err)
    // fmt.Fprintf(os.Stderr, "ping failed: %v; networking disabled\n", err)
}
  1. 直接忽略错误

文件结尾错误

io包保证任何由文件结束引起的读取失败都返回同一个错误——io.EOF，该错误在io包中定义：

1
var EOF = errors.New("EOF")

调用者只需通过简单的比较，就可以检测出这个错误。下面的例子展示了如何从标准输入中读取字符，以及判断文件结束。

1
2
3
4
5
6
7
8
9
10
11
12
in := bufio.NewReader(os.Stdin)
for {
	r, _, err := in.ReadRune()
	if err == io.EOF {
		break // finished reading
	}
	if err != nil {
		return fmt.Errorf("read failed:%v", err)
	}
	// ...use r…
}

因为文件结束这种错误不需要更多的描述，所以io.EOF有固定的错误信息——“EOF”。对于其他错误，我们可能需要在错误信息中描述错误的类型和数量，这使得我们不能像io.EOF一样采用固定的错误信息

函数值

在GO语言中，函数像其他值一样，拥有类型、可以被赋值给其他变量。

函数值属于引用类型

函数类型的零值是nil，函数值是可以和nil进行比较的。但是函数值之间是不可比较的（也就是说，函数值不能作为map的key）

1
2
3
4
var f func(int) int
if f != nil {
	f(3)
}

函数值作为函数的参数可以定义函数的行为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func f(pre, post func()) {
    if pre != nil {
        // 在执行f之前调用pre()
        pre()
    }
    /*
    	中间的函数体
    	.....
    */
    if post != nil {
        // 在执行f之后调用post
        post()
    }
}

匿名函数

拥有函数名的函数只能在包级语法块中被声明，通过函数字面量（function literal），我们可绕过这一限制，在任何表达式中表示一个函数值。函数字面量的语法和函数声明相似，区别在于func关键字后没有函数名。函数值字面量是一种表达式，它的值被成为匿名函数

更为重要的是，通过这种方式定义的函数可以访问完整的词法环境（lexical environment），这意味着在函数中定义的内部函数可以引用该函数的变量：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// squares返回一个匿名函数。
// 该匿名函数每次被调用时都会返回下一个数的平方。
func squares() func() int {
	var x int
	return func() int {
		x++
		return x * x
	}
}

func main() {
	f := squares()
	fmt.Println(f()) // "1"
	fmt.Println(f()) // "4"
	fmt.Println(f()) // "9"
	fmt.Println(f()) // "16"
}

squares的例子证明，函数值不仅仅是一串代码，还记录了状态。在squares中定义的匿名内部函数可以访问和更新squares中的局部变量，这意味着匿名函数和squares中，存在变量引用。这就是函数值属于引用类型和函数值不可比较的原因。

同时，这个例子说明了，变量的生命周期不由它的作用域决定：squares返回后，变量x仍然隐式的存在于f中。

当匿名函数需要被递归调用时，我们必须首先声明一个变量，再将匿名函数赋值给这个变量：

1
2
3
4
5
6
7
8
var preorder func(root *TreeNode)
preorder = func(root *TreeNode) {	// 二叉树的前序遍历
    if root != nil {
        visit(root)
        preorder(root.Left)
        preorder(root.Right)
    }
}

可变参数

在声明可变参数函数时，需要在参数列表的最后一个参数类型之前加上省略符号“…”，这表示该函数会接收任意数量的该类型参数：

1
2
3
4
5
6
7
8
9
10
11
func sum(vals...int) int {
	total := 0
	for _, val := range vals {
		total += val
	}
	return total
}

fmt.Println(sum()) 				// "0"
fmt.Println(sum(3))				// "3"
fmt.Println(sum(1, 2, 3, 4))	// "10"

调用者隐式的创建一个数组，并将原始参数复制到数组中，再把数组的一个切片作为参数传给被调函数。如果原始参数已经是切片类型，只需在最后一个参数后加上省略符

1
2
values := []int{1, 2, 3, 4}
fmt.Println(sum(values...)) // "10"

虽然在可变参数函数内部，...int 型参数的行为看起来很像切片类型，但实际上，可变参数函数和以切片作为参数的函数是不同的

1
2
3
4
func f(...int) {}
func g([]int) {}
fmt.Printf("%T\n", f)	// "func(...int)"
fmt.Printf("%T\n", g)	// "func([]int)"

defer语句

当defer语句被执行时，跟在defer后面的函数会被延迟执行。直到包含该defer语句的函数执行完毕时，defer后的函数才会被执行，不论包含defer语句的函数是通过return正常结束，还是由于panic导致的异常结束。你可以在一个函数中执行多条defer语句，它们的执行顺序与声明顺序相反。

释放资源

defer语句经常被用于处理成对的操作，如打开、关闭、连接、断开连接、加锁、释放锁。通过defer机制，不论函数逻辑多复杂，都能保证在任何执行路径下，资源被释放。释放资源的defer应该直接跟在请求资源的语句后。如文件操作：

1
2
3
4
5
6
7
8
func ReadFile(filename string) ([]byte, error) {
	f, err := os.Open(filename)
    defer f.Close()
	if err != nil {
		return nil, err
	}
	return ReadAll(f)
}

记录何时进入、退出函数

调试复杂程序时，defer机制也常被用于记录何时进入和退出函数。下面的例子中，bigSlowOperation函数开始时会执行trace函数，当bigSlowOperation退出前会执行trace返回的函数。只需要一条语句，就可以控制住函数的入口和出口：

1
2
3
4
5
6
7
8
9
10
11
12
13
func bigSlowOperation() {
	defer trace("bigSlowOperation")() // don't forget the extra parentheses
	// ...lots of work…
	time.Sleep(10 * time.Second) // simulate slow operation by sleeping
}

func trace(msg string) func() {
	start := time.Now()
	log.Printf("enter %s", msg)
	return func() {
		log.Printf("exit %s (%s)", msg,time.Since(start))
	}
}

观察、修改返回值

defer语句中的函数会在return语句更新返回值变量后再执行，又因为在函数中定义的匿名函数可以访问该函数包括返回值变量在内的所有变量，所以，对匿名函数采用defer机制，可以使其观察函数的返回值：

1
2
3
4
5
6
7
8
func double(x int) (result int) {
	defer func() { fmt.Printf("double(%d) = %d\n", x,result) }()
	return x + x
}

_ = double(4)
// Output:
// "double(4) = 8"

被延迟执行的匿名函数甚至可以修改函数返回给调用者的返回值：

1
2
3
4
5
func triple(x int) (result int) {
	defer func() { result += x }()
	return double(x)
}
fmt.Println(triple(4)) // "12"

异常处理

panic异常

当panic异常发生时，程序会中断运行，并立即执行在该goroutine中被延迟的函数（defer 机制）。随后，程序崩溃并输出日志信息。日志信息包括panic value和函数调用的堆栈跟踪信息。

panic异常和其他语言异常的不同：

虽然Go的panic机制类似于其他语言的异常，但panic的适用场景有一些不同。由于panic会引起程序的崩溃，因此panic一般用于严重错误，如程序内部的逻辑不一致。

对于大部分漏洞，我们应该使用Go提供的错误机制，而不是panic，尽量避免程序的崩溃。在健壮的程序中，任何可以预料到的错误，如不正确的输入、错误的配置或是失败的I/O操作都应该被优雅的处理，最好的处理方式，就是使用Go的错误机制，即返回一个额外的返回值，通常是最后一个，来传递错误信息

recover捕获异常

通常来说，不应该对panic异常做任何处理，但有时，也许我们可以从异常中恢复，至少我们可以在程序崩溃前，做一些操作。举个例子，当web服务器遇到不可预料的严重问题时，在崩溃前应该将所有的连接关闭；如果不做任何处理，会使得客户端一直处于等待状态。

如果在deferred函数中调用了内置函数recover，并且定义该defer语句的函数发生了panic异常，recover会使程序从panic中恢复，并返回panic value。导致panic异常的函数不会继续运行，但能正常返回。在未发生panic时调用recover，recover会返回nil。

1
2
3
4
5
6
7
8
func Parse(input string) (s *Syntax, err error) {
	defer func() {
		if p := recover(); p != nil {
			err = fmt.Errorf("internal error: %v", p)
		}
	}()
	// ...parser...
}

应该有选择性的recover。换句话说，只恢复应该被恢复的panic异常。为了标识某个panic是否应该被恢复，我们可以将panic value设置成特殊类型。在recover时对panic value进行检查，如果发现panic value是特殊类型，就将这个panic作为error处理，如果不是，则按照正常的panic进行处理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func f() (res string, err error) {
    type someKindError struct{}
    defer func(){
        switch p := recover(); p {
            case nil:	//	no panic
            case someKindError{}:	// expected panic
            	err = fmt.Errorf("Take place someKindError.....")
            default:
            	panic(p)	// unexpected panic
        }
    }()
    // 其他工作
    // ....
    if 某种类型的异常发生了{
        panic(someKindError{})
    }
}