**`context`** package को उद्देश्य के हो?

Question

Accepted Answer

**`context`** package ले **cancellation signals, deadlines, र request-scoped values** लाई API boundaries र goroutines मार्फत ढोकिन्छ। यो operations को lifetime नियन्त्रण गर्नको लागि मानक तरिका हो — विशेष गरी कामलाई cancel गर्न र timeouts लाई function calls को chain मार्फत propagate गर्नको लागि।

## यसले समाधान गर्ने मूल समस्या

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

## Contexts बनाउँदै

```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` ले child context लाई derive गरेर cancel गर्न सकिन्छ; तपाईंले यसको resources मुक्त गर्नको लागि `defer cancel()` गर्नु पर्छ।

## Cancellation को प्रतिक्रिया

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

Functions ले `ctx.Done()` (एक channel जो cancellation मा बन्द हुन्छ) जाँच गरेर रोकिन्छन् — यो कसरी cancellation वास्तवमा propagate हुन्छ।

## Call chain को माध्यमबाट context पास गर्ने (convention)

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

Context call stack को तल first parameter को रूपमा बग्छ, त्यसैले cancellation हरेक layer मा पुगेर सकिन्छ (standard-library DB/HTTP calls सहित जो context accept गर्छन्)।

## Request-scoped values (कम प्रयोग गर्नुहोस्)

```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`** package robust, production-grade Go services लेख्नको लागि आधारभूत छ — यो **cancellation र timeouts** को हेरफेर गर्नको लागि goroutines र API boundaries मार्फत मानक, idiomatic तरिका हो।

यसको प्राथमिक मूल्य व्यर्थ काम र resource leaks रोक्नुमा छ: जब client disconnect हुन्छ, deadline pass हुन्छ, वा server बन्द हुन्छ, context ले cancellation signal propagate गरेर यो सुनिश्चित गरेर हरेक goroutine र operation जो त्यस request को लागि spawn गरिएको थियो तत्काल रोकिन्छ (goroutine leaks विरुद्ध एक मुख्य रक्षा)।

यो real Go मा व्यापक छ — HTTP servers, database calls, gRPC, र अधिकांश networked libraries ले आफ्नो first parameter को रूपमा `context.Context` को स्वीकार गर्छन्।

Contexts कसरी बनाउने (`WithTimeout`/`WithCancel`), cancellation को प्रतिक्रिया जनाउने (`<-ctx.Done()`), must-call-`cancel()` rule, र call chains को माध्यमबाट context thread गर्ने convention बुझ्न गर्नु कुनै पनि serious Go backend work र एक सामान्य interview topic को लागि आवश्यक छ।