Go Academy · Aula

reflect.Type e reflect.Value

TypeOf, ValueOf, Kind e Elem

reflect.Type e reflect.Value é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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.

Visão geral do pacote reflect

O pacote reflect permite que programas Go inspecionem tipos e valores em tempo de execução. Ele é a base de bibliotecas de codificação, ORMs e estruturas de injeção de dependências.

reflect.TypeOf

reflect.TypeOf(x) retorna o reflect.Type do valor de x:

t := reflect.TypeOf(42)
fmt.Println(t.Name())    // "int"
fmt.Println(t.Kind())    // "int"
fmt.Println(t.String())  // "int"

reflect.ValueOf

reflect.ValueOf(x) retorna um reflect.Value que contém x. Você pode ler o valor com métodos específicos de Kind:

v := reflect.ValueOf(42)
fmt.Println(v.Kind())    // "int"
fmt.Println(v.Int())     // 42

Kind de Type vs Name de Type

Kind é a categoria Go subjacente (int, struct, ptr, slice, ...). Name é o nome do tipo declarado ("MyStruct"). As interfaces têm Kind == Interface, mas não têm Name.

Campos de struct

Inspecione os campos de uma struct por meio de Type.NumField() e Type.Field(i), que retorna um reflect.StructField:

t := reflect.TypeOf(User{})
for i := 0; i < t.NumField(); i++ {
    f := t.Field(i)
    fmt.Printf("Field: %s Type: %s Tag: %s\n", f.Name, f.Type, f.Tag.Get("json"))
}

Lendo valores de campos de struct

Use Value.FieldByName ou Value.Field(i) para ler valores de campos em tempo de execução:

v := reflect.ValueOf(user)
nameField := v.FieldByName("Name")
fmt.Println(nameField.String()) // "Alice"

Definindo valores de campos de struct

Para definir um campo, o valor precisa ser endereçável (passado como um ponteiro):

v := reflect.ValueOf(&user).Elem()
v.FieldByName("Name").SetString("Bob")

Indireção de ponteiro

Se um valor for um ponteiro, chame v.Elem() para obter o valor apontado. Primeiro, verifique v.Kind() == reflect.Ptr.

if v.Kind() == reflect.Ptr {
    v = v.Elem()
}

reflect.New

Crie um novo valor zero de um tipo e obtenha um ponteiro para ele:

t := reflect.TypeOf(User{})
ptr := reflect.New(t) // *User
user := ptr.Interface().(*User)

Chamando métodos

Chame um método pelo nome em um valor refletido:

v := reflect.ValueOf(user)
m := v.MethodByName("Greet")
results := m.Call(nil)
fmt.Println(results[0].String())

Desempenho

A reflexão é 5–10× mais lenta que o código direto. Armazene em cache as consultas de reflect.Type e reflect.Value fora dos loops críticos. Use geração de código quando o desempenho for essencial.

Verificação rápida

Qual é a diferença entre reflect.Type.Kind() e reflect.Type.Name()?

Recapitulação: reflect.Type e reflect.Value

Pontos principais:

reflect.TypeOf/ValueOf para inspeção de tipos em tempo de execução
Kind: categoria subjacente; Name: nome declarado
Value.FieldByName + SetXxx para manipulação de campos de struct
Passe um ponteiro e chame Elem() para obter valores que podem ser definidos

Perguntas Frequentes

A aula “reflect.Type e reflect.Value” é grátis?

Sim — o texto completo de “reflect.Type e reflect.Value” é 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 “reflect.Type e reflect.Value”?

TypeOf, ValueOf, Kind e Elem 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 1 de 4.

Quanto tempo leva a aula “reflect.Type e reflect.Value”?

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

← Voltar para Go Academy