Për çfarë përdoret paketa context?

Question

Accepted Answer

Paketa **`context`** përcjell **sinjale anulimi, afate kohore dhe vlera të fushëzës kërkesë** nëpër kufijtë e API-ve dhe goroutine-ve. Është mekanizmi standard për kontrollimin e kohëzgjatjes së operacioneve — veçanërisht për anulimin e punës dhe përhapjen e kohë-limiteve përmes një zinxhiri thirrjesh funksionesh.

## Problemi themelor që zgjidhet

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

## Krijimi i konteksteve

```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` dalin një kontekst të ri që mund të anulohet; duhet të bëni `defer cancel()` për të liruar burimet e tij.

## Përgjegjja ndaj anulimit

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

Funksionet kontrollojnë `ctx.Done()` (një kanal që mbyllet në anulim) dhe ndalojnë menjëherë — në këtë mënyrë anulimi përhapet në të vërtetë.

## Kalimi i kontekstit përmes një zinxhiri thirrjesh (konventa)

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

Konteksti rrjedh poshtë të stack-ut të thirrjeve si parametri i parë, kështu anulimi arrin çdo shtresë (përfshirë thirrjet e bibliotekës standarde DB/HTTP që pranojnë një kontekst).

## Vlerat e fushëzës kërkesë (përdorni me ekonomi)

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

## Përse është e rëndësishme

Paketa `context` është themelore për shkrimin e shërbimeve Go të fuqishëm dhe të nivelit prodhimi — është mënyra standarde, idiomatike për të trajtuar **anulimin dhe kohë-limitet** nëpër goroutine-ve dhe kufijtë e API-ve.

Vlera e tij parësore është parandalimi i punës të shpenzuar kotë dhe rrjedhjeve të burimeve: kur një klient shkëputet, një afat kalon, ose një shërbim mbyllet, konteksti përhap sinjalin e anulimit në mënyrë që të gjitha goroutine-t dhe operacionet e lindura për atë kërkesë të ndalojnë menjëherë në vend se të funksionojnë pa dobi (një mbrojtje kyçe kundër rrjedhjeve të goroutine-ve).

Është e përhapur në Go-n e vërtetë — shërbime HTTP, thirrje baze të dhënash, gRPC dhe shumica e bibliotekave në rrjet pranojnë një `context.Context` si parametrin e tyre të parë.

Kuptime se si të krijohen kontekste (`WithTimeout`/`WithCancel`), si të përgjigjet ndaj anulimit (`<-ctx.Done()`), rregulli i detyrueshëm-thirr-`cancel()`, dhe konventa e kalimit të kontekstit përmes zinxhireve thirrjesh është thelbësore për çdo punë seriozë Go backend-i dhe është një temë e zakonshme në intervista.