Ошибки — Основы Go

• Ошибки vs исключения
• Паника — это ошибки программиста
• Обработка ошибок
  • Что здесь происходит
• Более подробное сообщение об ошибке
• Пример: нормальное и ошибочное деление
• Как устроены программы в Go с ошибками

В Go есть два способа сообщать о проблемах: ошибки и паника.

Ошибки vs исключения

Во многих языках, например, в Python или JavaScript, при возникновении ошибки выбрасывается исключение (exception), которое можно перехватить и обработать. В Go всё иначе: вместо исключений используется явная передача ошибок через возвращаемые значения.

Такой подход делает поток исполнения более прозрачным: вы всегда видите, где может произойти ошибка и как она обрабатывается. Цена за это - постоянные проверки при вызове функций, которые могут вернуть ошибку.

Паника — это ошибки программиста

Go предоставляет механизм паники (panic), но он используется редко. Паника означает, что программа не может продолжать выполнение. Это обычно связано с ошибками в логике программы: выход за границы массива, обращение к nil, нарушение внутренних инвариантов.

Пример паники:

denominator := 0
result := 10 / denominator // Деление на ноль — вызывает панику
fmt.Println("Результат:", result)

Панику можно вызвать явно с помощью функции panic(). Обычно это делается, когда программа сталкивается с ситуацией, которая не должна происходить при корректной логике, и продолжать выполнение небезопасно:

func divide(a, b int) int {
    if b == 0 {
        panic("деление на ноль недопустимо")
    }
    return a / b
}

Паника в Go приводит к аварийному завершению программы: выполнение прерывается, и если не задействован специальный механизм для её обработки, программа прекращает работу и выводит сообщение об ошибке вместе со стек-трейсом.

Обработка ошибок

В Go есть специальный тип error, который можно использовать для возврата сообщения об ошибке из функции. Это встроенный тип в стандартной библиотеке, и его удобно использовать для обработки любых проблем, которые могут возникнуть при выполнении функции.

Сигнатура функции, которая может вернуть ошибку, обычно выглядит так:

func имя(аргументы) (результат, error)

Функция divide() ниже возвращает два значения: результат деления и ошибку. Если деление прошло успешно, ошибка равна nil. Если произошла ошибка (например, деление на ноль), вместо результата возвращается 0 и ненулевая ошибка. Вот пример безопасного деления с проверкой деления на ноль:

package main

import (
    "errors"
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("деление на ноль невозможно")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    fmt.Println("Результат:", result)
}

Что здесь происходит

• Функция divide() возвращает два значения: результат и ошибку.
• Если делитель равен нулю, создаётся ошибка с помощью errors.New.
• В main() мы проверяем: если err не nil, значит произошла ошибка — выводим её.

Более подробное сообщение об ошибке

Для создания более понятных сообщений можно использовать fmt.Errorf():

return 0, fmt.Errorf("ошибка деления %v / %v: делитель равен нулю", a, b)

Пример: нормальное и ошибочное деление

func main() {
    fmt.Println(divide(12, 4))  // 3 <nil>
    fmt.Println(divide(5, 0))   // 0 ошибка деления 5 / 0: делитель равен нулю
}

Как устроены программы в Go с ошибками

Так как в Go нет исключений и нет конструкции try/catch, весь контроль за ошибками осуществляется через возврат значения типа error. Это приводит к тому, что код часто выглядит как последовательность:

результат, ошибка := функция()
if ошибка != nil {
    // Обработка ошибки
    return ...
}

Такая структура повторяется много раз подряд, что может создать матрешку из вложенных проверок. Поэтому работая с ошибками, принято их выпрямлять:

func process() error {
    data, err := readData()
    if err != nil {
        return err
    }

    value, err := parseData(data)
    if err != nil {
        return err
    }

    result, err := computeResult(value)
    if err != nil {
        return err
    }

    err = saveResult(result)
    if err != nil {
        return err
    }

    fmt.Println("Обработка завершена успешно")
    return nil
}

Дополнительные материалы

1. Errors