Gehen Sie für Strategien zur Handhabungs- und Verpackungsstrategien für Fehlerhandel.

In Go -Projekten besteht der Schlüssel zur effizienten Fehlerbehandlung darin, Fehlertypen und Fehlerverpackungen anzupassen. 1. Benutzerdefinierte Fehlertypen werden verwendet, um das Fehlerverhalten zu unterscheiden, den Kontext zu führen und eine spezifische Verarbeitung durchzuführen, z. 2. Fehlerverpackung verbirgt den zugrunde liegenden Fehler im oberen Fehler im %W -Format und behält die ursprünglichen Informationen bei, um den Anrufer zu erleichtern, Fehler zu verwenden. 3. Eine angemessene Gestaltung der Fehlerhierarchiestruktur kann die Wartbarkeit des Codes verbessern. Es wird empfohlen, Apperror als oberste Schicht und Untertypen wie Dberror, NetworkError usw. Zu verwenden. 4. Fehlerinformationen sollten präzise und klar sein, vermeiden Sie redundante Beschreibungen und kombinieren Sie %w, um die zugrunde liegenden Fehler zu wickeln, um Klarheit und Praktikabilität aufrechtzuerhalten.

In Go -Projekten ist die Fehlerbehandlung ein wichtiger Link in der Codequalität. Viele Menschen sind es gewohnt, if err != nil Anpassete Fehler und Verpackungen können Ihr Programm erleichtern, das Debuggen, Wartung und Auswechseln zu erleichtern.

Warum müssen Sie den Fehlertyp anpassen?

Die Standardbibliothek von GO verwendet viele error , aber die errors.New oder fmt.Errorf liefert häufig nicht genügend Informationen. Benutzerdefinierte Fehlertypen sind nützlich, wenn Sie Fehlertypen unterscheiden, den Kontext tragen oder eine spezifische Verarbeitung durchführen müssen.

Zum Beispiel können Sie einen HTTPError definieren:

 Geben Sie httperror struct {ein
    Code int
    Nachrichtenzeichenfolge
}

func (e *httTerRor) error () String {
    Return E.Message
}

Auf diese Weise können Sie bei der Verarbeitung von HTTP -Anforderungen den Fehlertyp durch Typbehandlung bestimmen:

 wenn httperr, ok: = err. (*httperror); OK {
    // Gibt den spezifischen Statuscode W.WriteHeader (httperr.code) zurück
}

Anregung :

• Passen Sie den Typ nur an, wenn Sie zwischen falschen Verhaltensweisen unterscheiden müssen
• Das Implementieren Error() ist erforderlich
• Die Fehlerstruktur sollte so leicht wie möglich sein und nicht zu viele Felder anschließen

Wie mache ich Fehler mit Fehler?

GO 1.13 führt das %w -Format ein, um den Fehler zu wickeln, sodass Sie den zugrunde liegenden Fehler im oberen Fehler "ausblenden" können, während Sie die ursprüngliche Fehlermeldung beibehalten. Dies ist sehr nützlich, wenn Sie Zwischenschichtdienste oder Kapselungsbibliotheken erstellen.

Zum Beispiel:

 wenn er err: = dosomething (); err! = nil {
    Return fmt.Errorf ("Nicht etwas tun: %w", ähm)
}

Auf diese Weise kann der Anrufer errors.Is() oder errors.As() um den ursprünglichen Fehler zu beurteilen:

 if errors.is (err, os.errnotexist) {
    // Behandle den Fall, in dem die Datei nicht existiert}

Anmerkungen :

• %w kann nur verwendet werden, um einen Fehler direkt zu wickeln, und kann nicht mehrere Fehler einwickeln.
• Wenn Sie packen möchten, aber den ursprünglichen Fehler nicht aufdecken möchten, verwenden Sie nicht %w
• Versuchen Sie, einen Kontext zu bringen, wenn Verpackungsfehler wie "Konfigurationsdatei nicht gelesen hat: %W"

Wie gestaltete ich ein angemessenes Fehlergrad?

In großen Projekten neigen Fehlertypen dazu, eine Hierarchie zu bilden. Zum Beispiel:

• AppError : Fehlertyp der obersten Ebene
  • DBError
  • NetworkError
  • PermissionError

Mit diesem Design können Sie flexibel bestimmen, welcher Fehlertyp beim Umgang mit Fehlern ist:

 var err Fehler
wenn er = dosomething (); err! = nil {
    if errors.as (err, & dberror {}) {
        // Datenbank -Wiederholung logisch} else if errors.as (err, & networkError {}) {
        // Netzwerksicherheitsbehandlung machen}
}

Entwurfsvorschläge :

• Sie haben keine zu tiefen Ebenen, 2 bis 3 Schichten sind genug
• Jeder Fehlertyp muss einen klaren Zweck haben
• Erzwingen Sie nicht die Aufteilung für "Kategorisierung" und bleiben Sie pragmatisch

Kleine Details: Die Fehlermeldung sollte klar sein, aber nicht zu wortreich sein

Ein häufiges Missverständnis ist, dass es zu viele Fehlermeldungen gibt, wie z. B.:

 "Die Datei nicht geöffnet, weil das System sie nicht finden konnte"

Eigentlich ist es besser, direkt zu schreiben:

 "Datei nicht geöffnet: %w", os.errnotexist

Auf diese Weise kann der Anrufer den Fehlertyp genau beurteilen, anstatt nur die Zeichenfolge zu betrachten. Fehlermeldung Vorschläge:

• Erklären Sie kurz die Probleme des aktuellen Levels
• Verwenden Sie %w , um den zugrunde liegenden Fehler in einzuwickeln
• Vermeiden Sie redundante Beschreibungen, wie das Wiederholen von "nicht zu" "nicht"

Grundsätzlich ist das. Fehlerbehandlung ist keine triviale Angelegenheit. Wenn Sie gute kundenspezifische Fehler und Verpackungsstrategien erstellen, können Sie Ihren Go -Code robuster und leichter zu pflegen.

Das obige ist der detaillierte Inhalt vonGehen Sie für Strategien zur Handhabungs- und Verpackungsstrategien für Fehlerhandel.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!