**`context`** પેકેજ શું માટે વપરાય છે?

Question

Accepted Answer

**`context`** પેકેજ **કેન્સલેશન સિગ્નલ્સ, ડેડલાઈનો, અને રિક્વેસ્ટ-સ્કોપ્ડ વેલ્યુઝ** API બાઉન્ડરીઝ અને ગોરૌટીનો વચ્ચે વહન કરે છે. તે ઓપરેશનોના જીવનકાળને નિયંત્રણ કરવાની માનક મર્યાદા છે — ખાસ કરીને કામને કેન્સલ કરવા અને ફંક્શન કોલ્સની સાંકળ દ્વારા ટાઈમઆઉટ પ્રસારિત કરવા માટે.

## જે મુખ્ય સમસ્યા તેઓ હલ કરે છે

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

## કન્ટેક્સ્ટ્સ બનાવવું

```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` બાળ કન્ટેક્સ્ટ બનાવે છે જે કેન્સલ કરી શકાય છે; તમે તેના સંસાધનોને મુક્ત કરવા માટે `defer cancel()` કો કૉલ કરવું જોઈએ.

## કેન્સલેશનને પ્રતિક્રિયા આપવી

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

ફંક્શનો `ctx.Done()` ચેક કરે છે (એક ચેનલ જે કેન્સલેશન પર બંધ થાય છે) અને તરત જ બંધ થાય છે — આ છે કેવી રીતે કેન્સલેશન વાસ્તવમાં પ્રસારિત થાય છે.

## કોલ ચેઇનમાં કન્ટેક્સ્ટ પાસ કરવું (સંમેલન)

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

કન્ટેક્સ્ટ કોલ સ્ટેક નીચે પ્રથમ પરિમાણ તરીકે વહે છે, તેથી કેન્સલેશન દરેક સ્તર સુધી પહોંચે છે (સ્ટાન્ડર્ડ-લાઇબ્રેરી DB/HTTP કોલ્સ સહ જે કન્ટેક્સ્ટ સ્વીકારે છે).

## રિક્વેસ્ટ-સ્કોપ્ડ વેલ્યુઝ (કાયમી રીતે વપરો)

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

## શા માટે તે મહત્વપૂર્ણ છે

`context` પેકેજ મજબૂત, પ્રોડક્શન-ગ્રેડ Go સર્વિસেસ લખવા માટે મૌલિક છે — તે **કેન્સલેશન અને ટાઈમઆઉટ્સ** હેન્ડલ કરવાનો માનક, idiوmatic રીત છે ગોરૌટીનો અને API બાઉન્ડરીઝ વચ્ચે.

તેનું પ્રાથમિક મૂલ્ય વેડફાઈ કરેલ કાર્ક અને સંસાધનોના લીક્સ રોકવું છે: જ્યારે ક્લાયન્ટ ડિસ્કનેક્ટ થાય, ડેડલાઈન પસાર થાય, અથવા સર્વર શટ ડાઉન થાય, તો કન્ટેક્સ્ટ કેન્સલેશન સિગ્નલ પ્રસારિત કરે છે જેથી તે રિક્વેસ્ટ માટે સ્પોન કરાયેલ તમામ ગોરૌટીનો અને ઓપરેશનો તરત જ રોકાઈ જાય બદલે કે નિરર્થક રીતે ચાલતા રહે (ગોરૌટીન લીક્સ સામે કી રક્ષણ).

તે વાસ્તવિક Go માં સર્વવ્યાપી છે — HTTP સર્વર્સ, ડેટાબેસ કોલ્સ, gRPC, અને મોટાભાગના નેટવર્કড લાઇબ્રેરીઝ `context.Context` તેમના પ્રથમ પરિમાણ તરીકે સ્વીકારે છે.

કન્ટેક્સ્ટ્સ કેવી રીતે બનાવવું (`WithTimeout`/`WithCancel`), કેન્સલેશનને કેવી રીતે પ્રતિક્રિયા આપવી (`<-ctx.Done()`), `cancel()` નિયમ-અપરિહાર્ય-કોલ, અને કોલ ચેઇનોમાં કન્ટેક્સ્ટ થ્રેડ કરવાનું સંમેલન સમજવું કોઈપણ ગંભીર Go બેકএન્ડ કાર્ય અને સામાન્ય ઇન્ટરવ્યુ વિષય માટે આવશ્યક છે.