Za kaj se uporablja paket `context`?

Question

Accepted Answer

Paket **`context`** prenaša **signale za preklic, roke in vrednosti omejene na zahtevo** čez meje API in goroutine. To je standardni mehanizem za nadzor trajanja operacij — zlasti za preklic dela in propagacijo časovnih omejitev skozi verigo klicev funkcij.

## Temeljni problem, ki ga rešuje

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

## Ustvarjanje kontekstov

```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` izpeljeta otroški kontekst, ki ga je mogoče prekiniti; obavezno morate klicati `defer cancel()`, da sprostite njegove vire.

## Odziv na preklic

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

Funkcije preverijo `ctx.Done()` (kanal, ki se zapre ob prekliču) in se takoj ustavijo — tako se preklic dejansko propagira.

## Prehajanje konteksta skozi verigo klicev (konvencija)

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

Kontekst teče navzdol po skladu klicev kot prvi parameter, zato preklic doseže vsak sloj (vključno s klic iz standardne knjižnice za bazo podatkov/HTTP, ki sprejme kontekst).

## Vrednosti omejene na zahtevo (redko uporabite)

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

## Zakaj je to pomembno

Paket `context` je temeljnega pomena za pisanje robustnih, produkcijskih Go storitev — to je standardni, idiomatski način za ravnanje s **prekliči in časovnimi omejitvami** čez goroutine in meje API.

Negova primarna vrednost je preprečevanje ničenega dela in puščanja virov: ko se odjemalec prekine, poteče rok ali se strežnik izključi, kontekst propagira signal za preklic, tako da se vse goroutine in operacije, porojene za to zahtevo, takoj ustavijo namesto da tečejo neuporabno (ključna zaščita pred puščanjem goroutine).

Je vseprisotna v pravem Go — HTTP strežniki, klici baz podatkov, gRPC in večina mrežnih knjižnic sprejemajo `context.Context` kot svoj prvi parameter.

Razumevanje ustvarjanja kontekstov (`WithTimeout`/`WithCancel`), odziva na preklic (`<-ctx.Done()`), pravila obveznega klicanja `cancel()` in konvencije prehajanja konteksta skozi verige klicev je bistveno za resno delo na backendu v Go in pogosta tема razgovora za zaposlitev.