Cad a úsáidtear an pacáiste `context` a dhéanamh?

Question

Accepted Answer

Iompraíonn an pacáiste **`context`** **comharthaí cealaithe, teorainneacha ama, agus luachanna fálrainn ar iarratas** trasna teorainn API agus goroutines. Is é an meicníochas caighdeánach é chun saolré oibríochtaí a rialú — go háirithe d'obair a chealú agus timeouts a scaipeadh trí bhraistíneach glaochanna feidhme.

## An fhadhb bhunúsach a réitíonn sé

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

## Comhthéacsanna a chruthú

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

Díorthraíonn `WithTimeout`/`WithDeadline`/`WithCancel` comhthéacs linbh is féidir a chealú; caithfidh tú `defer cancel()` a ghlaoch chun a acmhainní a scaoileadh saor.

## Freagairt ar chealaithe

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

Deimhnítear feidhmeanna `ctx.Done()` (an tseanal a dhúntar ar chealaithe) agus stad go pras — is é seo conas a scaipíonn cealaithe i ndáiríre.

## Comhthéacs a rith tríd an bhraistín glaochanna (an ghnáth-chleachtas)

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

Fluann comhthéacs síos an bhraistín glaochanna mar an chéad pharaiméadar, ionas go sroichann cealaithe gach sraith (lena n-áirítear glaochanna caighdeánach-leabharlainne DB/HTTP a ghlacann comhthéacs).

## Luachanna fálrainn ar iarratas (úsáid go spáistúil)

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

## Cad a bhraithim ann

Is bunúsach an pacáiste `context` a bheith ann chun seirbhísí Go muiníneach, ardchaighdeáin a scríobh — is é an bealach caighdeánach, idiomagach é chun **cealaithe agus timeouts** a láimhseáil trasna goroutines agus theorainn API.

Is é an príomhluach atá ann gur cosc ar obair dhíobhálach agus scaptha acmhainní a chur i bhfeidhm: nuair a dhísceideann cliant, nuair a théann tréimhse in éag, nó nuair a dhúnann freastalaí, scaipíonn comhthéacs an chomhartha cealaithe ionas go stadann na goroutines agus na hoibríochtaí go léir a bhí sprioc-dhírithe don iarratas sin go pras seachas go bhfuiligeann siad gan fheidhm (cosaint ríthábhachtach i gcoinne scaptha goroutine).

Tá sé coileanach i Go fíor — na freastalaí HTTP, glaochanna bunachar sonraí, gRPC, agus a bhformhór de leabharlainní naisc `context.Context` a ghlacadh mar a gcéad pharaiméadar.

Tá tuiscint ar conas comhthéacsanna a chruthú (`WithTimeout`/`WithCancel`), freagairt ar chealaithe (`<-ctx.Done()`), an riail dhualgas-ghlaoch-`cancel()`, agus an gnáth-chleachtas comhthéacs a sníomh tríd bhraistíneacha glaochanna riachtanach do aon obair gheal-sprioc Go backend agus príomhthopaicí agus agallamh coitianta.