Go Academy · Aula

Chamadas dinâmicas de funções

Chame funções e defina valores por meio de reflect

Chamadas dinâmicas de funções é 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.

reflect.Value.Call

Value.Call(args) chama a função representada pelo Value com os argumentos fornecidos (como um []reflect.Value) e retorna os resultados como um []reflect.Value.

fn := reflect.ValueOf(add)
results := fn.Call([]reflect.Value{
    reflect.ValueOf(2),
    reflect.ValueOf(3),
})
fmt.Println(results[0].Int()) // 5

Verificação dos tipos dos argumentos

Certifique-se de que os tipos dos argumentos correspondam à assinatura da função antes de chamá-la. Tipos incompatíveis causam um pânico.

t := reflect.TypeOf(fn)
if t.NumIn() != len(args) { panic("wrong arg count") }
for i, arg := range args {
    if !reflect.TypeOf(arg).AssignableTo(t.In(i)) { panic("type mismatch") }
}

Funções variádicas

Chame uma função variádica com Value.Call (expandindo a fatia) ou Value.CallSlice (passando os argumentos variádicos como um valor de fatia):

sum := reflect.ValueOf(func(ns ...int) int {
    total := 0
    for _, n := range ns { total += n }
    return total
})
args := reflect.ValueOf([]int{1,2,3})
results := sum.CallSlice([]reflect.Value{args})

reflect.MakeFunc

reflect.MakeFunc cria uma nova função em tempo de execução com um tipo fornecido e um corpo wrapper. É usado para gerar funções adaptadoras para interfaces.

t := reflect.TypeOf(func(int) string { return "" })
fn := reflect.MakeFunc(t, func(args []reflect.Value) []reflect.Value {
    return []reflect.Value{reflect.ValueOf(strconv.Itoa(args[0].Interface().(int)))}
})

Chamando métodos pelo nome

Recupere um método pelo nome e chame-o:

v := reflect.ValueOf(myObj)
m := v.MethodByName("Process")
if m.IsValid() {
    m.Call(nil)
}

Verificando se um método existe

Sempre verifique m.IsValid() antes de chamar — MethodByName retorna o Value zero quando o método não é encontrado, e chamar o Value zero causa um pânico.

Casos de uso do despacho dinâmico

Chamadas dinâmicas de funções são usadas em: sistemas de plug-ins (chamar funções pelo nome em uma string), estruturas de teste (chamar funções TestXxx), despachantes RPC (mapear nomes de métodos para manipuladores) e decoradores.

Desempenho

reflect.Call é aproximadamente 10–50× mais lento que uma chamada direta. Armazene em cache o reflect.Value de funções chamadas com frequência e evite usá-lo em loops críticos.

Adaptador com segurança de tipos

Envolva chamadas dinâmicas em um auxiliar tipado que execute o mecanismo de reflexão uma vez durante a inicialização e chame repetidamente o Value armazenado em cache:

type Processor func(context.Context, []byte) ([]byte, error)
// Build at startup, reuse at request time

Tratamento do retorno de erros

Se a função retornar um erro como último resultado, extraia-o e verifique-o:

results := fn.Call(args)
if !results[len(results)-1].IsNil() {
    return results[len(results)-1].Interface().(error)
}

Alternativas à reflexão

Se o conjunto de funções for conhecido em tempo de compilação, use um mapa de valores de função (map[string]func(...)) em vez de reflexão — é mais seguro e rápido.

handlers := map[string]func(ctx context.Context, req []byte) []byte{
    "greet": greetHandler,
}

Verificação rápida

O que reflect.Value.Call retorna?

Recapitulação: chamadas dinâmicas de funções

Pontos principais:

Value.Call([]reflect.Value) invoca a função e retorna []reflect.Value
Verifique m.IsValid() antes de chamar o resultado de MethodByName
MakeFunc cria uma nova função com um tipo fornecido em tempo de execução
Prefira map[string]func à reflexão para conjuntos de funções conhecidos

Perguntas Frequentes

A aula “Chamadas dinâmicas de funções” é grátis?

Sim — o texto completo de “Chamadas dinâmicas de funções” é 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 “Chamadas dinâmicas de funções”?

Chame funções e defina valores por meio de reflect 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 “Chamadas dinâmicas de funções”?

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