Kombinieren Sie mehrere Fehlermeldungen

Ich bin neu in golang, meine Bewerbung zurückgeben muss, mehrere Fehler in einer Schleife, die später benötigt werden, kombiniert, und kehrte als ein einziger Fehler-string. Ich bin nicht in der Lage, die string-Funktionen zu kombinieren, die Fehlermeldungen. Welche Methoden können werden verwendet, um zu kombinieren, diese Fehler in einen einzigen Fehler vor der Rückkehr ?

package main

import (
   "fmt"
   "strings"
)

func Servreturn() (err error) {

   err1 = fmt.Errorf("Something else occured")
   err2 = fmt.Errorf("Something else occured again")

   //concatenate both the error

   return err3

}

Nicht genügend Informationen. Was der Kunde tun? Was Ihre server tun? Ein Beispiel für die Ausgabe.

InformationsquelleAutor Greg Petr | 2015-11-02

error-handling go

Könnten Sie die strings.Join() und append() Funktion zu erreichen, diese Scheibe.

Beispiel: golang playgorund

package main

import (
    "fmt"
    "strings"
    "syscall"
)

func main() {

    //create a slice for the errors
    var errstrings []string 

    //first error
    err1 := fmt.Errorf("First error:server error")
    errstrings = append(errstrings, err1.Error())

    //do something 
    err2 := fmt.Errorf("Second error:%s", syscall.ENOPKG.Error())
    errstrings = append(errstrings, err2.Error())

    //do something else
    err3 := fmt.Errorf("Third error:%s", syscall.ENOTCONN.Error())
    errstrings = append(errstrings, err3.Error())

    //combine and print all the error
    fmt.Println(fmt.Errorf(strings.Join(errstrings, "\n")))


}

Diesem würde die Ausgabe eine einzelne Zeichenfolge, die können Sie schicken Sie zurück an den client.

First error:server1 
Second error:Package not installed 
Third error:Socket is not connected

hoffe, das hilft!

InformationsquelleAutor askb

17

String-Funktionen arbeiten nicht auf Fehler, da Fehler, ist wirklich ein interface, dass implementiert die Funktion Fehler() string.

Können Sie die Verwendung von string-Funktionen auf err1.Fehler() und err2.Fehler()
aber nicht auf die "err1" auf sich selbst.

Einige Fehler sind Strukturen, wie die, die man aus dem Datenbank-Treiber.

Also gibt es keine Natürliche Art und Weise die Verwendung von string-Funktionen auf Fehler, da Sie möglicherweise gar keine strings unter.

Als für die Kombination von zwei Fehlern:

Einfach, benutzen Sie einfach fmt.Errorf wieder.
```
fmt.Errorf("Combined error: %v %v", err1, err2)
```
Alternativ:
```
errors.New(err1.Error() + err2.Error())
```
- Andere Wege, andere als die Verwendung von fmt.Errorf(), warum kann ich mit der string-Funktion ?
- Sicher. Hängt davon ab, was Sie wirklich bedeutet "verbinden". Die String-Verkettung erfolgt über die + Betreiber. Oder Sie können speichern Sie Sie einzeln in eine Scheibe, append()-ing Werte. Das Frage suggeriert Sie arbeiten sollten Sie sich durch einen Go-tutorial und erhalten Sie ein Buch über ihn.
- Möglicherweise einem anderen, sauberen Weg, dies zu tun ist, um Ihre eigenen CombinedError Struktur, die eine Liste der Fehler, die wie ein Feld und setzt die Error() string Methode und tun, was Sie wollen, egal, ob die Verkettung von strings oder was auch immer.
InformationsquelleAutor David Budworth
4

