Techniki obsługi błędów Go [zamknięte]

Dopiero zaczynam z Go. Mój kod zaczyna mieć dużo tego:

   if err != nil {
      //handle err
   }

albo to

  if err := rows.Scan(&some_column); err != nil {
      //handle err
  }

Czy są jakieś dobre idiomy / strategie / najlepsze praktyki dotyczące sprawdzania i obsługi błędów w Go?

EDYTUJ, aby wyjaśnić: nie oszukuję ani nie sugeruję, aby zespół Go wymyślił coś lepszego. Pytam, czy robię to dobrze, czy też przegapiłem jakąś technikę wymyśloną przez społeczność. Dziękuje wszystkim.

Twój kod jest idiomatyczny i moim zdaniem jest to najlepsza dostępna praktyka. Niektórzy na pewno by się z tym nie zgodzili, ale ja argumentowałbym, że jest to styl widoczny we wszystkich standardowych bibliotekach w Golangu . Innymi słowy, autorzy Go piszą w ten sposób obsługę błędów.

Sześć miesięcy po zadaniu tego pytania Rob Pike napisał post na blogu zatytułowany Błędy to wartości .

W tym miejscu argumentuje, że nie trzeba programować w sposób przedstawiony przez PO i wspomina o kilku miejscach w bibliotece standardowej, w których używają innego wzorca.

Oczywiście typowym stwierdzeniem dotyczącym wartości błędu jest sprawdzenie, czy jest ona zerowa, ale istnieje niezliczona ilość innych rzeczy, które można zrobić z wartością błędu, a zastosowanie niektórych z tych innych rzeczy może ulepszyć program, eliminując większość schematu która powstaje, gdy każdy błąd jest sprawdzany za pomocą rote if instrukcji.

...

Użyj języka, aby uprościć obsługę błędów.

Ale pamiętaj: cokolwiek robisz, zawsze sprawdzaj błędy!

To dobra lektura.

Zgodziłbym się z odpowiedzią jnml, że oba są kodem idiomatycznym i dodam:

Twój pierwszy przykład:

if err != nil {
      //handle err
}

jest bardziej idiomatyczny, gdy mamy do czynienia z więcej niż jedną wartością zwracaną. na przykład:

val, err := someFunc()
if err != nil {
      //handle err
}
//do stuff with val

Twój drugi przykład jest fajnym skrótem, jeśli chodzi tylko o errwartość. Ma to zastosowanie, jeśli funkcja zwraca tylko wartość an errorlub celowo zignorujesz zwrócone wartości inne niż error. Na przykład jest to czasami używane z funkcjami Readeri, Writerktóre zwracają intliczbę zapisanych bajtów (czasami niepotrzebne informacje) oraz error:

if _, err := f.Read(file); err != nil {
      //handle err
}
//do stuff with f

Drugi formularz jest określany jako użycie instrukcji inicjalizacji if .

Jeśli chodzi o najlepsze praktyki, o ile wiem (z wyjątkiem używania pakietu „errors” do tworzenia nowych błędów, gdy ich potrzebujesz), omówiłeś prawie wszystko, co musisz wiedzieć o błędach w Go!

EDIT: Jeśli okaże się, naprawdę nie mogą żyć bez wyjątków, można naśladować ich defer, panicirecover .

Stworzyłem bibliotekę do usprawnionej obsługi błędów i przesyłania przez kolejkę funkcji Go.

Możesz go znaleźć tutaj: https://github.com/go-on/queue

Ma zwarty i pełny wariant składni. Oto przykład krótkiej składni:

import "github.com/go-on/queue/q"

func SaveUser(w http.ResponseWriter, rq *http.Request) {
    u := &User{}
    err := q.Q(                      
        ioutil.ReadAll, rq.Body,  // read json (returns json and error)
    )(
        // q.V pipes the json from the previous function call
        json.Unmarshal, q.V, u,   // unmarshal json from above  (returns error)
    )(
        u.Validate,               // validate the user (returns error)
    )(
        u.Save,                   // save the user (returns error)
    )(
        ok, w,                    // send the "ok" message (returns no error)
    ).Run()

    if err != nil {
       switch err {
         case *json.SyntaxError:
           ...
       }
    }
}

Należy pamiętać, że istnieje niewielki narzut wydajności, ponieważ wykorzystuje refleksję.

Nie jest to również idiomatyczny kod go, więc będziesz chciał go używać we własnych projektach lub jeśli Twój zespół zgodzi się go używać.

