Методы обработки ошибок Go [закрыто]

Я только начинаю работать с Go. В моем коде этого становится много:

   if err != nil {
      //handle err
   }

или это

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

Есть ли какие-нибудь хорошие идиомы / стратегии / лучшие практики для проверки и обработки ошибок в Go?

ИЗМЕНИТЬ, чтобы уточнить: я не кричу и не предлагаю команде Go придумать что-то получше. Я спрашиваю, правильно ли я делаю или я пропустил какую-то технику, которую придумало сообщество. Спасибо всем.

Ваш код идиоматичен, и, на мой взгляд, это лучшая доступная практика. Некоторые наверняка не согласятся, но я бы сказал, что это стиль, встречающийся во всех стандартных библиотеках Golang . Другими словами, авторы Go так пишут обработку ошибок.

Через шесть месяцев после того, как этот вопрос был задан, Роб Пайк написал в блоге сообщение под названием « Ошибки - это ценности» .

Там он утверждает, что вам не нужно программировать способом, представленным OP, и упоминает несколько мест в стандартной библиотеке, где они используют другой шаблон.

Конечно, обычным утверждением, связанным со значением ошибки, является проверка, является ли оно нулевым, но есть бесчисленное множество других вещей, которые можно сделать со значением ошибки, и применение некоторых из этих других вещей может улучшить вашу программу, устраняя большую часть шаблонов это возникает, если каждая ошибка проверяется механическим условием if.

...

Используйте язык, чтобы упростить обработку ошибок.

Но помните: что бы вы ни делали, всегда проверяйте свои ошибки!

Это хорошее чтение.

Я согласен с ответом jnml, что они оба являются идиоматическим кодом, и добавлю следующее:

Ваш первый пример:

if err != nil {
      //handle err
}

более идиоматичен при работе с более чем одним возвращаемым значением. например:

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

Ваш второй пример - хорошее сокращение, когда вы имеете дело только со errзначением. Это применимо, если функция возвращает только error, или если вы намеренно игнорируете возвращаемые значения, кроме error. В качестве примера, это иногда используется с Readerи Writerфункциями , которые возвращают intиз числа записанных байт (иногда ненужной информации) , а также error:

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

Вторая форма называется использованием оператора инициализации if .

Итак, что касается лучших практик, насколько мне известно (за исключением использования пакета «errors» для создания новых ошибок, когда они вам нужны), вы охватили почти все, что вам нужно знать об ошибках в Go!

EDIT: Если вы обнаружили , что на самом деле не может жить без исключений, вы можете имитировать их defer, panicиrecover .

Я создал библиотеку для упрощенной обработки ошибок и передачи по очереди функций Go.

Вы можете найти его здесь: https://github.com/go-on/queue

Он имеет компактный и многословный синтаксический вариант. Вот пример короткого синтаксиса:

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:
           ...
       }
    }
}

Имейте в виду, что есть небольшие накладные расходы на производительность, так как он использует отражение.

Кроме того, это не идиоматический код go, поэтому вы захотите использовать его в своих собственных проектах или если ваша команда согласится использовать его.

«Стратегия» обработки ошибок в golang и других языках состоит в том, чтобы постоянно распространять ошибки вверх по стеку вызовов, пока вы не достигнете в стеке вызовов достаточно высокого уровня для обработки этой ошибки. Если вы попытались обработать эту ошибку слишком рано, то, скорее всего, в конечном итоге код повторится. Если вы справитесь с этим слишком поздно, вы что-то сломаете в своем коде. Golang делает этот процесс очень простым, поскольку он очень четко показывает, обрабатываете ли вы ошибку в данном месте или распространяете ее.

Если вы собираетесь игнорировать ошибку, простой _ очень ясно покажет этот факт. Если вы обрабатываете ее, то ясно, какой именно случай ошибки вы обрабатываете, поскольку вы проверите ее в операторе if.

Как было сказано выше, ошибка на самом деле является нормальным значением. Это относится к нему как к такому.

Боги Go опубликовали «черновой вариант» обработки ошибок в Go 2. Он направлен на изменение идиомы ошибок:

Обзор и дизайн

Им нужна обратная связь от пользователей!

Обратная связь вики

Вкратце это выглядит так:

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

ОБНОВЛЕНИЕ. Эскизный проект получил много критики, поэтому я составил « Требования, которые следует учитывать при обработке ошибок Go 2» с меню возможностей для возможного решения.

Большинство в отрасли следуют стандартным правилам, упомянутым в документации golang. Обработка ошибок и Go . И это также помогает создавать документы для проекта.

Ниже я расскажу о сокращении обработки ошибок для Go, образец предназначен для получения параметров URL-адреса HTTP:

(Шаблон проектирования взят из 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
}

вызов его для нескольких возможных параметров будет следующим:

    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
    }

Это не серебряная пуля, недостатком является то, что если у вас было несколько ошибок, вы можете получить только последнюю ошибку.

Но в данном случае это относительно однообразная повторяемость и низкий риск, поэтому я могу просто получить последнюю возможную ошибку.

Вы можете очистить свой код обработки ошибок для подобных ошибок (поскольку ошибки - это значения, с которыми вы должны быть осторожны здесь) и написать функцию, которую вы вызываете с переданной ошибкой для обработки ошибки. Тогда вам не придется каждый раз писать «if err! = Nil {}». Опять же, это приведет только к очистке кода, но я не думаю, что это идиоматический способ делать что-то.

Опять же, то, что вы можете , не означает, что вы должны .

goerr позволяет обрабатывать ошибки с помощью функций

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)
}

Если вам нужен точный контроль ошибок, это может не быть решением, но для меня в большинстве случаев любая ошибка является препятствием для шоу.

Поэтому вместо этого я использую функции.

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

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