Можно ли передавать аргументы в context?

Можно ли передавать аргументы в context?

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

Почему это не рекомендуется?

1. Нарушение семантики context: Context должен содержать информацию, которая:

   • Распространяется по всей цепочке вызовов (например, в HTTP-запрос, через несколько уровней middleware и в БД).
   • Управляет жизненным циклом операции (отмена, таймаут).
   • Содержит immutable данные, которые не меняются после установки.

2. Проблемы с ясностью кода: Если аргументы «прячутся» в context, сигнатура функции становится неявной. Например:

   // ПЛОХО: Непонятно, что нужно передать в context
   func Process(ctx context.Context) error
   
   // ХОРОШО: Явные аргументы
   func Process(ctx context.Context, userID string, limit int) error
   

3. Типобезопасность: Значения в context хранятся как interface{} и извлекаются через context.Value(), что теряет проверку типов на этапе компиляции:

   // ПЛОХО: Риск ошибки типа
   ctx := context.WithValue(ctx, "userID", 123) // int, но ожидается string
   userID := ctx.Value("userID").(string) // panic!
   

Когда использовать context.Value()?

Только для сквозных (cross-cutting) данных, например:

• ID запроса для логирования и трассировки.
• Токены аутентификации (хотя лучше через отдельные middleware).
• Информация о режиме выполнения (debug, тестирование).

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

Обычные аргументы функции должны передаваться явно. Если данных много, можно сгруппировать их в структуру:

type RequestParams struct {
    UserID string
    Limit  int
    Filter string
}

func Process(ctx context.Context, params RequestParams) error {
    // Используем ctx для отмены, params для данных
}

Если требуется передать данные через context, делайте это через типизированные ключи:

type contextKey string

var userKey = contextKey("user")

func WithUser(ctx context.Context, user *User) context.Context {
    return context.WithValue(ctx, userKey, user)
}

func GetUser(ctx context.Context) (*User, bool) {
    user, ok := ctx.Value(userKey).(*User)
    return user, ok
}

Пример разделения ответственности

// Правильный подход: context для управления, аргументы для данных
func HandleHTTPRequest(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
    defer cancel()
    
    userID := r.FormValue("user_id")
    limit, _ := strconv.Atoi(r.FormValue("limit"))
    
    // Явная передача данных
    result, err := GetUserData(ctx, userID, limit)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    json.NewEncoder(w).Encode(result)
}

func GetUserData(ctx context.Context, userID string, limit int) ([]Data, error) {
    // Используем ctx для проверки отмены/таймаута
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    
    // Используем userID и limit для логики
    return db.Query(ctx, "SELECT ... WHERE user_id = ? LIMIT ?", userID, limit)
}

Ключевые выводы

• Context — не для аргументов: Он предназначен для управления жизненным циклом операций, а не для передачи основных параметров.
• Явное лучше неявного: Четкая сигнатура функции улучшает читаемость, тестируемость и безопасность типов.
• Используйте Value ограниченно: Только для сквозных данных, которые действительно нужны во многих местах цепочки вызовов.
• Альтернативы: Для передачи множества параметров используйте структуры, опции через функциональные опции (functional options) или явные аргументы.

Передача аргументов через context — распространенная ошибка новичков, которая ведет к спагетти-коду. Следуйте принципу: «Аргументы — для данных, context — для контроля».