Qu'est-ce que les assertions de type et les commutateurs de type ?

Question

Accepted Answer

Une **assertion de type** extrait le type concret d'une valeur d'interface, et un **commutateur de type** crée une branche selon le type sous-jacent d'une interface. C'est comment récupérer des informations de type spécifiques à partir d'une interface (en particulier l'interface vide / `any`).

## Assertion de type — extraire un type concret

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

La syntaxe `i.(Type)` affirme que l'interface `i` contient une valeur de `Type` et l'extrait. Mais une assertion erronée **panique** — donc généralement vous utilisez la forme sécurisée comma-ok.

## La forme sécurisée 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
}
```

La forme à deux valeurs retourne la valeur plus un booléen — `ok` est false (au lieu de paniquer) si l'assertion échoue. **Privilégiez toujours cela** à moins que vous ne soyez certain du type.

## Commutateur de type — créer une branche sur plusieurs types possibles

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

La forme `switch v := i.(type)` vérifie le type sous-jacent et lie `v` (typée correctement dans chaque cas). C'est la façon claire de gérer une interface qui pourrait contenir plusieurs types.

## Assertion sur les types d'interface aussi

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

## Quand vous avez besoin de celles-ci

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

## Pourquoi c'est important

Les assertions de type et les commutateurs de type sont des outils essentiels pour travailler avec des valeurs d'interface — récupérer des informations de type concret à partir de `interface{}`/`any` ou vérifier si une valeur satisfait une interface particulière.

Elles sont nécessaires lors du traitement de données de types inconnus ou variés (analyse JSON dynamique, traitement générique, vérifications d'interface optionnelle comme « cela implémente-t-il io.Closer ? »).

Comprendre la **distinction panic-vs-sécurisée** est critique : une assertion simple `i.(T)` panique en cas de non-concordance, tandis que la **forme comma-ok** `v, ok := i.(T)` rapporte l'échec de manière sécurisée — utiliser la forme sécurisée est une pratique clé pour éviter les plantages à l'exécution.

Le commutateur de type gère élégamment plusieurs types possibles.

Connaître celles-ci (et le fait qu'une utilisation intensive signale souvent que vous devriez plutôt recourir aux génériques ou à des conceptions mieux typées) est important pour un Go sûr et idiomatique et un sujet d'entretien courant, puisque les interfaces et l'interface vide sont si centrales au langage.