Перейти к основному содержимому

5.10. Функции и методы

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Функции и методы​

Функции в языке Go — это основная единица логического объединения кода. В отличие от некоторых других языков, где функции могут быть вложенными или определяться внутри других функций (например, как в Python или JavaScript), в Go функции объявляются только на верхнем уровне пакета — вне тел других функций. Это подчёркивает декларативный и структурированный характер языка и способствует чёткому разделению ответственности, упрощая анализ, тестирование и поддержку кода.

Определение функции​

Синтаксис объявления функции в Go начинается с ключевого слова func, за которым следует:

  1. Имя функции — идентификатор, подчиняющийся общим правилам именования в Go (буквы, цифры, знак подчёркивания; первая буква не может быть цифрой; регистр имеет значение);
  2. Список параметров в круглых скобках — каждый параметр указывается как имя тип, при этом последовательные параметры одного типа могут объединяться через запятую с общим указанием типа в конце;
  3. (Опционально) список возвращаемых значений — может быть пустым (ничего не возвращается), содержать один или несколько типов, а также может быть задан с именованными возвращаемыми значениями;
  4. Тело функции в фигурных скобках { }, содержащее исполняемые инструкции.

Пример базовой функции без параметров и без возвращаемого значения:

func greet() {
    fmt.Println("Здравствуйте!")
}

Функция с параметрами и одним возвращаемым значением:

func add(a, b int) int {
    return a + b
}

Функция с несколькими параметрами разного типа:

func describe(name string, age int, active bool) string {
    return fmt.Sprintf("Пользователь %s, возраст %d, активен: %t", name, age, active)
}

Обратите внимание: в Go не допускается перегрузка функций — то есть, в пределах одного пакета не могут существовать две функции с одинаковыми именами, даже если их сигнатуры различаются. Это ограничение введено сознательно, чтобы избежать неоднозначности при вызове и повысить предсказуемость поведения программы. Если требуется разная логика для разных наборов аргументов, рекомендуется использовать разные имена (например, parseString, parseInt), либо применять функции с переменным числом аргументов.

Соглашения об именовании​

Имена функций в Go должны быть чёткими, выразительными и отражать выполняемое действие. В подавляющем большинстве случаев имя функции — это глагол или глагольное словосочетание: calculateTotal, validateInput, fetchUser, writeToFile. Это соответствует принципу self-documenting code — код, который говорит о своём назначении через структуру и имена.

Функции, возвращающие логическое значение, часто именуются с префиксом is, has, can, should — например, isValid, hasPermission, canConnect, shouldRetry. Такое именование позволяет без дополнительных комментариев понять, что функция проверяет условие и возвращает булев результат.

В Go не принято скрывать побочные эффекты или важные состояния в имени функции. Например, если функция проверяет и создаёт ресурс при его отсутствии, имя должно это отражать: ensureDirectory, acquireLock, initializeIfNeeded. Это требование вытекает из общей философии языка — «простота через прозрачность».

Параметры функции​

Параметры функции в Go передаются по значению. Это означает, что при вызове функции создаётся копия аргумента, и изменения внутри функции не влияют на исходную переменную в вызывающем коде. Исключение составляют ссылочные типы — такие как срезы, карты, каналы и указатели: они сами по себе являются дескрипторами, содержащими ссылку на данные в куче. При передаче таких значений копируется дескриптор, а не подлежащие данные, поэтому изменения содержимого среза или карты внутри функции будут видны снаружи.

Например:

func modifySlice(s []int) {
    s[0] = 999 // изменение элемента — видно снаружи
    s = append(s, 42) // изменение дескриптора (длина/ёмкость) — НЕ видно снаружи
}

Здесь модификация элемента среза проявится в вызывающем коде, поскольку оба дескриптора ссылаются на одну и ту же область памяти. Однако операция append, увеличивающая длину, может привести к выделению нового буфера — и тогда копия дескриптора внутри функции будет указывать на новую память, тогда как внешний срез останется неизменённым.

Если требуется гарантированно изменить структуру или базовый тип (например, int, string, struct), необходимо передавать указатель:

func increment(n *int) {
    *n++
}

