O que são asserções de tipo e comutadores de tipo?

Question

Accepted Answer

Uma **asserção de tipo** extrai o tipo concreto de um valor de interface, e um **comutador de tipo** se ramifica no tipo subjacente de uma interface. São como você recupera informações de tipo específicas de uma interface (especialmente a interface vazia / `any`).

## Asserção de tipo — extrair um tipo concreto

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

A sintaxe `i.(Type)` afirma que a interface `i` contém um valor do `Type` e a extrai. Mas uma asserção incorreta **entra em pânico** — então geralmente você usa o formulário comma-ok seguro.

## O formulário comma-ok seguro

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

O formulário de dois valores retorna o valor mais um booleano — `ok` é false (em vez de entrar em pânico) se a asserção falhar. **Sempre prefira isto** a menos que tenha certeza do tipo.

## Comutador de tipo — ramificar em vários tipos possíveis

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

O formulário `switch v := i.(type)` verifica o tipo subjacente e vincula `v` (digitado apropriadamente em cada case). É a maneira limpa de lidar com uma interface que pode conter vários tipos.

## Afirmando tipos de interface também

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

## Quando você precisa destes

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

## Por que isso importa

Asserções de tipo e comutadores de tipo são ferramentas essenciais para trabalhar com valores de interface — recuperar informações de tipo concreto de `interface{}`/`any` ou verificar se um valor satisfaz uma interface particular.

São necessárias ao lidar com dados de tipo desconhecido ou variado (análise de JSON dinâmico, processamento genérico, verificações de interface opcional como "isso implementa io.Closer?").

Compreender a **distinção panic-vs-seguro** é crítico: uma asserção simples `i.(T)` entra em pânico em caso de incompatibilidade, enquanto o **formulário comma-ok** `v, ok := i.(T)` relata com segurança a falha — usar o formulário seguro é uma prática chave para evitar travamentos em tempo de execução.

O comutador de tipo trata elegantemente múltiplos tipos possíveis.

Compreender estes (e que o uso intensivo muitas vezes sinaliza que você deveria, em vez disso, recorrer a genéricos ou designs melhor tipados) é importante para Go seguro e idiomático e um tópico comum de entrevista, já que interfaces e a interface vazia são tão centrais para a linguagem.