Type assertions اور type switches کیا ہیں؟

Question

Accepted Answer

ایک **type assertion** interface value سے concrete type نکالتا ہے، اور ایک **type switch** interface کی underlying type پر branch کرتا ہے۔ یہ وہ طریقے ہیں جن سے آپ interface سے specific type information واپس حاصل کرتے ہیں (خاص طور پر empty interface / `any` سے)۔

## 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 یہ assert کرتا ہے کہ interface `i` کسی `Type` کی value رکھتا ہے اور اسے نکالتا ہے۔ لیکن غلط assertion **panic** کرتا ہے — اس لیے عام طور پر آپ محفوظ comma-ok form استعمال کرتے ہیں۔

## محفوظ 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 واپس کرتا ہے — `ok` غلط ہے (panic کرنے کی بجائے) اگر assertion ناکام ہو۔ **ہمیشہ یہ پسند کریں** جب تک آپ کو 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 check کرتا ہے اور `v` کو bind کرتا ہے (ہر case میں مناسب طریقے سے typed)۔ یہ اس interface کو handle کرنے کا صاف طریقہ ہے جو کئی 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 information واپس حاصل کرنا یا یہ جانچنا کہ کیا value کسی خاص interface کو satisfy کرتا ہے۔

یہ اس وقت ضروری ہیں جب نامعلوم یا متنوع قسموں کی ڈیٹا کو handle کیا جائے (dynamic JSON parsing، generic processing، optional-interface checks جیسے "کیا یہ io.Closer کو implement کرتا ہے؟")۔

**panic-vs-safe تفریق** کو سمجھنا اہم ہے: سادہ assertion `i.(T)` mismatch پر panic کرتا ہے، جبکہ **comma-ok form** `v, ok := i.(T)` محفوظ طریقے سے ناکامی کی اطلاع دیتا ہے — محفوظ form استعمال کرنا runtime crashes سے بچنے کے لیے کلیدی طریقہ ہے۔

Type switch متعدد ممکنہ types کو خوبصورتی سے handle کرتا ہے۔

یہ جاننا (اور یہ کہ بھاری استعمال اکثر اشارہ کرتا ہے کہ آپ کو generics یا بہتر-typed designs کی طرف جانا چاہیے) safe، idiomatic Go کے لیے اہم ہے اور ایک عام interview topic ہے، کیونکہ interfaces اور empty interface language میں بہت مرکزی ہیں۔