Это стандартная идиома в Go — явное использование указателей там, где предполагается модификация состояния. Такой подход делает намерения разработчика прозрачными и избегает неожиданного поведения.

Возврат значений​

Go поддерживает множественный возврат — функция может возвращать одновременно несколько значений любого типа. Наиболее распространённый паттерн — возврат основного результата и ошибки:

func openFile(path string) (*os.File, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    return f, nil
}

Здесь возвращаются два значения: указатель на открытый файл (*os.File) и ошибка (error). Важно: в Go ошибки являются значениями, а не исключениями. Они не прерывают поток выполнения автоматически — их необходимо проверять явно.

Явный возврат и обработка ошибок​

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

file, err := openFile("data.txt")
if err != nil {
    // обработка ошибки: логирование, возврат, преобразование и т.п.
    log.Fatal("Не удалось открыть файл:", err)
}
// продолжение работы с file — безопасно, т.к. err == nil

Такой подход обеспечивает локальность обработки: ошибка рассматривается сразу после её возникновения, в контексте конкретной операции, что упрощает отладку и повышает надёжность. Сокрытие ошибки (например, через _ при присваивании: file, _ := openFile(...)) считается антипаттерном и допустимо только в редких случаях, когда разработчик сознательно пренебрегает проверкой (например, в тестах или при работе с заведомо корректными данными).

Именованные возвращаемые значения​

Go позволяет задавать имена для возвращаемых значений прямо в сигнатуре функции:

func divide(a, b float64) (result float64, err error) {
    if b == 0 {
        err = errors.New("деление на ноль")
        return // "голый return" — возвращает текущие значения result (0.0) и err
    }
    result = a / b
    return // возвращает вычисленные result и nil (т.к. err не переопределён)
}

При таком объявлении переменные result и err автоматически объявляются в начале тела функции и инициализируются нулевыми значениями своих типов. Возврат без аргументов (return) — так называемый naked return — возвращает текущие значения этих переменных.

Когда использовать именованные возвращаемые значения?
Их стоит применять, когда:

  • функция возвращает несколько значений, и их смысл неочевиден из контекста;
  • в теле функции несколько точек возврата, и использование имён упрощает чтение (например, при раннем выходе по ошибке);
  • требуется единообразие в пакете (например, все функции, возвращающие (T, error), используют имена value, err).

Однако злоупотреблять этим механизмом не рекомендуется — особенно в коротких функциях, где имена параметров и так ясны. Naked return может ухудшить читаемость, если тело функции велико: не сразу понятно, какие значения возвращаются, и где они были установлены. Поэтому в длинных функциях предпочтительнее использовать явный return value, err.

Методы: функции, привязанные к типам​

В Go нет классов в традиционном смысле, но существует механизм, позволяющий связывать функции с пользовательскими типами — это методы. Метод — это функция, объявленная с дополнительным параметром, называемым получателем (receiver). Получатель указывается перед именем функции и определяет, к какому типу привязан метод.

Синтаксис объявления метода:

func (r ReceiverType) MethodName(params) ReturnType {
    // тело метода
}

Здесь r — имя получателя (аналог this или self в других языках), ReceiverType — тип, к которому привязывается метод. Получатель может быть как значением, так и указателем:

  • (r T) — метод с получателем-значением;
  • (r *T) — метод с получателем-указателем.

Различие между ними принципиально: при вызове метода с получателем-значением создаётся копия экземпляра, и все изменения внутри метода не затрагивают исходный объект. При получателе-указателе метод работает с оригинальным экземпляром, что позволяет изменять его состояние.

Когда использовать указатель в качестве получателя?​

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

Рассмотрим пример:

type Counter struct {
    value int
}

// Некорректно: метод не сможет изменить исходный экземпляр
func (c Counter) Increment() {
    c.value++ // изменяется копия; исходный объект остаётся неизменным
}

// Корректно: метод изменяет исходный экземпляр
func (c *Counter) SafeIncrement() {
    c.value++
}

Если вызвать Increment() на переменной типа Counter, поле value не увеличится. В то же время SafeIncrement() работает ожидаемо.

