Asserções de tipo e switches de tipo
Asserções de tipo seguras e padrões de switch
Asserções de tipo e switches de tipo é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.
Asserções de Tipo
Uma asserção de tipo extrai o valor concreto de uma interface. A sintaxe é x.(T):
package main
import "fmt"
func main() {
var i interface{} = "hello"
s := i.(string) // panics if wrong type
fmt.Println(s, len(s)) // hello 5
}Asserção Segura com Dois Valores
Use a forma vírgula-ok para evitar pânicos quando os tipos estiverem incorretos:
package main
import "fmt"
func main() {
var i interface{} = 42
s, ok := i.(string)
fmt.Println(s, ok) // "" false
n, ok := i.(int)
fmt.Println(n, ok) // 42 true
}Seleção de Tipo
Uma seleção de tipo compara o tipo dinâmico de um valor de interface com vários tipos:
package main
import "fmt"
func describe(i interface{}) string {
switch v := i.(type) {
case int: return fmt.Sprintf("int: %d", v)
case string: return fmt.Sprintf("string: %q", v)
case bool: return fmt.Sprintf("bool: %v", v)
default: return fmt.Sprintf("unknown: %T", v)
}
}
func main() {
fmt.Println(describe(42))
fmt.Println(describe("hi"))
fmt.Println(describe(3.14))
}Seleção de Tipo em error
Seleções de tipo são especialmente úteis para categorizar erros:
package main
import ("errors"; "fmt")
type NotFoundError struct{ Name string }
func (e *NotFoundError) Error() string { return e.Name + " not found" }
type PermError struct{}
func (e *PermError) Error() string { return "permission denied" }
func handle(err error) {
switch e := err.(type) {
case *NotFoundError: fmt.Println("missing:", e.Name)
case *PermError: fmt.Println("perm error")
default: fmt.Println("other:", e)
}
}
func main() {
handle(&NotFoundError{"user"})
handle(errors.New("generic"))
}Asserção para uma Interface
Você pode fazer uma asserção para outro tipo de interface, não apenas para tipos concretos. Isso é útil para verificar se um objeto oferece um comportamento opcional:
package main
import "fmt"
type Flusher interface{ Flush() }
type Writer interface{ Write(string) }
type BufferedWriter struct{ buf string }
func (b *BufferedWriter) Write(s string) { b.buf += s }
func (b *BufferedWriter) Flush() { fmt.Println(b.buf); b.buf = "" }
func maybeFlush(w Writer) {
if f, ok := w.(Flusher); ok { f.Flush() }
}
func main() {
bw := &BufferedWriter{}
bw.Write("hello")
maybeFlush(bw)
}Asserção sobre Interface Nil
Fazer uma asserção sobre uma interface nil causa um pânico. Verifique sempre se a interface não é nil antes de fazer a asserção:
package main
import "fmt"
func safePrint(i interface{}) {
if i == nil {
fmt.Println("nil")
return
}
fmt.Printf("%T: %v\n", i, i)
}
func main() {
safePrint(nil)
safePrint(42)
}Alternativa a reflect.TypeOf
Para imprimir o tipo sem fazer uma asserção, use fmt.Sprintf("%T", v) ou reflect.TypeOf(v):
package main
import ("fmt"; "reflect")
func main() {
v := []int{1, 2, 3}
fmt.Printf("%T\n", v) // []int
fmt.Println(reflect.TypeOf(v)) // []int
}Asserção de tipo versus conversão
Asserção de tipo: extrai o tipo concreto de uma interface. Conversão de tipo: transforma um tipo concreto em outro tipo compatível. São operações diferentes:
package main
import "fmt"
func main() {
var i interface{} = int32(5)
n := i.(int32) // assertion — OK
big := int64(n) // conversion — OK
fmt.Println(n, big)
}Padrão vírgula-ok em select
O padrão vírgula-ok também funciona ao receber valores de um canal para detectar se ele foi fechado. O mesmo idioma conciso é usado de forma consistente em Go.
Quando usar alternâncias de tipo
Casos de uso comuns:
- Conversão de JSON com campos
interface{} - Categorização de erros
- Despacho de mensagens de protocolo
- Verificação de interfaces opcionais (Flusher, Closer etc.)
Verificação rápida
Qual é o resultado de uma asserção de tipo não segura que falha?
Recapitulação
Principais conclusões:
x.(T)causa pânico com o tipo errado;x, ok := x.(T)é seguro- As alternâncias de tipo lidam claramente com vários tipos
- Faça asserções para interfaces a fim de verificar capacidades opcionais
- Nunca faça uma asserção sobre uma interface nula
Proposta de prática
Escreva uma função sum(values []any) float64 que use uma alternância de tipos para lidar com valores int, float64 e string (analise a string), ignorando os demais.
Aprenda Go com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “Asserções de tipo e switches de tipo” é grátis?
Sim — o texto completo de “Asserções de tipo e switches de tipo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.
O que vou aprender em “Asserções de tipo e switches de tipo”?
Asserções de tipo seguras e padrões de switch Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Go Academy?
Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Asserções de tipo e switches de tipo”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Go Academy?
Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Definindo e implementando interfaces
- Interfaces essenciais da biblioteca padrão
- Asserções de tipo e switches de tipo
- Composição de interfaces e boas práticas