Hva brukes kontekst-pakken til?

Question

Accepted Answer

**`context`**-pakken bærer **avslutningssignaler, frister og forespørsels-relaterte verdier** på tvers av API-grenser og goroutines. Det er standardmekanismen for å kontrollere levetiden til operasjoner — spesielt for å avbryte arbeid og propagere tidsgrenser gjennom en kjede av funksjonsanrop.

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

## Lage kontekster

```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` henter en barnkontekst som kan avbrytes; du må `defer cancel()` for å frigjøre ressursene.

## Respondere på avbrytelse

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

Funksjoner sjekker `ctx.Done()` (en kanal som lukkes ved avbrytelse) og stopper raskt — dette er hvordan avbrytelse faktisk propageres.

## Å sende kontekst gjennom en samtalekjede (konvensjonen)

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

Konteksten flyter ned i samtalestabelen som første parameter, slik at avbrytelse når hvert lag (inkludert standardbibliotekets DB/HTTP-anrop som godtar en kontekst).

## Forespørsels-relaterte verdier (bruk sparsommelig)

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

## Hvorfor det er viktig

**`context`**-pakken er fundamental for å skrive robuste, produksjonsklar Go-tjenester — det er standardmåten, idiomatisk måte å håndtere **avbrytelse og tidsgrenser** på tvers av goroutines og API-grenser.

Itsprimære verdi er å forhindre bortkastet arbeid og ressurslekkasjer: når en klient kobler fra, en frist går ut, eller en server avslutter, propagerer konteksten avslutningssignalet slik at alle goroutines og operasjoner som er opprettet for den forespørselen stopper raskt i stedet for å kjøre unyttig (en nøkkelforsvar mot goroutine-lekkasjer).

Det er gjennomgripende i ekte Go — HTTP-servere, databaseanrop, gRPC og de fleste nettverksbiblioteker godtar en `context.Context` som deres første parameter.

Å forstå hvordan du lager kontekster (`WithTimeout`/`WithCancel`), respondere på avbrytelse (`<-ctx.Done()`), må-kalle-`cancel()`-regelen, og konvensjonen med å lede kontekst gjennom samtalekjeder er essensielt for alt alvorlig Go backend-arbeid og et vanlig intervjuemne.