type assertions மற்றும் type switches என்றால் என்ன?

Question

Accepted Answer

ஒரு **type assertion** ஆனது interface value-இலிருந்து 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`-இன் ஒரு value-ஐ வைத்திருக்கிறது என்று assert செய்து அதைப் பிரித்தெடுக்கிறது. ஆனால் தவறான 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
}
```

two-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-இலும் பொருத்தமாக type செய்யப்படுகிறது). பல types-ஐ வைத்திருக்கக்கூடிய ஒரு interface-ஐ கையாள்வதற்கான சுத்தமான வழி இதுவே.

## 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-இன் data-ஐ கையாளும்போது அவை தேவைப்படுகின்றன (dynamic JSON-ஐ parse செய்தல், generic processing, "இது io.Closer-ஐ implement செய்கிறதா?" போன்ற optional-interface சரிபார்ப்புகள்).

**panic-vs-safe வேறுபாட்டை** புரிந்துகொள்வது முக்கியம்: ஒரு plain assertion `i.(T)` ஆனது பொருந்தாதபோது panic செய்கிறது, அதேசமயம் **comma-ok form** `v, ok := i.(T)` ஆனது தோல்வியை பாதுகாப்பாக அறிக்கையிடுகிறது — safe form-ஐ பயன்படுத்துவது runtime crashes-ஐ தவிர்ப்பதற்கான ஒரு முக்கிய நடைமுறையாகும்.

type switch ஆனது பல சாத்தியமான types-ஐ நேர்த்தியாக கையாள்கிறது.

இவற்றை அறிவது (மற்றும் அதிக பயன்பாடு பெரும்பாலும் நீங்கள் generics அல்லது சிறந்த-type செய்யப்பட்ட designs-ஐ நாட வேண்டும் என்பதைக் குறிக்கிறது என்பதை அறிவது) பாதுகாப்பான, idiomatic Go-க்கு முக்கியமானது மற்றும் ஒரு பொதுவான interview தலைப்பாகும், ஏனெனில் interfaces மற்றும் empty interface ஆனவை மொழியில் மிகவும் மையமானவை.