Wie können mehrere Fehler in einem einzigen Block effizient behandelt werden?

Eleganter Umgang mit mehreren Fehlern in Go

In Go ist es oft notwendig, mehrere Fehler gleichzeitig zu behandeln, insbesondere wenn es um E/A geht Operationen oder Datentransformationen. Während der traditionelle Ansatz, jeden Fehler einzeln zu überprüfen, mühsam und repetitiv sein kann, bietet Go einen Mechanismus, um alle Fehler in einem kurzen Block zu behandeln.

Problem: Umgang mit mehreren Fehlern

Betrachten Sie den folgenden Code, der versucht, mehrere Werte in JSON zu marsalieren:

aJson, err1 := json.Marshal(a)
bJson, err2 := json.Marshal(b)
cJson, err3 := json.Marshal(c)
dJson, err4 := json.Marshal(d)
eJson, err5 := json.Marshal(e)
fJson, err6 := json.Marshal(f)
gJson, err4 := json.Marshal(g)
if err1 != nil {
    return err1
} else if err2 != nil {
    return err2
} else if err3 != nil {
    return err3
} else if err4 != nil {
    return err4
} else if err5 != nil {
    return err5
} else if err5 != nil {
    return err5
} else if err6 != nil {
    return err6
}

Dieser Code ist fehleranfällig und erfordert Wiederholungen Fehlerbehandlungsprüfungen für jeden Marshalling-Vorgang. Außerdem wird die Behandlung von Fehlern für alle JSON-Objekte zu einer Herausforderung.

Lösung: Verwendung einer nicht-lokalen Variablen zur Fehlererkennung

Go bietet eine praktische Möglichkeit, mehrere Fehler in zu behandeln ein einzelner Block, der eine nicht-lokale Variable verwendet. Hier ist eine verbesserte Version des Codes:

var err error
f := func(dest *D, src S) bool {
    *dest, err = json.Marshal(src)
    return err == nil
}

f(&aJson, a) &&
    f(&bJson, b) &&
    f(&cJson, c) &&
    f(&dJson, d) &&
    f(&eJson, e) &&
    f(&fJson, f) &&
    f(&gJson, g)
return err

In dieser Lösung definieren wir eine f-Funktion, die das Marshalling durchführt und die Variable err festlegt. Die err-Variable wird außerhalb der Funktion deklariert, sodass sie von allen Aufrufen der f-Funktion gemeinsam genutzt werden kann.

Die f-Funktion akzeptiert Zeiger auf die Ziel-JSON-Objekte und die Quelldaten. Es gibt einen Bool-Wert zurück, der angibt, ob das Marshalling erfolgreich war (kein Fehler aufgetreten).

Danach rufen wir für jedes Objekt die f-Funktion auf und verbinden die Ergebnisse mit && (logisches Und). Wenn einer der Aufrufe „Falsch“ zurückgibt (ein Fehler ist aufgetreten), wird die Kette unterbrochen und die Variable „err“ enthält den ersten aufgetretenen Fehler. Andernfalls, wenn alle Aufrufe „true“ zurückgeben, ist kein Fehler aufgetreten und der letzte Fehler ist Null.

In der letzten Zeile geben wir die Variable „err“ zurück, die den ersten aufgetretenen Fehler enthält, oder Null, wenn alle Vorgänge erfolgreich waren .

Dieser Ansatz ermöglicht es uns, alle Fehler in einer einzigen Anweisung zu behandeln, wodurch die Fehlerbehandlung präziser und effizienter wird.

Das obige ist der detaillierte Inhalt vonWie können mehrere Fehler in einem einzigen Block effizient behandelt werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!