type assertions और type switches क्या हैं?

Question

Accepted Answer

एक **type assertion** एक interface value से concrete type निकालता है, और एक **type switch** एक interface के underlying type पर शाखा बनाता है। ये वही हैं जिनसे आप एक interface (खासकर empty interface / `any`) से विशिष्ट 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 दावा करता है कि interface `i` में `Type` की एक value है और उसे निकालता है। लेकिन एक गलत assertion **panic** करता है — इसलिए आमतौर पर आप सुरक्षित comma-ok रूप का उपयोग करते हैं।

## सुरक्षित comma-ok रूप

```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 रूप value के साथ एक boolean लौटाता है — यदि assertion विफल होता है तो `ok` false होता है (panic करने के बजाय)। **हमेशा इसे प्राथमिकता दें** जब तक आप type के बारे में निश्चित न हों।

## type switch — कई संभावित types पर शाखा बनाएँ

```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)` रूप underlying type की जाँच करता है और `v` को bind करता है (हर case में उपयुक्त रूप से typed)। यह एक interface को संभालने का साफ़ तरीका है जो कई types रख सकता है।

## interface types का भी assertion करना

```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 के data को संभालते हैं (dynamic JSON parsing, generic processing, optional-interface जाँच जैसे "क्या यह io.Closer लागू करता है?")।

**panic-बनाम-safe अंतर** को समझना महत्वपूर्ण है: एक सादा assertion `i.(T)` mismatch पर panic करता है, जबकि **comma-ok रूप** `v, ok := i.(T)` सुरक्षित रूप से विफलता की रिपोर्ट करता है — सुरक्षित रूप का उपयोग runtime crashes से बचने के लिए एक मुख्य अभ्यास है।

type switch कई संभावित types को सुरुचिपूर्ण ढंग से संभालता है।

इन्हें जानना (और यह कि भारी उपयोग अक्सर संकेत देता है कि आपको इसके बजाय generics या better-typed designs की ओर जाना चाहिए) सुरक्षित, idiomatic Go के लिए महत्वपूर्ण है और एक आम interview विषय है, क्योंकि interfaces और empty interface भाषा के इतने केंद्रीय हैं।