select statement के बारे मा के हो?

Question

Accepted Answer

**`select`** ले goroutine लाई **multiple channel operations** मा एकै पटक प्रतीक्षा गर्न दिन्छ, र कुन पहिले तयार हुन्छ भन्ने कुरामा अगाडि बढ्छ। यो channels को लागि `switch` जस्तै हो — concurrent operations, timeouts, र cancellation समन्वय गर्नको लागि आवश्यक हो।

## Basic select — multiple channels मा प्रतीक्षा गर्नुहोस्

```go
select {
case msg1 := <-ch1:
    fmt.Println("from ch1:", msg1)
case msg2 := <-ch2:
    fmt.Println("from ch2:", msg2)
case ch3 <- "hello":          // can also wait to SEND
    fmt.Println("sent to ch3")
}
// blocks until ONE case is ready, then runs that case
// if MULTIPLE are ready, one is chosen at RANDOM
```

`select` तब सम्म block हुन्छ जब सम्म यसको कुनै पनि channel operation अगाडि बढ्न सक्छ, त्यसपछि त्यो case execute हुन्छ। यदि धेरै एकै पटक तयार छन् भने, यसले एक randomly चयन गर्छ (starvation रोक्नको लागि)।

## Timeouts — एक मुख्य use case

```go
select {
case result := <-workCh:
    fmt.Println("got result:", result)
case <-time.After(2 * time.Second):     // fires after 2 seconds
    fmt.Println("timed out")             // don't wait forever
}
```

Work channel लाई `time.After` को साथ जोडिनु भनेको **timeout** थप गर्नुको idiomatic तरिका हो — यदि परिणाम आएको छ भने अगाडि बढ्नुहोस्, अन्यथा deadline पछि छोडिदिनुहोस्। यो goroutines लाई अनिश्चितकालको लागि block हुनबाट रोक्छ।

## Non-blocking operations with default

```go
select {
case msg := <-ch:
    fmt.Println("received:", msg)
default:
    fmt.Println("no message ready")     // runs immediately if no case is ready
}
// with a default case, select NEVER blocks — it's a non-blocking check
```

एक `default` case ले `select` लाई non-blocking बनाउँछ: यदि कुनै पनि channel तयार छैन भने, `default` प्रतीक्षा गरेर सट्टा तुरुन्त चल्छ।

## Cancellation with context (एकदम सामान्य)

```go
func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():           // context cancelled or timed out
            fmt.Println("shutting down:", ctx.Err())
            return                    // clean exit — prevents goroutine leak
        }
    }
}
```

`case <-ctx.Done()` प्याटर्न ले goroutine लाई काम गर्दा cancellation सुन्न दिन्छ — goroutines लाई stoppable बनाउनु र leaks रोक्नुको मानक तरिका।

## एक सामान्य प्याटर्न: loop with select

```go
for {
    select {
    case data := <-dataCh:  ...
    case <-quit:            return
    }
}
```

## किन यो महत्त्वपूर्ण छ

`select` Go concurrency को लागि एक मौलिक उपकरण हो — यो कसरी goroutines multiple channels समन्वय गर्छ, जो real concurrent programs को लागि आवश्यक प्याटर्नहरु सक्षम गर्छ।

यसको मुख्य प्रयोगहरु गम्भीर छन्: **timeouts** (`time.After`) अनिश्चितकालको blocking रोक्छ; **non-blocking** channel checks (`default`) stuck हुनबाट बचाउँछ; र विशेष गरी **cancellation** (`<-ctx.Done()`) ले goroutines लाई सफाईसाथ बाहिर निकल्न दिन्छ, जो goroutine leaks विरुद्ध प्राथमिक रक्षा हो।

`select` बिना, तपाइँ धेरै channels मा elegant तरिकामा प्रतीक्षा गर्न सक्नुहुन्न, deadlines implement गर्न सक्नुहुन्न, वा goroutines लाई shutdown signals को लागि responsive बनाउन सक्नुहुन्न।

`select` बुझ्नु (यसको blocking-until-ready व्यवहार, ready cases बीच random choice, non-blocking को लागि `default`, र timeout/cancellation idioms) robust, leak-free concurrent Go लेखनको लागि आवश्यक छ र भाषामा core concurrency topics मध्ये एक हो।