Существует также второе, менее очевидное правило: даже если метод не изменяет состояние, но получатель — большая структура, предпочтительно использовать указатель, чтобы избежать ненужного копирования. Хотя компилятор Go в некоторых случаях может оптимизировать копирование (например, если метод не экспортируется и не вызывается извне), явное использование указателя делает намерения ясными и гарантирует эффективность.

Go допускает автоматическое разыменование и автоматическое взятие адреса при вызове методов. Это означает, что:

  • метод с получателем-указателем (*T).M() может быть вызван как на значении x T, так и на указателе p *T;
  • метод с получателем-значением (T).M() может быть вызван только на значении x T, но не на nil-указателе.

Однако при вызове метода с получателем-указателем на значении x компилятор неявно создаёт временный указатель &x и вызывает метод на нём. Это безопасно, пока x не является некорректным (например, не содержит nil в полях-указателях, к которым обращается метод).

Интерфейсы и методы​

Методы играют ключевую роль в реализации интерфейсов. В Go интерфейс определяет набор сигнатур методов, и любой тип, у которого есть методы с совпадающими сигнатурами, автоматически удовлетворяет этому интерфейсу — даже если разработчик не объявлял это явно (structural typing).

Например:

type Stringer interface {
    String() string
}

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("%s (%d лет)", p.Name, p.Age)
}

Тип Person удовлетворяет интерфейсу Stringer, потому что у него есть метод String() string. Обратите внимание: метод объявлен с получателем-значением. Это допустимо, так как метод не изменяет состояние. Если бы методу требовалось менять Person, пришлось бы объявить его как (p *Person) String() string, и тогда только *Person удовлетворял бы интерфейсу Stringer, а Person — нет.

Это подчёркивает важность согласованности: в пакете следует придерживаться единого подхода к выбору типа получателя для методов одного типа — либо все методы используют указатель, либо все — значение (за редкими исключениями, когда семантика действительно различается).

Анонимные функции​

Анонимная функция в Go — это функция, не имеющая имени при объявлении. Она определяется с помощью того же ключевого слова func, но без идентификатора. Такая функция может быть:

  • присвоена переменной;
  • передана как аргумент другой функции;
  • вызвана немедленно после определения.

Синтаксис анонимной функции идентичен обычной, за исключением отсутствия имени:

func(parameters) ReturnType {
    // тело
}

Присвоение переменной​

Анонимная функция может быть присвоена переменной, после чего переменная становится вызываемой как обычная функция:

greet := func(name string) string {
    return "Привет, " + name + "!"
}

message := greet("Алексей") // "Привет, Алексей!"

Тип переменной greet в этом случае выводится как func(string) string — функциональный тип. Такие типы в Go являются first-class citizens: их можно присваивать, передавать, возвращать, хранить в структурах и срезах.

Функциональные типы могут быть также объявлены явно через type, что повышает читаемость и обеспечивает переиспользование сигнатур:

type GreetingFunc func(string) string

var greeter GreetingFunc = func(name string) string {
    return "Здравствуйте, " + name
}

Замыкания​

Одна из наиболее мощных особенностей анонимных функций — их способность захватывать переменные из окружающей области видимости, формируя замыкание (closure). Захваченные переменные сохраняются на время жизни функции, даже если внешняя область уже завершила выполнение.

Пример:

func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

c1 := makeCounter()
c2 := makeCounter()

fmt.Println(c1()) // 1
fmt.Println(c1()) // 2
fmt.Println(c2()) // 1 — независимый счётчик

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

Замыкания широко применяются для создания фабрик, конфигурируемых обработчиков, функций с сохранённым состоянием (например, middleware в HTTP-серверах), а также для инкапсуляции данных без использования структур.

Передача в качестве аргумента​

Анонимные функции часто используются как коллбэки. Например, стандартная библиотека предоставляет функции, принимающие функции сравнения для сортировки:

people := []string{"Мария", "Алексей", "Екатерина"}

// Сортировка по длине имени
sort.Slice(people, func(i, j int) bool {
    return len(people[i]) < len(people[j])
})
// Результат: ["Мария", "Алексей", "Екатерина"] → ["Мария", "Алексей", "Екатерина"] (длины: 5, 6, 8)

