與其他主流語言如 Javascript、Java 和 Python 相比，Golang 的錯誤處理方式可能和這些你熟悉的語言有所不同。所以才有了這個想法根大家聊一聊 golang 的錯誤處理方式，以及實際開發(fā)中應(yīng)該如何對錯誤進行處理。因為分享面對 Golang有一個基本的了解 developers, 所以一些簡單地方就不做贅述了。

如何定義錯誤

在 golang 語言中，無論是在類型檢查還是編譯過程中，都是將錯誤看做值來對待，和 string 或者 integer 這些類型值并不差別。聲明一個 string 類型變量和聲明一個 error 類型變量是沒什么區(qū)別的。

你可以定義接口作為 error 的類型，有關(guān) error 能夠提供什么樣信息都是由自己決定的，這是 error 在 golang 作為值的好處，不過這樣做也自然有其壞處，有關(guān) error 定義好壞就全由其定義開發(fā)人員所決定，也就是有關(guān) error 融入過多人為的主觀因素。

package main

import (
	"fmt"
	"io/ioutil"
)

func main(){
	dir, err := ioutil.TempDir("","temp")

	if err != nil{
		fmt.Errorf("failed to create temp dir: %v",err)
	}
}

錯誤在語言中的重點地位

在 Go 語言中錯誤處理設(shè)計一直大家喜歡討論的內(nèi)容，錯誤處理是該語言的核心，但該語言并沒有規(guī)定如何處理錯誤。社區(qū)已經(jīng)為改進和規(guī)范錯誤處理做出了努力，但許多人忽略了錯誤在我們應(yīng)用程序領(lǐng)域中的核心地位。也就是說，錯誤與客戶和訂單類型一樣重要。

Golang中的錯誤

錯誤表示在應(yīng)用程序中發(fā)生了不需要的情況。比方說，想創(chuàng)建一個臨時目錄，在那里可以為應(yīng)用程序存儲一些文件，但這個目錄的創(chuàng)建失敗了。這是一個不期望的情況，就可以用錯誤來表示。

通過創(chuàng)建自定義錯誤可以將更豐富錯誤信息傳遞給調(diào)用者。個返回值返回將錯誤交給調(diào)用函數(shù)人來處理錯誤。Golang 本身允許函數(shù)具有多個返回值，所以通常把錯誤作為函數(shù)最后一個參數(shù)返回給調(diào)用者來處理。

errors 是 I/O

• 有時候開發(fā)人員是 error 的生產(chǎn)者(寫 error)
• 有時候開發(fā)人員又是 error 的消費者(讀 error)
  

也就是我們開發(fā)程序一部分工作是讀取和寫入 error

errors 的上下文
什么是 error 的上下文呢? 如何定義 error 需要考慮一些因素，例如在不同程序我們定義 error 和處理 error 方式也不僅相同

1. CLI 工具
2. 庫
3. 長時間運行的系統(tǒng)

而且我們需要考慮使用程序的人群，他們是什么方式來使用系統(tǒng)，這些因素都是我們設(shè)計也好定義錯誤信息要考慮的因素。

錯誤的類型

就錯誤核心，那么錯誤可能是我們預(yù)料之中的錯誤，錯誤也可能是我們沒有考慮到，例如無效內(nèi)存，數(shù)組越界，也就是單靠代碼自身暫時是解決不了的錯誤 ，這樣的誤差往往讓代碼恐慌，所以 Panic。通常這樣錯誤對于程序是災(zāi)難性的失敗，無法修復(fù)的。

自定義錯誤

如前所述，錯誤使用內(nèi)置的錯誤接口類型來表示，其定義如下。

type error interface {  
    Error() string
}

下面舉了 2 例子來定義 error ，分別定義兩個 struct 都實現(xiàn)了 Error() 接口即可

type SyntaxError struct {
    Line int
    Col  int
}

func (e *SyntaxError) Error() string {
    return fmt.Sprintf("%d:%d: syntax error", e.Line, e.Col)
}

type InternalError struct {
    Path string
}

func (e *InternalError) Error() string {
    return fmt.Sprintf("parse %v: internal error", e.Path)
}