Ergänzen, was @WillC erwähnt hatte in einem Kommentar es ist möglich, zu definieren, Ihre eigenen error Typ wie error ist eine Schnittstelle geben. Jede Art, die eine Error() string Funktion implementiert die error - Schnittstelle. Daher könnten Sie eine CollectionError die Aggregate Fehler und gibt eine Fehler-string verkettet.
```
type ErrorCollector []error

func (c *ErrorCollector) Collect(e error) { *c = append(*c, e) }

func (c *ErrorCollector) Error() (err string) {
    err = "Collected errors:\n"
    for i, e := range *c {
        err += fmt.Sprintf("\tError %d: %s\n", i, e.Error())
    }

    return err
}
```
Diese bietet eine Sammlung Funktion fügt einen bestimmten error zu einem slice. Bei Aufruf Error() string es durchläuft die Scheibe und erstellt eine verkettete Fehler-string.
```
func main() {
    collector := new(ErrorCollector)

    for i := 0; i < 10; i++ {
         collector.Collect(errors.New(fmt.Sprintf("%d Error", i)))
    }

    fmt.Println(collector)
}
```
Gibt es eine große golang.org blog-post über Fehler im detail. Ein vollständiges Beispiel für das Beispiel ist auf Die Gehen Spielplatz.
- vielen Dank, dein Beispiel war sehr hilfreich. Ich werde das ausprobieren und wieder zurück.
- Gibt es einen Grund für die Methode Empfänger ein Zeiger hier?
- Vielen Dank für diesen Tipp. Auf der off-chance, könnte man hinzufügen einer null-error, die Error () - Funktion sollte ein null-check auf die gesammelten Fehler. Und wenn man zugreift, indem nur der index und nicht der index + Wert, müssen Rücksicht Besetzung der Fehler-array vor der index-Zugriff. Hier ein Beispiel: play.golang.org/p/h9F5WhcQ5Bs
InformationsquelleAutor Ben Campbell
2

Menschen können daran interessiert sein, https://github.com/hashicorp/go-multierror die sich selbst beschreibt als "A Go (golang) Paket zur Darstellung einer Liste von Fehlern, wie einem einzigen Fehler.".

InformationsquelleAutor Mark Lawrence

Dave Cheney ausgezeichnete errors - Paket (https://github.com/pkg/errors) gehören Wrap Funktion für diesen Zweck:

package main

import "fmt"
import "github.com/pkg/errors"

func main() {
        err := errors.New("error")
        err = errors.Wrap(err, "open failed")
        err = errors.Wrap(err, "read config failed")

        fmt.Println(err) //"read config failed: open failed: error"
}

Dies ermöglicht auch zusätzliche Funktionen, wie das Auspacken der Ursache des Fehlers:

package main

import "fmt"
import "github.com/pkg/errors"

func main() {
    err := errors.New("original error")
    err = errors.Wrap(err, "now this")

    fmt.Println(errors.Cause(err)) //"original error"
}

Sowie die option zur Ausgabe eines stack-trace-bei der Angabe fmt.Printf("%+v\n", err).

Finden Sie weitere Informationen über das Paket auf seinem blog: hier und hier.

InformationsquelleAutor Feckmore

Verwenden Sie diese Funktion:

func JoinErrs(errs ...error) error {
    var joinErrsR func(string, int, ...error) error
    joinErrsR = func(soFar string, count int, errs ...error) error {
        if len(errs) == 0 {
            if count == 0 {
                return nil
            }
            return fmt.Errorf(soFar)
        }
        current := errs[0]
        next := errs[1:]
        if current == nil {
            return joinErrsR(soFar, count, next...)
        }
        count++
        if count == 1 {
            return joinErrsR(fmt.Sprintf("%s", current), count, next...)
        } else if count == 2 {
            return joinErrsR(fmt.Sprintf("1: %s\n2: %s", soFar, current), count, next...)
        }
        return joinErrsR(fmt.Sprintf("%s\n%d: %s", soFar, count, current), count, next...)
    }
    return joinErrsR("", 0, errs...)
}

Es wird Ihnen null, wenn alle Fehler sind gleich null, geben Sie den gleichen Fehler, wenn nur eine nicht-null-Fehler, geben Sie " nummerierte Liste der nicht-null-Fehler, wenn mehrere nicht-null-Fehler

Versuchen Sie es hier: https://play.golang.org/p/WttztCr-xHG

InformationsquelleAutor Sean F

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.