Функция sort.Slice принимает срез и анонимную функцию, определяющую порядок. Такой подход обеспечивает гибкость без необходимости создания отдельных именованных функций для каждой уникальной логики сравнения.

Аналогично, в HTTP-обработчиках:

http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "OK")
})

Анонимная функция здесь выступает как обработчик маршрута — компактно, локально, без загрязнения глобального пространства имён.

Немедленно вызываемые функции (IIFE-подобные конструкции)​

В экосистеме JavaScript термин IIFE (Immediately Invoked Function Expression) обозначает анонимную функцию, определённую и вызванную в одном выражении. В Go нет прямого эквивалента по синтаксису, но семантически аналогичные конструкции возможны и идиоматичны.

Общий шаблон:

(func() {
    // код, выполняемый немедленно
})()

Здесь анонимная функция оборачивается в скобки и сразу вызывается с помощью (). Такая форма применяется, когда требуется:

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

Пример: инициализация сложной структуры с проверкой:

config := (func() *Config {
    raw, err := os.ReadFile("config.json")
    if err != nil {
        log.Fatalf("Не удалось прочитать конфиг: %v", err)
    }
    var cfg Config
    if err := json.Unmarshal(raw, &cfg); err != nil {
        log.Fatalf("Некорректный формат конфига: %v", err)
    }
    return &cfg
})()

Переменная config получает результат выполнения анонимной функции. Внутри неё можно использовать локальные переменные (raw, err, cfg), которые не засоряют внешнюю область. Это особенно полезно в инициализационных блоках, init()-функциях или при построении константных значений на этапе выполнения.

В Go IIFE не используется для создания приватных замыканий в глобальной области (как в JS), потому что Go уже имеет строгие правила видимости (регистр первой буквы определяет экспорт). Основная цель — инкапсуляция логики инициализации.

Модули в Go​

Система модулей в Go — это механизм управления зависимостями и версиями на уровне проекта. Модуль — это коллекция пакетов, распространяемая как единое целое, с чётко определённой точкой входа и метаданными.

Файл go.mod: точка входа модуля​

Ключевой признак модуля — наличие файла go.mod в корневом каталоге проекта. Этот файл создаётся командой go mod init имя_модуля и содержит:

  • директиву module, задающую путь модуля (обычно — URL-подобная строка, например, github.com/user/project);
  • директиву go, указывающую минимальную версию языка Go, с которой совместим модуль;
  • (опционально) директивы require, exclude, replace, управляющие зависимостями.

Пример go.mod:

module example.com/myapp

go 1.22

require (
    github.com/sirupsen/logrus v1.9.3
    golang.org/x/text v0.14.0
)

Наличие go.mod сообщает инструментам Go (включая go build, go test, go mod tidy), что текущий каталог — корень модуля. Без этого файла Go ведёт себя в режиме GOPATH, где зависимости ищутся в едином глобальном каталоге, — подход, признанный устаревшим с выходом Go 1.11 (2018 г.).

Версионирование и семантическое управление​

Go использует семантическое версионирование (SemVer) для зависимостей: MAJOR.MINOR.PATCH. Компилятор строго соблюдает правило минимальной версии: если в go.mod указана v1.9.3, будет использована эта или более поздняя версия в пределах v1.x.x, но никогда v2.0.0+, поскольку это может нарушить обратную совместимость.

Для мажорных версий (начинающихся с v2+) применяется требование импортного пути с суффиксом версии: github.com/user/lib/v2. Это позволяет нескольким мажорным версиям одного модуля сосуществовать в одном проекте без конфликтов.

Файл go.sum: контроль целостности​

Параллельно с go.mod создаётся и обновляется файл go.sum. Он содержит криптографические хэши содержимого каждого зависимого модуля — как прямых, так и транзитивных. При сборке Go проверяет, что скачанные архивы совпадают с зафиксированными хэшами. Это защищает от подмены зависимостей (атаки supply chain).

Файл go.sum не предназначен для редактирования вручную. Его содержимое управляется командами go get, go mod tidy, go build.

