K čemu se používá balíček context?

Question

Accepted Answer

Balíček **`context`** přenáší **signály zrušení, deadliny a hodnoty vymezené na požadavek** přes hranice API a goroutiny. Jedná se o standardní mechanismus pro řízení doby životnosti operací — zejména pro zrušení práce a šíření timeoutů přes řetězec volání funkcí.

## Základní problém, který řeší

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

## Vytváření kontextů

```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` odvozují podřízený kontext, který lze zrušit; musíte zavolat `defer cancel()` pro uvolnění jeho zdrojů.

## Reagování na zrušení

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

Funkce kontrolují `ctx.Done()` (kanál, který se zavře při zrušení) a zastaví se promptně — takto se zrušení skutečně šíří.

## Předávání kontextu přes řetězec volání (konvence)

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

Kontext se předává dolů zásobníkem volání jako první parametr, takže zrušení dosáhne každé vrstvy (včetně volání standardní knihovny DB/HTTP, která přijímá kontext).

## Hodnoty vymezené na požadavek (používejte zřídka)

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

## Proč je to důležité

Balíček `context` je zásadní pro psaní robustních Go služeb na úrovni výroby — jedná se o standardní, idiomatický způsob, jak zvládnout **zrušení a timeouty** přes goroutiny a hranice API.

Jeho primární hodnota spočívá v prevenci zbytečné práce a úniků zdrojů: když se klient odpojí, uplyne deadline nebo se server vypne, kontext šíří signál zrušení, aby všechny goroutiny a operace vytvořené pro daný požadavek zastavily promptně místo toho, aby běžely zbytečně (klíčová obrana proti únikům goroutin).

Je rozšířený v reálném Go — HTTP servery, volání databází, gRPC a většina síťových knihoven přijímá `context.Context` jako první parametr.

Porozumění tomu, jak vytvářet kontexty (`WithTimeout`/`WithCancel`), reagovat na zrušení (`<-ctx.Done()`), pravidlu must-call-`cancel()` a konvenci předávání kontextu přes řetězce volání je nezbytné pro vážnou práci na Go backendu a běžné téma v rozhovorech.