Type assertions आणि type switches म्हणजे काय?

Question

Accepted Answer

एक **type assertion** interface value मधून concrete type काढून देते, आणि एक **type switch** interface च्या underlying type वर आधारित branch करते. हे interface (विशेषत: empty interface / `any`) मधून specific type information वापस मिळवण्याचा मार्ग आहे.

## 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 **पॅनिक** करते — तर सामान्यत: तुम्ही 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 परत करते — `ok` false असते (पॅनिक करण्याऐवजी) जर assertion fail झाली. **हे नेहमी पसंद करा** जोपर्यंत तुम्हाला 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 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 सोबत काम करण्यासाठी आवश्यक tools आहेत — `interface{}`/`any` मधून concrete type information वापस मिळवणे किंवा check करणे की value एक particular interface satisfy करते की नाही.

हे गरज असते अज्ञात किंवा विविध types चे data handle करताना (dynamic JSON parse करणे, generic processing, optional-interface checks जसे की "हे io.Closer implement करते का?").

**panic-vs-safe distinction** समजून घेणे गंभीर आहे: plain assertion `i.(T)` mismatch वर पॅनिक करते, तर **comma-ok form** `v, ok := i.(T)` safe रीत्या failure report करते — safe form वापरणे runtime crashes टाळण्यासाठी एक मुख्य practice आहे.

type switch gracefully अनेक संभाव्य types handle करते.

हे जाणून घेणे (आणि हे की heavy use बहुधा असे सूचित करते की तुम्ही generics किंवा better-typed designs च्या दिशेने जावे) safe, idiomatic Go साठी महत्वाचे आहे आणि एक सामान्य interview topic आहे, कारण interfaces आणि empty interface language साठी इतके central आहेत.