Vad används `context`-paketet till?

Question

Accepted Answer

Paketet **`context`** för med sig **cancellationssignaler, deadlines och request-scoped values** över API-gränser och goroutines. Det är standardmekanismen för att kontrollera livslängden på operationer — särskilt för att avbryta arbete och sprida timeouts genom en kedja av funktionsanrop.

## Huvudproblemet det löser

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

## Skapa 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` härleder en child context som kan avbrytas; du måste `defer cancel()` för att frigöra dess resurser.

## Svara på cancellation

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

Funktioner kontrollerar `ctx.Done()` (en channel som stängs vid cancellation) och stannar omedelbar — så här sprids cancellation faktiskt.

## Skicka context genom en anropkedja (konventionen)

```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 flödar ned i anropsstacken som första parameter, så cancellation når varje lager (inklusive standard-library DB/HTTP-anrop som accepterar en context).

## Request-scoped values (använd sparsamt)

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

## Varför det spelar roll

Paketet `context` är fundamentalt för att skriva robust, produktionsklar Go-tjänster — det är standardsättet och det idiomatiska sättet att hantera **cancellation och timeouts** över goroutines och API-gränser.

Dess primära värde är att förhindra slösat arbete och resursläckage: när en klient kopplar från, en deadline passerar, eller en server stänger av, sprider context cancellationssignalen så alla goroutines och operationer som skapades för denna request stannar omedelbar istället för att köra meningslöst (ett viktigt försvar mot goroutine-läckor).

Det är genomgripande i verklig Go — HTTP-servrar, databasanrop, gRPC, och de flesta nätverksbibliotek accepterar en `context.Context` som första parameter.

Att förstå hur man skapar contexts (`WithTimeout`/`WithCancel`), svara på cancellation (`<-ctx.Done()`), regeln om att måste-anropa-`cancel()`, och konventionen att trådföra context genom anropkedjor är väsentligt för allt seriöst Go backend-arbete och ett vanligt intervjuämne.