Pentru ce este folosit pachetul `context`?

Question

Accepted Answer

Pachetul **`context`** transportă **semnale de anulare, deadline-uri și valori la nivel de cerere** peste limitele API-ului și goroutine-urilor. Este mecanismul standard pentru controlarea duratei de viață a operațiilor — în special pentru anularea lucrării și propagarea timeout-urilor prin lanțul de apeluri funcție.

## Problema principală pe care o rezolvă

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

## Crearea contextelor

```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` derivă un context copil care poate fi anulat; trebuie să apelezi `defer cancel()` pentru a elibera resursele acestuia.

## Răspunderea la anulare

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

Funcțiile verifică `ctx.Done()` (un canal care se închide la anulare) și se opresc prompt — aceasta este modul în care anularea se propagă de fapt.

## Trecerea contextului prin lanțul de apeluri (convenția)

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

Contextul curge în jos pe stiva de apeluri ca prim parametru, deci anularea ajunge la fiecare nivel (inclusiv apelurile din biblioteca standard DB/HTTP care acceptă un context).

## Valori la nivel de cerere (folosiți cu moderație)

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

## De ce contează

Pachetul `context` este fundamental pentru a scrie servicii Go robuste, de calitate producție — este modul standard, idiomativ de a gestiona **anularea și timeout-urile** peste goroutine-uri și limitele API-ului.

Valoarea sa primară este prevenirea risipei de lucru și scurgerilor de resurse: atunci când un client se deconectează, un deadline trece, sau un server se oprește, context propagă semnalul de anulare, astfel încât toate goroutine-urile și operațiile spawned pentru acea cerere se opresc prompt, mai degrabă decât să ruleze inutil (o apărare cheie împotriva scurgerilor de goroutine).

Este omniprezent în Go real — servere HTTP, apeluri la baza de date, gRPC și majoritatea bibliotecilor în rețea acceptă `context.Context` ca prim parametru.

Înțelegerea modului de a crea contextele (`WithTimeout`/`WithCancel`), a răspunde la anulare (`<-ctx.Done()`), regula care trebuie să apelezi `cancel()`, și convenția de a trece contextul prin lanțuri de apeluri este esențială pentru orice lucru serios pe backend cu Go și un subiect frecvent în interviuri.