Внутренние модули и replace​

Директива replace позволяет переопределить источник модуля — например, использовать локальную копию вместо удалённой:

replace github.com/user/experimental => ../experimental

Это незаменимо при разработке нескольких связанных модулей одновременно: изменения в experimental вступают в силу сразу, без публикации релиза. Также replace помогает при отладке, интеграционном тестировании и работе с форками.

Важно: replace действует только при сборке текущего модуля. Он не попадает в go.mod зависимых проектов и не влияет на их сборку — это локальное переопределение.

Как модули влияют на функции​

Хотя модули управляют пакетами, а не функциями напрямую, они оказывают косвенное, но глубокое влияние на то, как функции используются:

  • Функции из внешних модулей доступны только после объявления зависимости в go.mod;
  • Экспорт функции (видимость за пределами пакета) по-прежнему определяется регистром первой буквы имени (PublicFunc vs privateFunc);
  • Версионирование модулей гарантирует, что сигнатура функции, на которую рассчитывает вызывающий код, не изменится неожиданно в пределах совместимой версии.

Функции как значения: композиция и конвейеры​

В Go функции — это полноценные значения. Это позволяет строить программы, в которых логика выражается через комбинацию небольших, переиспользуемых функций. Хотя язык не поддерживает встроенные операторы для каррирования или частичного применения (в отличие от Haskell или Scala), эти паттерны реализуются вручную с помощью анонимных функций и замыканий.

Каррирование​

Каррирование — преобразование функции от нескольких аргументов в цепочку функций, каждая из которых принимает один аргумент. В Go это достигается возвратом анонимной функции из функции:

func add(x int) func(int) int {
    return func(y int) int {
        return x + y
    }
}

add5 := add(5)
result := add5(3) // 8

Здесь add(5) возвращает функцию, «запоминающую» значение x = 5. Такой подход полезен, когда один или несколько параметров известны заранее, а остальные поступают позже — например, при конфигурировании middleware или построении генераторов данных.

Важно: каррирование в Go не даёт автоматической оптимизации, как в некоторых функциональных языках. Каждое промежуточное замыкание создаёт новую функцию в куче. Поэтому его следует применять осознанно — там, где выигрыш в выразительности и повторном использовании перевешивает накладные расходы на аллокации.

Композиция функций​

Композиция — объединение двух или более функций в одну, где выход одной подаётся на вход следующей. В Go композиция не встроена на уровне синтаксиса, но легко выражается:

func compose(f, g func(string) string) func(string) string {
    return func(s string) string {
        return f(g(s))
    }
}

toUpper := strings.ToUpper
addPrefix := func(s string) string { return "Префикс: " + s }

processor := compose(addPrefix, toUpper)
result := processor("тест") // "Префикс: ТЕСТ"

Обратите внимание на порядок: compose(f, g) даёт f ∘ g, то есть f(g(x)). Это соответствует математическому соглашению, но может быть контринтуитивно при чтении слева направо. Чтобы избежать путаницы, в реальном коде часто предпочитают явную запись цепочки:

s := input
s = toUpper(s)
s = addPrefix(s)

— или используют конвейерные структуры (см. ниже). Композиция оправдана, когда одна и та же цепочка вызовов повторяется многократно.

Конвейеры обработки данных​

Один из самых идиоматичных способов применения функций как значений в Go — построение конвейеров (pipelines) на основе каналов и горутин. В таком подходе функции преобразуют поток данных, передавая результат по каналу.

Пример: обработка чисел — фильтрация, возведение в квадрат, суммирование:

func generate(nums []int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            out <- n
        }
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in {
            out <- n * n
        }
    }()
    return out
}

func sum(in <-chan int) int {
    total := 0
    for n := range in {
        total += n
    }
    return total
}

// Использование:
nums := []int{1, 2, 3, 4}
result := sum(square(generate(nums))) // 30

Каждая функция принимает канал на вход и возвращает канал на выход. Такой стиль обеспечивает:

  • Декомпозицию — каждая стадия отвечает за одну операцию;
  • Параллелизм — стадии работают одновременно, данные протекают по каналам;
  • Составляемость — можно вставлять новые этапы (например, filterEven) без изменения существующих.

