Waar wordt het `context`-package voor gebruikt?

Question

Accepted Answer

Het **`context`**-package draagt **annuleringssignalen, deadlines en request-scoped waarden** over API-grenzen en goroutines heen. Het is het standaardmechanisme voor het controleren van de levensduur van operaties — vooral voor het annuleren van werk en het doorgeven van timeouts door een keten van functieaanroepen heen.

## Het kernprobleem dat het oplost

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

## Contexten aanmaken

```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` leiden een onderliggende context af die kan worden geannuleerd; je moet `defer cancel()` aanroepen om de resources vrij te geven.

## Reageren op annulering

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

Functies controleren `ctx.Done()` (een kanaal dat sluit bij annulering) en stoppen onmiddellijk — dit is hoe annulering daadwerkelijk wordt doorgegeven.

## Context doorgeven door een aanroepketen (de conventie)

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

Context vloeit de aanroepstack af als de eerste parameter, zodat annulering elk laag bereikt (inclusief standaard-library DB/HTTP-aanroepen die een context accepteren).

## Request-scoped waarden (gebruik voorzichtig)

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

## Waarom het belangrijk is

Het `context`-package is fundamenteel voor het schrijven van robuuste, productie-grade Go-services — het is de standaard, idiomatische manier om **annulering en timeouts** over goroutines en API-grenzen heen af te handelen.

De primaire waarde ervan is het voorkomen van verspilde arbeid en resource-leaks: wanneer een client zich afsluit, een deadline verstrijkt of een server wordt afgesloten, verspreidt context het annuleringssignaal zodat alle goroutines en operaties die voor die request zijn gegenereerd onmiddellijk stoppen in plaats van nutteloos door te lopen (een sleutelbescherming tegen goroutine-leaks).

Het is alomtegenwoordig in echte Go — HTTP-servers, databaseaanroepen, gRPC en de meeste netwerkbibliotheken accepteren een `context.Context` als hun eerste parameter.

Het begrijpen van hoe je contexten aanmaakt (`WithTimeout`/`WithCancel`), hoe je op annulering reageert (`<-ctx.Done()`), de regel dat je `cancel()` moet aanroepen, en de conventie van het doorgeven van context door aanroepketens is essentieel voor ernstig Go backend-werk en een veelvoorkomend interviewonderwerp.