Type assertions ਅਤੇ type switches ਕੀ ਹਨ?

Question

Accepted Answer

ਇੱਕ **type assertion** interface ਵੈਲਯੂ ਤੋਂ concrete type ਨੂੰ ਕੱਢਦਾ ਹੈ, ਅਤੇ ਇੱਕ **type switch** interface ਦੀ underlying type ਤੇ branch ਕਰਦਾ ਹੈ। ਇਹ ਉਹ ਤਰੀਕਾ ਹਨ ਜਿਨ੍ਹਾਂ ਦੁਆਰਾ ਤੁਸੀਂ 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` ਦੀ ਵੈਲਯੂ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕੱਢਦਾ ਹੈ। ਪਰ ਇੱਕ ਗਲਤ 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
}
```

ਦੋ-ਮੁੱਲ form ਵੈਲਯੂ ਪਲਸ ਇੱਕ boolean ਵਾਪਸ ਕਰਦਾ ਹੈ — `ok` false ਹੈ (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 ਨੂੰ ਚੈਕ ਕਰਦਾ ਹੈ ਅਤੇ `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 ਵੈਲਯੂਜ਼ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਟੂਲ ਹਨ — `interface{}`/`any` ਤੋਂ concrete type ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਜਾਂ ਚੈਕ ਕਰਨਾ ਕਿ ਕੀ ਇੱਕ ਵੈਲਯੂ ਕਿਸੇ ਖਾਸ interface ਨੂੰ ਪੂਰਾ ਕਰਦੀ ਹੈ।

ਉਹ ਅਣਜਾਣ ਜਾਂ ਵਿਭਿੰਨ types ਦਾ ਡੇਟਾ ਸੰਭਾਲਣ ਕਰਦੇ ਸਮੇਂ ਲਾਜ਼ਮੀ ਹਨ (dynamic JSON ਨੂੰ parse ਕਰਨਾ, generic processing, optional-interface checks ਜਿਵੇਂ "ਕੀ ਇਹ io.Closer ਨੂੰ implement ਕਰਦਾ ਹੈ?")।

**panic-vs-safe distinction** ਨੂੰ ਸਮਝਣਾ ਨਾਜ਼ੁਕ ਹੈ: ਇੱਕ ਸਾਧਾਰਣ assertion `i.(T)` mismatch 'ਤੇ panic ਕਰਦਾ ਹੈ, ਜਦਕਿ **comma-ok form** `v, ok := i.(T)` ਅਸਫਲਤਾ ਨੂੰ ਸੁਰੱਖਿਤ ਰੂਪ ਵਿੱਚ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ — safe form ਦੀ ਵਰਤੋਂ runtime crashes ਤੋਂ ਬਚਣ ਦੀ ਮੁੱਖ ਅਭਿਆਸ ਹੈ।

Type switch ਕਈ ਸਮਭਾਵਿਤ types ਨੂੰ ਸੁੰਦਰਤਾ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ।

ਇਹਨਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ (ਅਤੇ ਇਹ ਕਿ ਭਾਰੀ ਵਰਤੋਂ ਅਕਸਰ ਸੰਕੇਤ ਕਰਦੀ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇਸ ਦੀ ਬਜਾਏ generics ਜਾਂ ਬਿਹਤਰ-typed ਡਿਜ਼ਾਈਨ ਲਈ ਪਹੁੰਚਣਾ ਚਾਹੀਦਾ ਹੈ) ਸੁਰੱਖਿਤ, idiomatic Go ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਅਤੇ ਇੱਕ ਆਮ interview ਸਵਾਲ ਹੈ, ਕਿਉਂਕਿ interfaces ਅਤੇ empty interface ਭਾਸ਼ਾ ਲਈ ਇੰਨੇ ਕੇਂਦਰੀ ਹਨ।