Хотя конвейеры требуют больше кода, чем циклы в одном потоке, они масштабируются на многопроцессорные системы и позволяют эффективно обрабатывать большие объёмы данных без полной загрузки памяти.

Отложенный вызов: defer​

Конструкция defer позволяет отложить выполнение вызова функции (или метода) до завершения текущей функции. Отложенные вызовы выполняются в порядке LIFO (last in, first out), то есть последний объявленный defer сработает первым.

Синтаксис:

defer выражение_вызова

Выражение должно быть вызовом функции или метода. Аргументы вычисляются немедленно, при встрече defer, но сам вызов происходит позже.

Пример:

func readFile(path string) ([]byte, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer f.Close() // Close() будет вызван при выходе из readFile

    return io.ReadAll(f)
}

Здесь f.Close() гарантированно выполнится, даже если io.ReadAll вернёт ошибку или произойдёт паника. Это ключевой паттерн для управления ресурсами: файлы, соединения, мьютексы, транзакции — всё, что требует явного освобождения.

Как defer работает с методами?​

Если откладывается вызов метода, тип получателя сохраняется. Например:

type Locker struct {
    mu sync.Mutex
}

func (l *Locker) Lock()   { l.mu.Lock() }
func (l *Locker) Unlock() { l.mu.Unlock() }

func criticalSection(l *Locker) {
    l.Lock()
    defer l.Unlock() // вызывает (*Locker).Unlock() на том же экземпляре
    // ... критическая секция
}

Здесь l — указатель, и defer l.Unlock() корректно разыменует его при выходе. Если бы метод Unlock был объявлен как (l Locker) Unlock(), то при вызове через defer использовалась бы копия структуры, и мьютекс не разблокировался бы — что привело бы к взаимной блокировке. Это ещё раз подчёркивает важность согласованного выбора типа получателя.

Производительность defer​

До Go 1.14 defer имел измеримые накладные расходы из-за динамического управления стеком отложенных вызовов. Начиная с Go 1.14, компилятор оптимизирует большинство случаев defer, встраивая код напрямую при выходе из функции (так называемый open-coded defer), при условии, что вызов defer не находится в цикле и не зависит от условий. Это делает defer практически бесплатным в типичных сценариях управления ресурсами.

Паника и восстановление: panic и recover​

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

Типичные случаи применения panic:

  • Обращение к неинициализированному интерфейсу (nil-указатель разыменован);
  • Выход за пределы среза (index out of range);
  • Некорректное приведение типов (type assertion без проверки);
  • Явный вызов panic("invariant violated") в библиотечном коде при обнаружении внутренней несогласованности.

Вызов panic прерывает выполнение текущей функции, запускает все отложенные вызовы (defer), затем передаёт управление вызывающей функции — и так до корня стека, либо пока не встретится recover.

recover: перехват паники​

Функция recover может быть вызвана только внутри отложенной функции и возвращает значение, переданное в panic, или nil, если паники не было.

Шаблон безопасного перехвата:

func safeCall(f func()) (recovered interface{}) {
    defer func() {
        if r := recover(); r != nil {
            recovered = r
        }
    }()
    f()
    return nil
}

Здесь recover() вызывается в defer, что позволяет остановить распространение паники и преобразовать её в обычное значение. Однако:

  • Нельзя перехватить панику из другой горутины — recover работает только в стеке той горутины, где произошла паника;
  • Не следует использовать panic/recover для управления потоком выполнения (например, для «бросания исключений» при валидации входных данных) — это нарушает идиомы Go и затрудняет анализ кода;
  • Стандартная библиотека использует panic только в крайних случаях (например, regexp.MustCompile паникует при неверном регулярном выражении — потому что ошибка статическая и должна обнаруживаться на этапе разработки).

Рекомендуется: если библиотека может столкнуться с некорректными входными данными в рантайме, она должна возвращать error, а не вызывать panic. Вызов panic оправдан только при доказуемо невозможных состояниях — например, при нарушении контракта, защищённого статическим анализом.