Detaillierte Einführung in den Fehlerbehandlungsmechanismus in Golang

Grundlagen

Fehlerbehandlung sollte Teil des Projekts sein: interface

type error interface {
	Error() string
}

Jede Struktur, die die

-Methode implementiert, kann als Fehler behandelt werden. Wenn in der Funktion möglicherweise ein Fehler auftritt, können Sie daher am Ende des Rückgabewerts einen Fehler zurückgeben, z. B.: Error()

func foo() error {
	// ... do something
	return errors.New("foo error")
}

Den Fehler direkt zurückgeben

Geben Sie den Fehler direkt zurück, ähnlich wie direkt. Gibt einen Fehler vom Typ String oder einen Fehlercode oder ähnliches zurück. Fehler beim String-Typ wurden im Abschnitt „Grundlagen“ erwähnt. Der Fehlercode entspricht dem Fehlercode in der Linux- und C-Programmierung. Im Allgemeinen müssen wir ihn selbst definieren. Zum Beispiel:

package mypkg

type ErrCode int

const (
	ERR1 = 1
	ERR2 = 2
	ERR3 = 3
)

func sub(a, b int) (int, ErrCode) {
	if b < 0 {
		return 0, ERR1
	} else if a < b {
		return 0, Err2
	} else if a < 0 {
		return 0, Err3
	}
	return a - b
}

Dieser Fehlertyp ist einfach zu schreiben, weist jedoch zwei Mängel auf:

1. Wenn Sie Fehlercodes in der äußeren Ebene verwenden möchten, müssen Sie diesen einführen Paket, was einfach ist. Es entsteht ein Zirkelverweis.

2. Wenn der zurückgegebene Fehlercodetyp intern im Paket geändert wird, müssen entsprechende Änderungen überall dort vorgenommen werden, wo der Fehlercode extern verwendet wird, wodurch der Abschluss zerstört wird.

Für den ersten Fehler können Sie ein Drittanbieterpaket verwenden, um Fehlercodes gezielt zu speichern. Diese Methode ist eine Diskussion wert. Beurteilen Sie niemals den Wert der von der Error()-Methode zurückgegebenen Zeichenfolge, um den entsprechenden Fehler zu behandeln! ! !

Einen benutzerdefinierten Fehlertyp zurückgeben

Diese Methode kann einen benutzerdefinierten Typ zurückgeben und eine zugehörige Fehlerbehandlung durchführen, indem sie den benutzerdefinierten Typ bestätigt. Sie kann weitere Informationen enthalten. Codebeispiel:

package main

import (
	"errors"
	"fmt"
	"runtime/debug"
)

type MyError struct {
	Inner      error                  // 内粗错误
	Message    string                 // 自定义错误信息
	StackTrace string                 // 堆栈信息
	Misc       map[string]interface{} //其它的一些数据
}

func (myError MyError) Error() string {
	return myError.Message
}

func wrapError(err error, msg string, msgArgs ...interface{}) MyError {
	return MyError{
		Inner:      err,
		Message:    fmt.Sprintf(msg, msgArgs),
		StackTrace: string(debug.Stack()),
		Misc:       make(map[string]interface{}),
	}
}

func Handle(key int) error {
	if key < 0 {
		return wrapError(errors.New("key < 0"), "This is an error test")
	}
	return nil
}

func main() {
	if err := Handle(-1); err != nil {
		if e, ok := err.(MyError); ok {
			fmt.Printf("Inner: %v, Message: %v, StackTrace: %v\n",
				e.Inner, e.Message, e.StackTrace)  // 这里输出对应的数据
		}
	}
}

Diese Art der Problembehandlung ist bequemer, es können jedoch immer noch Probleme mit Paketzirkelverweisen auftreten.

Fehlerbehandlung, die interne Details verbirgt

Die beiden oben genannten Methoden können an einige Szenarien angepasst werden, aber keine von beiden kann das Problem möglicher zirkulärer Abhängigkeiten lösen. Zu diesem Zweck verwenden wir das Paket

, um das Problem zu lösen und ein Codebeispiel zu geben. github.com/pkg/errors

func New(message string) error

Wenn ein vorgefertigter Fehler vorliegt, müssen wir ihn erneut verpacken. Zu diesem Zeitpunkt stehen drei Funktionen zur Auswahl.

//只附加新的信息
func WithMessage(err error, message string) error
//只附加调用堆栈信息
func WithStack(err error) error
//同时附加堆栈和信息
func Wrap(err error, message string) error

Tatsächlich ist die obige Verpackung der Ausnahmeverpackung von Java sehr ähnlich. Ursache Die Hauptursache für den im vorherigen Kapitel erwähnten Fehler ist diese Ursache. Diese Fehlerbehandlungsbibliothek stellt uns also die Cause-Funktion zur Verfügung, damit wir die grundlegendste Ursache des Fehlers ermitteln können.

func Cause(err error) error {
	type causer interface {
		Cause() error
	}

	for err != nil {
		cause, ok := err.(causer)
		if !ok {
			break
		}
		err = cause.Cause()
	}
	return err
}

Verwenden Sie eine for-Schleife, um den grundlegendsten Fehler (auf der untersten Ebene) zu finden.

Empfohlene verwandte Artikel und Tutorials:

Golang-Tutorial

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in den Fehlerbehandlungsmechanismus in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!