„Strategią” obsługi błędów w języku golang i innych językach jest ciągłe rozpowszechnianie błędów w stosie wywołań, dopóki nie osiągniesz wystarczająco wysokiego poziomu w stosie wywołań, aby obsłużyć ten błąd. Jeśli próbowałeś obsłużyć ten błąd zbyt wcześnie, prawdopodobnie w końcu powtórzysz kod. Jeśli poradzisz sobie z tym za późno, zepsujesz coś w swoim kodzie. Golang sprawia, że ​​ten proces jest bardzo łatwy, ponieważ bardzo jasno określa, czy obsługujesz błąd w danej lokalizacji, czy też go propagujesz.

Jeśli zamierzasz zignorować błąd, proste _ ujawni ten fakt bardzo wyraźnie. Jeśli go obsługujesz, to dokładnie, który przypadek błędu, który obsługujesz, jest jasny, ponieważ sprawdzisz go w instrukcji if.

Jak ludzie powiedzieli powyżej, błąd jest w rzeczywistości zwykłą wartością. To traktuje to jako takie.

Bogowie Go opublikowali "szkic projektu" do obsługi błędów w Go 2. Ma on na celu zmianę idiomu błędów:

Przegląd i projekt

Chcą opinii użytkowników!

Witryna wiki opinii

W skrócie wygląda to tak:

func f() error {
   handle err { fmt.Println(err); return err }
   check mayFail()
   check canFail()
}

AKTUALIZACJA: Projekt projektu spotkał się z dużą krytyką, dlatego przygotowałem projekt Wymagania do rozważenia w przypadku obsługi błędów Go 2 z menu możliwości ewentualnego rozwiązania.

Większość w branży postępuje zgodnie ze standardowymi zasadami wymienionymi w dokumentacji firmy Golang. Obsługa błędów i gotowe . Pomaga także w generowaniu dokumentów dla projektu.

Poniżej znajduje się moja opinia na temat ograniczenia obsługi błędów w Go, przykład dotyczy pobierania parametrów adresu URL HTTP:

(Wzorzec projektowy pochodzi z https://blog.golang.org/errors-are-values )

type HTTPAdapter struct {
    Error *common.AppError
}

func (adapter *HTTPAdapter) ReadUUID(r *http.Request, param string, possibleError int) uuid.UUID {
    requestUUID := uuid.Parse(mux.Vars(r)[param])
    if requestUUID == nil { 
        adapter.Error = common.NewAppError(fmt.Errorf("parameter %v is not valid", param),
            possibleError, http.StatusBadRequest)
    }
    return requestUUID
}

wywołanie go dla wielu możliwych parametrów wyglądałoby następująco:

    adapter := &httphelper.HTTPAdapter{}
    viewingID := adapter.ReadUUID(r, "viewingID", common.ErrorWhenReadingViewingID)
    messageID := adapter.ReadUUID(r, "messageID", common.ErrorWhenReadingMessadeID)
    if adapter.Error != nil {
        return nil, adapter.Error
    }

To nie jest srebrna kula, wadą jest to, że jeśli miałeś wiele błędów, możesz uzyskać tylko ostatni błąd.

Ale w tym przypadku jest to stosunkowo powtarzalne i niskie ryzyko, dlatego mogę uzyskać ostatni możliwy błąd.

Państwo może oczyścić swój kod obsługi błędów dla podobnych błędów (ponieważ błędy są wartościami trzeba być ostrożnym tutaj) i napisać funkcję, którą nazywasz z błędem przeszedł do obsługi błędu. Nie będziesz wtedy musiał za każdym razem pisać "if err! = Nil {}". Ponownie, spowoduje to jedynie wyczyszczenie kodu, ale nie sądzę, że jest to idiomatyczny sposób robienia rzeczy.

Ponownie, tylko dlatego, że możesz , nie oznacza, że powinieneś .

goerr umożliwia obsługę błędów za pomocą funkcji

package main

import "github.com/goerr/goerr"
import "fmt"

func ok(err error) {
    if err != nil {
        goerr.Return(err)
        // returns the error from do_somethingN() to main()
        // sequence() is terminated
    }
}

func sequence() error {
    ok(do_something1())
    ok(do_something2())
    ok(do_something3())

    return nil /// 1,2,3 succeeded
}
func do_something1() error { return nil }
func do_something2() error { return fmt.Errorf("2") }
func do_something3() error {
    fmt.Println("DOING 3")
    return nil
}

func main() {
    err_do_something := goerr.OR1(sequence)

    // handle errors

    fmt.Println(err_do_something)
}

Jeśli chcesz precyzyjnej kontroli błędów, może nie jest to rozwiązanie, ale dla mnie w większości przypadków każdy błąd jest zatrzymaniem pokazu.

Więc zamiast tego używam funkcji.

func Err(err error) {
    if err!=nil {
        fmt.Println("Oops", err)
        os.Exit(1)
    }
}

fi, err := os.Open("mmm.txt")
Err(err)