টাইপ অ্যাসার্শন এবং টাইপ সুইচ কী?

Question

Accepted Answer

একটি **টাইপ অ্যাসার্শন** একটি ইন্টারফেস মান থেকে নির্দিষ্ট টাইপ বের করে, এবং একটি **টাইপ সুইচ** একটি ইন্টারফেসের অন্তর্নিহিত টাইপের উপর ভিত্তি করে শাখা তৈরি করে। এগুলি হল কীভাবে আপনি একটি ইন্টারফেস থেকে নির্দিষ্ট টাইপ তথ্য পুনরুদ্ধার করেন (বিশেষত খালি ইন্টারফেস / `any`)।

## টাইপ অ্যাসার্শন — একটি নির্দিষ্ট টাইপ বের করুন

```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)` সিন্ট্যাক্স নিশ্চিত করে যে ইন্টারফেস `i` একটি `Type` মান ধরে রাখে এবং এটি বের করে। কিন্তু একটি ভুল অ্যাসার্শন **প্যানিক** করে — তাই সাধারণত আপনি নিরাপদ কমা-অক ফর্ম ব্যবহার করেন।

## নিরাপদ কমা-অক ফর্ম

```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
}
```

দুই-মূল্য ফর্ম মান এবং একটি বুলিয়ান রিটার্ন করে — অ্যাসার্শন ব্যর্থ হলে `ok` মিথ্যা (প্যানিক করার পরিবর্তে)। **সর্বদা এটি পছন্দ করুন** যদি না আপনি টাইপের ব্যাপারে নিশ্চিত হন।

## টাইপ সুইচ — একাধিক সম্ভাব্য টাইপে শাখা

```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)` ফর্ম অন্তর্নিহিত টাইপ পরীক্ষা করে এবং `v` বাঁধে (প্রতিটি ক্ষেত্রে যথাযথভাবে টাইপ করা হয়)। এটি একটি ইন্টারফেস পরিচালনা করার পরিষ্কার উপায় যা একাধিক টাইপ ধরতে পারে।

## ইন্টারফেস টাইপ অ্যাসার্ট করাও

```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
```

## কেন এটি গুরুত্বপূর্ণ

টাইপ অ্যাসার্শন এবং টাইপ সুইচ ইন্টারফেস মানগুলির সাথে কাজ করার জন্য অপরিহার্য সরঞ্জাম — `interface{}`/`any` থেকে নির্দিষ্ট টাইপ তথ্য পুনরুদ্ধার করা বা একটি মান একটি নির্দিষ্ট ইন্টারফেস সন্তুষ্ট করে কিনা তা পরীক্ষা করা (যেমন "এটি io.Closer বাস্তবায়ন করে কি?")।

অজানা বা বিভিন্ন ধরনের ডেটা পরিচালনা করার সময় এগুলি প্রয়োজন (গতিশীল JSON পার্সিং, জেনেরিক প্রসেসিং, ঐচ্ছিক-ইন্টারফেস চেক)।

**প্যানিক-বনাম-নিরাপদ পার্থক্য** বোঝা গুরুত্বপূর্ণ: একটি সাধারণ অ্যাসার্শন `i.(T)` মিসম্যাচে প্যানিক করে, যখন **কমা-অক ফর্ম** `v, ok := i.(T)` নিরাপদে ব্যর্থতা রিপোর্ট করে — রানটাইম ক্র্যাশ এড়াতে নিরাপদ ফর্ম ব্যবহার করা একটি মূল অনুশীলন।

টাইপ সুইচ এলিগ্যান্টভাবে একাধিক সম্ভাব্য টাইপ পরিচালনা করে।

এই বিষয়গুলি জানা (এবং যে ভারী ব্যবহার প্রায়শই নির্দেশ করে যে আপনার জেনেরিক্স বা আরও ভাল-টাইপ করা ডিজাইনের দিকে যাওয়া উচিত) নিরাপদ, প্রাকৃতিক Go এবং একটি সাধারণ সাক্ষাৎকারের বিষয়ের জন্য গুরুত্বপূর্ণ, কারণ ইন্টারফেস এবং খালি ইন্টারফেস ভাষার জন্য এত কেন্দ্রীয়।