Classificador de tipos básicos

package main

import "fmt"

// classify retorna uma descrição do tipo dinâmico de i.
func classify(i interface{}) string {
	switch v := i.(type) { // v terá o tipo concreto em cada case
	case nil:
		return "nulo"
	case int:
		return "inteiro"
	case string:
		return "texto"
	default:
		_ = v // evita erro de variável não usada
		return "outro"
	}
}

func main() {
	fmt.Println(classify(nil))
	fmt.Println(classify(10))
	fmt.Println(classify("Go"))
	fmt.Println(classify(3.14))
}

Passo a passo

1. A função classify recebe um parâmetro do tipo interface{} (ou any), que pode armazenar qualquer valor.
2. O type switch switch v := i.(type) avalia o tipo dinâmico de i e vincula v ao valor convertido em cada case.
3. O case nil trata explicitamente quando a interface é nula, retornando "nulo".
4. O case int só é executado se o tipo dinâmico for int; nesse bloco, v já é do tipo int.
5. O case string faz o mesmo para strings.
6. O default captura qualquer outro tipo (como float64) e retorna "outro".
7. No default, usamos _ = v apenas para evitar o erro de compilação "v declared but not used", já que não usamos v.
8. A função main chama classify com diferentes valores e imprime os resultados.

Por que funciona

O type switch é a forma idiomática de inspecionar o tipo dinâmico de uma interface. Ele combina a verificação de tipo com a extração segura do valor, eliminando a necessidade de múltiplas asserções como if v, ok := i.(int); ok { ... }. O case nil é essencial porque uma interface nula não tem tipo dinâmico e não corresponderia a nenhum outro case.

Erros comuns

• Esquecer o case nil: se i for nil, o type switch cai no default (se existir) ou não faz nada. Isso pode mascarar a ausência de valor. Corrija adicionando case nil:.
• Usar v no default sem necessidade: o compilador reclama se v não for usado. Use _ = v ou simplesmente não declare v no switch (use switch i.(type)).
• Achar que case int captura int64: tipos diferentes são cases diferentes. int64 cairia no default.

Outra forma de resolver

Poderia usar uma série de if com asserções de tipo:

if i == nil {
    return "nulo"
}
if _, ok := i.(int); ok {
    return "inteiro"
}
// ...

Mas o type switch é mais legível e eficiente. Prefira-o sempre que houver múltiplos tipos.

Saída esperada

nulo
inteiro
texto
outro