Цели главы
- Писать и читать паттерн
result, errиif err != nil. - Создавать ошибки через
errors.Newиfmt.Errorf, объявлять sentinel-ошибки. - Использовать ранний возврат.
- Добавлять контекст через
%wи не путать его с%v. - Проверять ошибки через
errors.Isиerrors.As, писать свой тип ошибки.
Ошибка — это значение
Если ты пришёл из языков с try/catch, поначалу Go может раздражать: здесь ошибка — не исключение, которое летит вверх по стеку, а обычное значение. Функция возвращает его рядом с результатом, и ты решаешь, что с ним делать, прямо на месте. Кода становится больше, зато ошибка всегда перед глазами и ничего не улетает внезапно.
Разбирать будем на стриминговом сервисе GoFlix: фильмы, подписки, запуск контента.
Паттерн result, err
Функция возвращает два значения: результат и ошибку. Всё хорошо — ошибка nil; что-то пошло не так — в ней значение ошибки, а результат обычно нулевой. Точнее, ошибка — это значение встроенного интерфейсного типа error.
package main
import "fmt"
func loadMovie(title string) (string, error) {
catalog := map[string]string{
"Интерстеллар": "Фантастика, 2014, 8.6",
"Начало": "Фантастика, 2010, 8.8",
}
data, ok := catalog[title]
if !ok {
return "", fmt.Errorf("фильм %q не найден", title)
}
return data, nil
}
func main() {
movie, err := loadMovie("Интерстеллар")
if err != nil {
fmt.Println("Ошибка:", err)
} else {
fmt.Println("Загружен:", movie)
}
if _, err := loadMovie("Несуществующий"); err != nil {
fmt.Println("Ошибка:", err)
}
if movie, err := loadMovie("Начало"); err == nil {
fmt.Println("Загружен:", movie) // movie и err живут только внутри этого if
}
}Загружен: Фантастика, 2014, 8.6
Ошибка: фильм "Несуществующий" не найден
Загружен: Фантастика, 2010, 8.8Компактная запись через if с инициализацией (06 — Условия if-else → if с инициализацией) не разбрасывает временные переменные по функции: movie и err живут только внутри блока. Мелочь, но в реальном коде такие мелочи сильно влияют на читаемость.
Как создать ошибку
errors.New и fmt.Errorf
errors.New("нужна подписка")— фиксированный текст: «доступ запрещён», «неверный пользователь».fmt.Errorf("фильм %q не найден", title)— когда в сообщение нужно подставить данные: название, ID, логин.
Договорённость Go: если функция возвращает несколько значений, error всегда последний.
Sentinel-ошибки
Два вызова errors.New с одинаковым текстом дают разные значения ошибок. Поэтому ошибки, которые вызывающий код должен распознавать, объявляют один раз на уровне пакета и переиспользуют. Такие заранее объявленные значения называют сигнальными, или sentinel-ошибками. По соглашению их имена начинаются с Err (экспортируемые) или err (внутренние).
package main
import (
"errors"
"fmt"
)
var ErrMovieNotFound = errors.New("фильм не найден")
func findMovie(id int) error {
return ErrMovieNotFound
}
func main() {
a := errors.New("фильм не найден")
b := errors.New("фильм не найден")
fmt.Println(a == b) // текст одинаковый, значения разные
fmt.Println(findMovie(1) == ErrMovieNotFound) // одна переменная — одно значение
}false
trueРанний возврат
Как только нашли проблему — сразу выходим из функции с ошибкой. Пустое имя — ошибка; неизвестный тариф — ошибка. И только когда все проверки пройдены, идём по основному сценарию. Так «счастливый путь» (happy path) остаётся прямым и прижатым к левому краю, а не уезжает вправо в три уровня вложенных if.
package main
import (
"errors"
"fmt"
)
var ErrInvalidUser = errors.New("неверный пользователь")
func processSubscription(userName, plan string) (string, error) {
if userName == "" {
return "", ErrInvalidUser
}
validPlans := map[string]bool{"Basic": true, "Standard": true, "Premium": true}
if !validPlans[plan] {
return "", fmt.Errorf("недопустимый план: %q", plan)
}
return fmt.Sprintf("%s подключил план %s", userName, plan), nil
}
func main() {
for _, plan := range []string{"Premium", "Gold"} {
result, err := processSubscription("Алексей", plan)
if err != nil {
fmt.Println("Ошибка:", err)
continue
}
fmt.Println(result)
}
}Алексей подключил план Premium
Ошибка: недопустимый план: "Gold"Контекст: оборачивание через %w
Голое «фильм не найден» мало что говорит. Нужен контекст: ошибка случилась при просмотре фильма с конкретным ID. Для этого берут исходную ошибку и добавляют к ней слой: fmt.Errorf("просмотр фильма %d: %w", id, err).
%w(wrap) сохраняет связь с исходной ошибкой: её потом найдутerrors.Isиerrors.As.%vдаёт тот же текст, но связь с причиной теряется.
package main
import (
"errors"
"fmt"
)
var ErrMovieNotFound = errors.New("фильм не найден")
func findMovieByID(id int) (string, error) {
if id == 42 {
return "", ErrMovieNotFound
}
return fmt.Sprintf("Фильм #%d", id), nil
}
func watchMovie(id int) error {
title, err := findMovieByID(id)
if err != nil {
return fmt.Errorf("просмотр фильма %d: %w", id, err) // %w сохраняет причину
}
fmt.Println("Смотрим:", title)
return nil
}
func main() {
err := watchMovie(42)
fmt.Println(err)
fmt.Println(errors.Is(err, ErrMovieNotFound)) // ищет по всей цепочке
lost := fmt.Errorf("просмотр фильма %d: %v", 42, ErrMovieNotFound) // %v — только текст
fmt.Println(lost)
fmt.Println(errors.Is(lost, ErrMovieNotFound))
}просмотр фильма 42: фильм не найден
true
просмотр фильма 42: фильм не найден
falseerrors.Is — проверка по значению
errors.Is(err, target) отвечает на вопрос: «Есть ли в этой ошибке или в её цепочке конкретное значение?» Так у каждого известного случая появляется своя ветка обработки.
package main
import (
"errors"
"fmt"
)
var (
ErrMovieNotFound = errors.New("фильм не найден")
ErrAccessDenied = errors.New("доступ запрещён")
)
func findMovieByID(id int) (string, error) {
switch id {
case 42:
return "", ErrMovieNotFound
case 100:
return "", ErrAccessDenied
default:
return fmt.Sprintf("Фильм #%d", id), nil
}
}
func main() {
for _, id := range []int{1, 42, 100} {
title, err := findMovieByID(id)
switch {
case errors.Is(err, ErrMovieNotFound):
fmt.Printf("ID %d: фильм не найден\n", id)
case errors.Is(err, ErrAccessDenied):
fmt.Printf("ID %d: доступ запрещён\n", id)
case err != nil:
fmt.Printf("ID %d: %v\n", id, err)
default:
fmt.Printf("ID %d: %s\n", id, title)
}
}
}ID 1: Фильм #1
ID 42: фильм не найден
ID 100: доступ запрещёнИгнорирование ошибки
Иногда ошибку отбрасывают через _: value, _ := strconv.Atoi("123") — строка заведомо число, проблем не будет. Но делать так по привычке — очень плохая идея: каждое _ вместо ошибки должно быть осознанным решением, иначе легко пропустить настоящую проблему. В продакшен-коде такие места стоит хотя бы мысленно перепроверять.
Свой тип ошибки и errors.As
Иногда одной строки мало: нужно вернуть, какое поле не прошло валидацию, какое значение пришло и что показать пользователю. Тогда делают свой тип ошибки — обычную структуру (15 — Структуры) с методом Error() string. Этого достаточно, чтобы тип стал ошибкой.
errors.As(err, &target) проверяет ошибку по типу: «Нет ли в цепочке *ValidationError?» Если есть, записывает найденную ошибку в target — отсюда указатель на переменную в вызове.
package main
import (
"errors"
"fmt"
)
type ValidationError struct {
Field string
Value any
Message string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("валидация поля %q: %s", e.Field, e.Message)
}
func validateUserAge(age int) error {
if age < 0 {
return &ValidationError{Field: "age", Value: age, Message: "не может быть отрицательным"}
}
if age > 150 {
return &ValidationError{Field: "age", Value: age, Message: "нереалистичный возраст"}
}
return nil
}
func register(age int) error {
if err := validateUserAge(age); err != nil {
return fmt.Errorf("регистрация: %w", err)
}
return nil
}
func main() {
err := register(-5)
fmt.Println(err)
var validErr *ValidationError
if errors.As(err, &validErr) { // ищет в цепочке ошибку нужного типа
fmt.Printf("поле %s, значение %v: %s\n", validErr.Field, validErr.Value, validErr.Message)
}
}регистрация: валидация поля "age": не может быть отрицательным
поле age, значение -5: не может быть отрицательнымerrors.Is |
errors.As |
|
|---|---|---|
| Проверяет | конкретное значение | тип ошибки |
| Типичная цель | sentinel: ErrNotFound |
свой тип: *ValidationError |
| Что даёт | true или false |
true или false + доступ к полям ошибки |
Цепочка в реальном коде
Функция делает несколько шагов: проверяет пользователя, ищет фильм, запускает стрим. На каждом шаге может возникнуть своя ошибка. Задача хорошего кода — не спрятать проблему, а сохранить причину и дописать, на каком этапе всё сломалось. Ошибка идёт снизу вверх, и каждый слой добавляет свой контекст.
package main
import (
"errors"
"fmt"
)
var (
ErrInvalidUser = errors.New("неверный пользователь")
ErrMovieNotFound = errors.New("фильм не найден")
)
func findMovieByID(id int) (string, error) {
if id == 42 {
return "", ErrMovieNotFound
}
return fmt.Sprintf("Фильм #%d", id), nil
}
func startMovieStream(user string, movieID int) error {
if user == "" {
return fmt.Errorf("авторизация: %w", ErrInvalidUser)
}
title, err := findMovieByID(movieID)
if err != nil {
return fmt.Errorf("загрузка: %w", err)
}
fmt.Printf("%s запускает %q\n", user, title)
return nil
}
func main() {
if err := startMovieStream("Алексей", 1); err != nil {
fmt.Println("стрим:", err)
}
if err := startMovieStream("Алексей", 42); err != nil {
fmt.Println("стрим:", err)
}
if err := startMovieStream("", 1); err != nil {
fmt.Println("стрим:", err, "| неверный пользователь?", errors.Is(err, ErrInvalidUser))
}
}Алексей запускает "Фильм #1"
стрим: загрузка: фильм не найден
стрим: авторизация: неверный пользователь | неверный пользователь? trueПо сообщению сразу видно, где упало: во втором вызове — на загрузке, в третьем — на авторизации. Так выглядит нормальный продакшен-код.
Практика
Домашнее задание: активация подписки
Пользователь вводит ID и дату, бэкенд проверяет данные. Внутри две проверки:
- Пользователь не найден → sentinel-ошибка
ErrUserNotFound. - Дата не разбирается в формате «год-месяц-день» → свой тип
ValidationErrorс полямиFieldиValue.
Снаружи должны работать и errors.Is, и errors.As — поэтому следи, как заворачиваешь цепочку.
решениеЭталонное решение
package main
import (
"errors"
"fmt"
"time"
)
var ErrUserNotFound = errors.New("пользователь не найден")
type ValidationError struct {
Field string
Value string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("некорректное поле %s: %q", e.Field, e.Value)
}
var users = map[int]string{1: "Алексей", 2: "Мария"}
func findUser(id int) (string, error) {
name, ok := users[id]
if !ok {
return "", fmt.Errorf("поиск пользователя %d: %w", id, ErrUserNotFound)
}
return name, nil
}
func parseDate(s string) (time.Time, error) {
d, err := time.Parse("2006-01-02", s) // формат «год-месяц-день»
if err != nil {
return time.Time{}, &ValidationError{Field: "date", Value: s}
}
return d, nil
}
func activateSubscription(userID int, date string) error {
name, err := findUser(userID)
if err != nil {
return fmt.Errorf("активация подписки: %w", err)
}
start, err := parseDate(date)
if err != nil {
return fmt.Errorf("активация подписки для %s: %w", name, err)
}
fmt.Printf("%s: подписка активна с %s\n", name, start.Format("02.01.2006"))
return nil
}
func report(err error) {
var vErr *ValidationError
switch {
case err == nil:
return
case errors.Is(err, ErrUserNotFound):
fmt.Println("404:", err)
case errors.As(err, &vErr):
fmt.Printf("400: поле %s = %q (%v)\n", vErr.Field, vErr.Value, err)
default:
fmt.Println("500:", err)
}
}
func main() {
report(activateSubscription(1, "2026-10-16"))
report(activateSubscription(7, "2026-10-16"))
report(activateSubscription(2, "16.10.2026"))
}Алексей: подписка активна с 16.10.2026
404: активация подписки: поиск пользователя 7: пользователь не найден
400: поле date = "16.10.2026" (активация подписки для Мария: некорректное поле date: "16.10.2026")Тренировка: предскажи вывод
package main
import (
"errors"
"fmt"
)
var ErrTimeout = errors.New("таймаут")
func main() {
e1 := fmt.Errorf("загрузка: %w", ErrTimeout)
e2 := fmt.Errorf("сервис: %w", e1)
e3 := fmt.Errorf("сервис: %v", e1)
fmt.Println(errors.Is(e2, ErrTimeout), errors.Is(e3, ErrTimeout))
fmt.Println(e3)
}самопроверкаОтвет
true false
сервис: загрузка: таймаутerrors.Is проходит по цепочке e2 → e1 → ErrTimeout. У e3 цепочка оборвана на %v, хотя текст тот же.
Проверь себя
вопросЧем обработка ошибок в Go отличается от try/catch?
Ошибка — обычное значение типа error, которое функция возвращает последним. Её проверяют сразу через if err != nil; ничего не летит вверх по стеку само.
вопросКогда использовать errors.New, а когда fmt.Errorf?
errors.New — для фиксированного текста и sentinel-ошибок. fmt.Errorf — когда в текст нужно подставить данные или обернуть причину через %w.
вопросЧто такое sentinel-ошибка и почему её объявляют на уровне пакета?
Заранее объявленное значение ошибки (var ErrNotFound = errors.New(…)), которое вызывающий код распознаёт через errors.Is. Два errors.New с одинаковым текстом — разные значения, поэтому ошибку создают один раз и переиспользуют.
вопросЧем %w отличается от %v в fmt.Errorf?
%w оборачивает ошибку и сохраняет связь с причиной для errors.Is и errors.As. %v вставляет только текст.
вопросЧем errors.Is отличается от errors.As?
Is ищет в цепочке конкретное значение и возвращает bool. As ищет ошибку определённого типа и записывает её в переданный указатель — так получают доступ к полям.
вопросЧто нужно, чтобы свой тип стал ошибкой?
Реализовать метод Error() string.
вопросЧто такое ранний возврат и зачем он нужен?
При обнаружении проблемы сразу возвращать ошибку. Основной сценарий остаётся без вложенных if, код читается сверху вниз.
Ключевые выводы
- 📮 Ошибка — значение типа
error, последнее в списке результатов; проверкаif err != nilсразу после вызова. - 🏷️ Sentinel-ошибки объявляют один раз на уровне пакета и распознают через
errors.Is. - 🧅
fmt.Errorf("контекст: %w", err)добавляет слой и сохраняет причину;%vеё теряет. - 🔎
errors.Is— по значению,errors.As— по типу, оба проходят всю цепочку. - 🧱 Свой тип ошибки — структура с методом
Error() string, когда нужны поля. - ↩️ Ранний возврат держит основной сценарий прямым и читаемым.
