Type assertions र type switches के हुन्?

Question

Accepted Answer

एक **type assertion** interface value बाट concrete type निकाल्छ, र एक **type switch** interface को underlying type मा branch गर्छ। तिनीहरू interface (विशेषतः empty interface / `any`) बाट concrete type जानकारी फिर्ता पाउने तरिका हुन्।

## Type assertion — एक concrete type निकाल्नु

```go
var i interface{} = "hello"     // an interface holding a string

s := i.(string)                  // assert it's a string → s = "hello"
fmt.Println(s)

n := i.(int)                     // ❌ PANIC — i is not an int (wrong assertion)
```

को `i.(Type)` syntax ले assertion गर्छ कि interface `i` ले `Type` को value राख्छ र यो निकाल्छ। तर गलत assertion ले **panic** गर्छ — त्यसैले सामान्यतया तपाई safe comma-ok form प्रयोग गर्नुहुन्छ।

## Safe comma-ok form

```go
s, ok := i.(string)
if ok {
    fmt.Println("it's a string:", s)   // ok = true, s = the value
} else {
    fmt.Println("not a string")         // ok = false, s = zero value, NO panic
}
```

दुई-value form ले value र एक boolean फिर्ता गर्छ — assertion असफल भएमा `ok` false हुन्छ (panic हुनको सट्टा)। **सधैँ यो प्राथमिकता दिनुहोस्** जब सम्म तपाई type को बारेमा निश्चित हुनुहुन्न।

## Type switch — बहुविध सम्भावित types मा branch गर्नु

```go
func describe(i interface{}) string {
    switch v := i.(type) {           // the special .(type) form, only in a switch
    case int:
        return fmt.Sprintf("int: %d (doubled: %d)", v, v*2)
    case string:
        return fmt.Sprintf("string of length %d", len(v))
    case bool:
        return fmt.Sprintf("bool: %t", v)
    case nil:
        return "nil value"
    default:
        return fmt.Sprintf("unknown type: %T", v)
    }
}

describe(42)        // "int: 42 (doubled: 84)"
describe("hi")      // "string of length 2"
```

को `switch v := i.(type)` form underlying type जाँच गर्छ र `v` लाई bind गर्छ (प्रत्येक case मा उपयुक्त रूपमा typed)। यो interface को संचालन गर्ने स्वच्छ तरिका हो जो धेरै types राख्न सक्छ।

## Interface types लाई पनि assert गर्नु

```go
// assert that a value implements a specific interface
if w, ok := i.(io.Writer); ok {
    w.Write([]byte("data"))    // use it as an io.Writer if it satisfies that interface
}
```

## जब तपाईलाई यो चाहिन्छ

```text
✓ Processing values of unknown type (interface{}/any) — JSON, generic handlers
✓ Checking if a value implements an optional interface (e.g. io.Closer)
✓ Handling heterogeneous data
⚠️ Often a sign you could use generics or better-typed interfaces instead — don't overuse
```

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

Type assertions र type switches interface values को साथ काम गर्न आवश्यक उपकरण हुन् — `interface{}`/`any` बाट concrete type जानकारी फिर्ता पाउन वा जाँच गर्न कि कुनै value विशेष interface को सन्तुष्टि दिन्छ।

यिनीहरू अज्ञात वा विविध types को डेटा संभालने समयमा आवश्यक हुन्छन् (dynamic JSON parse गर्न, generic processing गर्न, optional-interface जाँच गर्न जस्तै