該接口包含一個方法 Error() ，以字符串形式返回錯誤信息。每一個實現(xiàn)了錯誤接口的類型都可以作為一個錯誤使用。當(dāng)使用 fmt.Println 等方法打印錯誤時，Golang 會自動調(diào)用 Error() 方法。

在 Golang 中，有多種創(chuàng)建自定義錯誤信息的方法，每一種都有自己的優(yōu)點和缺點。

基于字符串的錯誤

基于字符串的錯誤可以用 Golang 中兩個開箱即用方法來自定義錯誤，適用哪些僅返回描述錯誤信息的相對來說比較簡單的錯誤。

err := errors.New("math: divided by zero")

將錯誤信息傳入到 errors.New() 方法可以用來新建一個錯誤

err2 := fmt.Errorf("math: %g cannot be divided by zero", x)

fmt.Errorf 通過字符串格式方式，可以將錯誤信息包含你錯誤信息中。也就是為錯誤信息添加了一些格式化的功能。

自定義數(shù)據(jù)結(jié)構(gòu)的錯誤

可以通過在你的結(jié)構(gòu)上實現(xiàn) Error 接口中定義的 Error() 函數(shù)來創(chuàng)建自定義的錯誤類型。下面是一個例子。

Defer, panic 和 recover

Go 并不像許多其他編程語言（包括 Java 和 Javascript ）那樣有異常，但有一個類似的機制，即 "Defer, panic 和 recover"。然而，panic 和 recover 的使用情況與其他編程語言中的異常非常不同，因為代碼本身無法應(yīng)對時候和不可恢復(fù)的情況下使用。

Defer

有點類似析構(gòu)函數(shù)，在函數(shù)執(zhí)行完畢后做一些資源釋放等收尾工作，好處其執(zhí)行和其在代碼中位置并沒有關(guān)系，所以可以將其寫在你讀寫資源語句后面，以免隨后忘記做一些資源釋放的工作。關(guān)于 defer 輸出也是面試時，面試官喜歡問的一個問題。

package main

import(
	"fmt"
	"os"
)

func main(){
	f := createFile("tmp/machinelearning.txt")
	defer closeFile(f)
	writeFile(f)
}

func createFile(p string) *os.File {
	fmt.Println("creating")
	f, err := os.Create(p)
	if err != nil{
		panic(err)
	}
	return f
}

func closeFile(f *os.File){
	fmt.Println("closing")
	err := f.Close()

	if err != nil{
		fmt.Fprintf(os.Stderr, "error:%v\n",err)
		os.Exit(1)
	}
}

func writeFile(f *os.File){
	fmt.Println("writing")
	fmt.Fprintln(f,"machine leanring")
}

defer 語句會將函數(shù)推入到一個棧結(jié)構(gòu)中。同時棧結(jié)構(gòu)中的函數(shù)會在 return 語句執(zhí)行后被調(diào)用。

package main


import "fmt"

func main(){
	// defer fmt.Println("word")
	// fmt.Println("hello")

	fmt.Println("hello")
	for i := 0; i <=3; i++ {
		defer fmt.Println(i)
	}
	fmt.Println("world")
}

hello
world
3
2
1
0

可以通過在你的結(jié)構(gòu)上實現(xiàn) Error 接口中定義的 Error() 函數(shù)來實現(xiàn)自定義錯誤類型，下面是一個例子。

Panic

panic 語句向 Golang 發(fā)出信號，這時通常是代碼無法解決當(dāng)前的問題，所以停止代碼的正常執(zhí)行流程。一旦調(diào)用了 panic，所有的延遲函數(shù)都會被執(zhí)行，并且程序會崩潰，其日志信息包括 panic 值（通常是錯誤信息）和堆棧跟蹤。

舉個例子，當(dāng)一個數(shù)字被除以0時，Golang會出現(xiàn) panic。

package main

import "fmt"

func main(){
	divide(5)
}

func divide(x int){
	fmt.Printf("divide(%d)\n",x+0/x)
	divide(x-1)
}

divide(5)
divide(4)
divide(3)
divide(2)
divide(1)
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.divide(0x0)
        /Users/zidea2020/Desktop/mysite/go_tut/main.go:10 +0xdb
main.divide(0x1)
        /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc
main.divide(0x2)
        /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc
main.divide(0x3)
        /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc
main.divide(0x4)
        /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc
main.divide(0x5)
        /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc
