Как передать в Defer результат выполнения функции?

Проблема передачи результата функции в Defer

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

Неправильный подход

func example() error {
    defer fmt.Println("Результат:", someFunction()) // Неправильно!
    
    // someFunction() вызовется СРАЗУ при объявлении defer
    // а не при завершении example()
    return nil
}

Правильные способы передачи результата в Defer

### 1. Использование анонимной функции (наиболее распространённый способ)

func processFile() (result int, err error) {
    file, err := os.Open("data.txt")
    if err != nil {
        return 0, err
    }
    
    defer func() {
        // Анонимная функция имеет доступ к result и err
        fmt.Printf("Закрытие файла. Результат: %d, Ошибка: %v\n", result, err)
        file.Close()
    }()
    
    // ... обработка файла ...
    result = 42
    return result, nil
}

Ключевой момент: анонимная функция замыкает переменные result и err, поэтому она получает их актуальные значения на момент выполнения.

### 2. Использование именованных возвращаемых значений

Этот способ тесно связан с первым, так как именованные возвращаемые значения делают код чище:

func calculate() (total int, err error) {
    defer func() {
        if total > 100 {
            fmt.Println("Большой результат:", total)
        }
        if err != nil {
            fmt.Println("Операция завершилась с ошибкой:", err)
        }
    }()
    
    // ... логика вычислений ...
    total = 150
    return total, nil
}

### 3. Передача указателей на переменные

func process() error {
    var result string
    var statusCode int
    
    defer func(r *string, sc *int) {
        fmt.Printf("Результат: %s, Код: %d\n", *r, *sc)
        // Можем даже модифицировать результат через указатель
    }(&result, &statusCode)
    
    // ... вычисления ...
    result = "success"
    statusCode = 200
    
    return nil
}

### 4. Сохранение результата во внешнюю переменную перед defer

func worker() {
    var finalResult string
    
    // Сохраняем результат в переменную
    res := compute()
    finalResult = res
    
    defer func() {
        logResult(finalResult)
    }()
    
    // ... дополнительная обработка ...
}

Важные нюансы и best practices

### Захват переменных в замыканиях

Важно понимать, как именно работает захват переменных:

func trickyExample() {
    for i := 0; i < 3; i++ {
        defer func() {
            fmt.Println(i) // Всегда выведет 3!
        }()
    }
    // Выведет: 3 3 3
}

// Правильный вариант:
func correctExample() {
    for i := 0; i < 3; i++ {
        i := i // Создаём локальную копию
        defer func() {
            fmt.Println(i) // Выведет 2, 1, 0
        }()
    }
}

### Взаимодействие с panic и recover

Defer с доступом к результатам особенно полезен при обработке паник:

func safeOperation() (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic recovered: %v", r)
            result = -1
        }
    }()
    
    // Код, который может вызвать panic
    result = riskyCalculation()
    return result, nil
}

### Производительность и оптимизация

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

// Более эффективно, но менее читаемо
func optimizedFunc() (res int, err error) {
    var deferredCleanup func()
    
    // Настраиваем отложенную функцию
    if условие {
        deferredCleanup = func() { cleanupA(res) }
    } else {
        deferredCleanup = func() { cleanupB(res) }
    }
    
    defer deferredCleanup()
    
    // ... основная логика ...
    return 42, nil
}

Практический пример из реального проекта

func HandleHTTPRequest(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    var statusCode int
    var responseSize int
    
    defer func() {
        // Используем результаты обработки запроса
        duration := time.Since(start)
        log.Printf(
            "Запрос %s %s - Статус: %d, Размер: %d байт, Время: %v",
            r.Method, r.URL.Path, statusCode, responseSize, duration,
        )
    }()
    
    // Обработка запроса
    data, err := processRequest(r)
    if err != nil {
        statusCode = http.StatusInternalServerError
        http.Error(w, err.Error(), statusCode)
        return
    }
    
    responseBytes := []byte(data)
    responseSize = len(responseBytes)
    statusCode = http.StatusOK
    
    w.WriteHeader(statusCode)
    w.Write(responseBytes)
}

Заключение

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

• Логирования результатов операций
• Очистки ресурсов с учётом результата операции
• Обработки ошибок и паник
• Сбора метрик и телеметрии

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