¿Para qué se utiliza el paquete context?

Question

Accepted Answer

El paquete **`context`** transporta **señales de cancelación, plazos y valores con alcance de solicitud** a través de límites de API y goroutines. Es el mecanismo estándar para controlar la vida útil de las operaciones — especialmente para cancelar trabajo y propagar timeouts a través de una cadena de llamadas de función.

## El problema central que resuelve

```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.
```

## Crear contextos

```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` derivan un contexto secundario que se puede cancelar; debes `defer cancel()` para liberar sus recursos.

## Responder a la cancelación

```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)
        }
    }
}
```

Las funciones verifican `ctx.Done()` (un canal que se cierra en la cancelación) y se detienen prontamente — así es cómo se propaga la cancelación.

## Pasar contexto a través de una cadena de llamadas (la convención)

```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
}
```

El contexto fluye hacia abajo en la pila de llamadas como primer parámetro, por lo que la cancelación llega a cada capa (incluyendo llamadas DB/HTTP de la biblioteca estándar que aceptan un contexto).

## Valores con alcance de solicitud (úsalos con moderación)

```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
```

## Por qué es importante

El paquete `context` es fundamental para escribir servicios Go sólidos y de nivel de producción — es la forma estándar e idiomática de manejar **cancelación y timeouts** entre goroutines y límites de API.

Su valor principal es prevenir trabajo desperdiciado y fugas de recursos: cuando un cliente se desconecta, vence un plazo o se apaga un servidor, el contexto propaga la señal de cancelación para que todas las goroutines y operaciones generadas para esa solicitud se detengan prontamente en lugar de continuar inútilmente (una defensa clave contra fugas de goroutine).

Esta es ubicua en el Go real — servidores HTTP, llamadas de base de datos, gRPC y la mayoría de las bibliotecas de red aceptan `context.Context` como su primer parámetro.

Comprender cómo crear contextos (`WithTimeout`/`WithCancel`), responder a la cancelación (`<-ctx.Done()`), la regla must-call-`cancel()` y la convención de pasar contexto a través de cadenas de llamadas es esencial para cualquier trabajo serio de backend en Go y un tema común en entrevistas.