Τι είναι οι type assertions και οι type switches;

Question

Accepted Answer

Μια **type assertion** εξάγει τον συγκεκριμένο τύπο από μια τιμή διεπαφής, και ένα **type switch** διακλαδώνεται με βάση τον υποκείμενο τύπο μιας διεπαφής. Αυτός είναι ο τρόπος με τον οποίο ανακτάτε συγκεκριμένες πληροφορίες τύπου από μια διεπαφή (ειδικά την κενή διεπαφή / `any`).

## Type assertion — εξαγωγή ενός συγκεκριμένου τύπου

```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` και την εξάγει. Όμως μια λανθασμένη assertion **προκαλεί panic** — γι' αυτό συνήθως χρησιμοποιείτε την ασφαλή μορφή comma-ok.

## Η ασφαλής μορφή comma-ok

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

Η μορφή δύο τιμών επιστρέφει την τιμή συν ένα boolean — το `ok` είναι false (αντί να προκαλέσει panic) εάν η assertion αποτύχει. **Προτιμήστε πάντα αυτή** εκτός κι αν είστε σίγουροι για τον τύπο.

## Type switch — διακλάδωση σε πολλαπλούς πιθανούς τύπους

```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` (με κατάλληλο τύπο σε κάθε case). Είναι ο καθαρός τρόπος να χειριστείτε μια διεπαφή που θα μπορούσε να περιέχει πολλαπλούς τύπους.

## Assertion και σε τύπους διεπαφής

```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{}`/`any` ή ελέγχοντας εάν μια τιμή ικανοποιεί μια συγκεκριμένη διεπαφή.

Χρειάζονται όταν χειρίζεστε δεδομένα άγνωστου ή διάφορου τύπου (parsing δυναμικού JSON, γενική επεξεργασία, προαιρετικούς ελέγχους διεπαφής όπως "εφαρμόζει αυτό το io.Closer;").

Η κατανόηση της **διάκρισης panic-vs-safe** είναι κρίσιμη: μια απλή assertion `i.(T)` προκαλεί panic σε περίπτωση αναντιστοιχίας, ενώ η **μορφή comma-ok** `v, ok := i.(T)` αναφέρει με ασφάλεια την αποτυχία — η χρήση της ασφαλούς μορφής είναι μια βασική πρακτική για την αποφυγή σφαλμάτων runtime.

Το type switch χειρίζεται κομψά πολλαπλούς πιθανούς τύπους.

Η γνώση αυτών (και ότι η έντονη χρήση συχνά δηλώνει ότι θα πρέπει να καταφύγετε σε generics ή καλύτερα σχεδιασμένες αρχιτεκτονικές τύπων αντ' αυτού) είναι σημαντική για το ασφαλές, ιδιωματικό Go και ένα συνηθισμένο θέμα συνέντευξης, δεδομένου ότι οι διεπαφές και η κενή διεπαφή είναι τόσο κεντρικές στη γλώσσα.