Go 语言中的异常处理简单实践 panic、recover【GO 基础】

〇、Go 中的异常处理简介

Golang 没有结构化异常,使用 panic 抛出错误,recover 捕获错误

panic、recover 参数类型为 interface{},因此可抛出任何类型对象。

func panic(v interface{})
func recover() interface{}

处理流程:方法体重抛出一个 panic 的异常,然后在 defer 中通过 recover 捕获这个异常,然后正常处理。

关于 panic:

  触发运行时错误:panic 用于立即停止当前函数的执行,并开始回溯调用栈直到程序终止或遇到 recover。
  传递错误信息:panic 可以接受任何类型的参数,通常传递字符串或错误接口实例,方便错误信息的传递和处理。
  易错点:随意使用 panic 处理非严重错误是不推荐的,其主要用于处理不可恢复的运行时错误,对于可处理的错误,应通过返回错误值的方式传递给调用者。

关于 recover:

  捕获 panic:recover 只能在 defer 语句中调用,用于捕获当前 goroutine 发生的 panic,如果没有 panic 发生,则返回 nil。
  recover 处理异常后:逻辑并不会恢复到 panic 那个点去,函数跑到 defer 之后的那个点。
  易错点:recover 只能捕获同一 goroutine 内发生的 panic,对于其他 goroutine 引发的 panic 无能为力。

Go 语言推荐使用错误返回码而非异常机制来处理错误,通过 error 接口返回错误信息,这是一种更灵活且不会破坏程序执行流程的方法。在实际开发中,建议优先使用错误处理机制,谨慎使用 panic 和 recover,以编写出更加稳定和高效的 Go 程序。

一、异常捕获简单测试

1.1 简单的捕获 panic

如下代码,直接触发 panic,在 defer 中通过 recover 捕获,并转换成 string 输出:

package main

func main() {
	test()
}

func test() {
	defer func() {
		if err := recover(); err != nil {
			println("输出:", err.(string)) // 将 interface{} 转型为具体类型 string
			// 输出: panic error!
		}
	}()
	panic("panic error!")
}

再来个示例,往已关闭的通道中发送数据,会引发异常:

package main

import (
	"fmt"
)

func main() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err) // 输出:send on closed channel
		}
	}()

	var ch chan int = make(chan int, 10)
	close(ch) // 关闭通道
	ch <- 1   // 继续往通道中发送值,就会引发异常
}

1.2 多个异常时 recover 如何捕获?

延迟调用中引发的错误,可被后续延迟调用捕获,但仅最后一个错误可被捕获。

如下代码,只有 defer 中的 panic 会被捕获,另一个异常将会漏掉:

package main

import "fmt"

func test() {
	defer func() {
		fmt.Println(recover())
	}()
	defer func() {
		panic("defer panic")
	}()
	panic("test panic")
}

func main() {
	test()
}
// 输出:
// defer panic

因此,需要再第二个 defer 中针对 test panic 进行处理。

1.3 一个异常在多层 defer 如何捕获?

捕获函数 recover 只有在延迟调用内直接调用才会终止错误,否则总是返回 nil。任何未捕获的错误都会沿调用堆栈向外传递。

如下代码,在第一层进行了延迟调用,然后第〇层就未获取到 panic:

package main

import "fmt"

func test() {
	defer func() {
		fmt.Println("第〇层:", recover()) // 无效
	}()
	defer func() {
		fmt.Println("第一层:", recover()) // 有效
	}()
	defer fmt.Println("第二层:", recover()) // 无效!
	defer fmt.Println("第三层:", recover()) // 无效!
	defer func() {
		func() {
			println("第四层:defer inner")
			fmt.Println("第四层:", recover()) // 无效!
		}()
	}()
	panic("test panic")
}

func main() {
	test()
}
// 输出:
// 第四层:defer inner
// 第四层: <nil>
// 第三层: <nil>
// 第二层: <nil>
// 第一层: test panic
// 第〇层: <nil>

1.4 通过 error 类型的错误对象来表示函数调用状态

除用 panic 引发中断性错误外,还可返回 error 类型错误对象来表示函数调用状态。

type error interface {
    Error() string
}

标准库 errors.New 和 fmt.Errorf 函数用于创建实现 error 接口的错误对象。通过判断错误对象实例来确定具体错误类型。

package main

import (
	"errors"
	"fmt"
)

var ErrDivByZero = errors.New("division by zero") // 定义错误类型 ErrDivByZero

func div(x, y int) (int, error) {
	if y == 0 {
		return 0, ErrDivByZero
	}
	return x / y, nil
}

func main() {
	defer func() {
		fmt.Println(recover()) // 捕获 panic,无 panic 就打印 <nil>
	}()
	switch z, err := div(10, 0); err { // div(10, 0) 返回 ErrDivByZero
	case nil:
		println(z)
	case ErrDivByZero: // 触发 panic
		panic(err)
	}
}

// 输出:
// division by zero

1.5 通过将代码块重构成匿名函数来实现 try-catch 的效果

将代码块重构成匿名函数,并包含异常处理,如此可确保后续代码被执行

如下代码,当被除数为 0 时会报错,在匿名函数中被捕获并记录,然后不影响正常输出:

package main

import "fmt"

func test(x, y int) {
	var z int
	func() {
		defer func() {
			if err := recover(); err != nil {
				fmt.Println("err:", err)
				z = 0
			}
		}()
		z = x / y
	}()
	fmt.Printf("x / y = %d\n", z)
}

func main() {
	test(2, 0)
}
// 输出:
// err: runtime error: integer divide by zero
// x / y = 0

1.6 实现类似 try-catch 的异常处理

package main

import "fmt"

func Try(fun func(), handler func(interface{})) {
	defer func() {
		if err := recover(); err != nil {
			handler(err) // 捕获异常后,执行异常处理逻辑
		}
	}()
	fun() // 直接执行处理逻辑
}

func main() {
	Try(
		func() {
			// 程序处理逻辑。。。
			panic("test panic") // 抛出异常
		},
		func(err interface{}) {
			// 异常处理逻辑。。。
			fmt.Println(err)
		},
	)
}

参考:http://www.topgoer.com/%E5%87%BD%E6%95%B0/%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86.html

posted @ 2024-06-14 16:45  橙子家  阅读(759)  评论(0编辑  收藏  举报