main.main()
        /Users/zidea2020/Desktop/mysite/go_tut/main.go:6 +0x2a
exit status 2

Recover

Go語言提供了recover內(nèi)置函數(shù)，前面提到，一旦panic，邏輯就會走到defer那，那我們就在defer那等著，調(diào)用recover函數(shù)將會捕獲到當(dāng)前的panic，被捕獲到的panic就不會向上傳遞了。然后，恢復(fù)將結(jié)束當(dāng)前的 Panic 狀態(tài)，并返回 Panic 的錯誤值。

package main

import "fmt"

func main(){
	accessSlice([]int{1,2,5,6,7,8}, 0)
}

func accessSlice(slice []int, index int) {
	defer func() {
		if p := recover(); p != nil {
			fmt.Printf("internal error: %v", p)
		}
	}()

	fmt.Printf("item %d, value %d \n", index, slice[index])
	defer fmt.Printf("defer %d \n", index)
	accessSlice(slice, index+1)
}

包裝錯誤

Golang 也允許對錯誤進行包裹，通過錯誤嵌套，在原有錯誤信息上添加一個額外信息幫助調(diào)用者對問題判斷以及后續(xù)應(yīng)該如何處理信息。以通過使用 %w 標(biāo)志和 fmt.Errorf 函數(shù)來對原有的錯誤進行保存提供一些特定的信息，如下例所示。

package main

import (
	"errors"
	"fmt"
	"os"
)

func main() {
	err := openFile("non-existing")

	if err != nil {
		fmt.Printf("error running program: %s \n", err.Error())
	}
}

func openFile(filename string) error {
	if _, err := os.Open(filename); err != nil {
		return fmt.Errorf("error opening %s: %w", filename, err)
	}

	return nil
}

上面已經(jīng)通過代碼演示如何包裝一個錯誤，程序會打印輸出使用 fmt.Errorf 添加文件名的包裝過的錯誤，也打印了傳遞給 %w 標(biāo)志的原有錯誤信息。這里再補充一個 Golang 還提供的功能，通過使用 error.Unwrap 來還原錯誤信息，從而獲得原有的錯誤信息。

package main

import (
	"errors"
	"fmt"
	"os"
)

func main() {
	err := openFile("non-existing")

	if err != nil {
		fmt.Printf("error running program: %s \n", err.Error())

		// Unwrap error
		unwrappedErr := errors.Unwrap(err)
		fmt.Printf("unwrapped error: %v \n", unwrappedErr)
	}
}

func openFile(filename string) error {
	if _, err := os.Open(filename); err != nil {
		return fmt.Errorf("error opening %s: %w", filename, err)
	}

	return nil
}

錯誤的類型轉(zhuǎn)換

有時候需要在不同的錯誤類型之間進行轉(zhuǎn)換，有情況需要通過類型轉(zhuǎn)換來為錯誤添加信息，或者換一種表達方式，。 errors.As 函數(shù)提供了一個簡單而安全的方法，通過尋找錯誤鏈中匹配錯誤類型進行轉(zhuǎn)化輸出。如果沒有找到匹配的，該函數(shù)返回 false 。

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
)

func main(){
	// Casting error
	if _, err := os.Open("non-existing"); err != nil {
		var pathError *os.PathError
		if errors.As(err, &pathError) {
			fmt.Println("Failed at path:", pathError.Path)
		} else {
			fmt.Println(err)
		}
	}
}

在這里，試圖將通用錯誤類型轉(zhuǎn)換為 os.PathError ，這樣就可以訪問該特定的錯誤信息，這些信息保存在結(jié)構(gòu)體中的 Path 屬性上。

錯誤類型檢查

Golang 提供了 errors.Is 函數(shù)來用于檢查錯誤類型是否為指定的錯誤類型，該函數(shù)返回一個布爾值值來表示是否為指定錯誤類型。

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
)

func main(){
	// Check if error is a specific type
	if _, err := os.Open("non-existing"); err != nil {
		if errors.Is(err, fs.ErrNotExist) {
			fmt.Println("file does not exist")
		} else {
			fmt.Println(err)
		}
	}
}

到此這篇關(guān)于golang 語言中錯誤處理機制的文章就介紹到這了,更多相關(guān)golang 錯誤處理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論