À quoi sert le package `context` ?

Question

Accepted Answer

Le package **`context`** transporte les **signaux d'annulation, les délais d'expiration et les valeurs limitées à la requête** à travers les limites d'API et les goroutines. C'est le mécanisme standard pour contrôler la durée de vie des opérations — notamment pour annuler le travail et propager les délais d'expiration à travers une chaîne d'appels de fonctions.

## Le problème fondamental qu'il résout

```text
A request starts work across many goroutines/functions (DB query, API call, etc.).
If the client disconnects or a timeout hits, you want to CANCEL all that work
so goroutines don't keep running uselessly (wasting resources / leaking).
→ context propagates the "stop now" signal down the entire call chain.
```

## Créer des contexts

```go
ctx := context.Background()          // the root context (top of the tree)
ctx := context.TODO()                 // placeholder when unsure

// with a timeout — auto-cancels after the duration
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()                        // ALWAYS call cancel to release resources

// with manual cancellation
ctx, cancel := context.WithCancel(context.Background())
// call cancel() to signal cancellation

// with a deadline (specific time)
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Minute))
```

`WithTimeout`/`WithDeadline`/`WithCancel` dérive un contexte enfant qui peut être annulé ; vous devez `defer cancel()` pour libérer ses ressources.

## Répondre à l'annulation

```go
func doWork(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():            // fires when cancelled or timed out
            return ctx.Err()           // returns context.Canceled or DeadlineExceeded
        case work := <-jobs:
            process(work)
        }
    }
}
```

Les fonctions vérifier `ctx.Done()` (un canal qui se ferme à l'annulation) et s'arrêtent rapidement — c'est ainsi que l'annulation se propage réellement.

## Passer le contexte à travers une chaîne d'appels (la convention)

```go
// ctx is conventionally the FIRST parameter, named ctx
func handler(ctx context.Context, ...) {
    data, err := fetchFromDB(ctx, id)   // pass it down — DB call honors cancellation
}
func fetchFromDB(ctx context.Context, id int) (...) {
    row := db.QueryRowContext(ctx, ...)  // standard-library APIs accept context
}
```

Le contexte circule vers le bas de la pile d'appels en tant que premier paramètre, de sorte que l'annulation atteint chaque couche (y compris les appels HTTP/base de données de la bibliothèque standard qui acceptent un contexte).

## Valeurs limitées à la requête (à utiliser avec modération)

```go
ctx = context.WithValue(ctx, requestIDKey, "abc-123")   // attach a value
id := ctx.Value(requestIDKey)                            // retrieve it downstream
// ⚠️ for request-scoped metadata (request IDs, auth) — NOT for passing regular params
```

## Pourquoi c'est important

Le package `context` est fondamental pour écrire des services Go robustes et prêts pour la production — c'est le moyen standard et idiomatique de gérer les **annulations et délais d'expiration** à travers les goroutines et les limites d'API.

Sa valeur principale est d'éviter le travail inutile et les fuites de ressources : quand un client se déconnecte, un délai expire ou un serveur s'arrête, le contexte propage le signal d'annulation de sorte que toutes les goroutines et opérations lancées pour cette requête s'arrêtent rapidement plutôt que de continuer inutilement (une défense clé contre les fuites de goroutines).

C'est omniprésent dans le Go réel — les serveurs HTTP, les appels de base de données, gRPC et la plupart des bibliothèques en réseau acceptent un `context.Context` en tant que premier paramètre.

Comprendre comment créer des contextes (`WithTimeout`/`WithCancel`), répondre à l'annulation (`<-ctx.Done()`), la règle qui stipule qu'il faut appeler `cancel()`, et la convention de passage du contexte à travers les chaînes d'appels est essentiel pour tout travail sérieux de backend Go et un sujet d'entretien courant.