Chiamate dinamiche di funzioni
Chiamare funzioni e impostare valori tramite reflect
Chiamate dinamiche di funzioni è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.
reflect.Value.Call
Value.Call(args) chiama la funzione rappresentata dal Value con gli argomenti specificati (come []reflect.Value) e restituisce i risultati come []reflect.Value.
fn := reflect.ValueOf(add)
results := fn.Call([]reflect.Value{
reflect.ValueOf(2),
reflect.ValueOf(3),
})
fmt.Println(results[0].Int()) // 5Verifica dei tipi degli argomenti
Verifichi che i tipi degli argomenti corrispondano alla firma della funzione prima della chiamata. I tipi non corrispondenti causano un panic.
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") }
}Funzioni variadiche
Chiami una funzione variadica con Value.Call (espandendo la slice) oppure con Value.CallSlice (passando gli argomenti variadici come valore slice):
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 crea una nuova funzione a runtime con un determinato tipo e un corpo wrapper. Viene utilizzata per generare funzioni adattatrici per le interfacce.
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)))}
})Chiamata dei metodi per nome
Recuperi un metodo per nome e lo chiami:
v := reflect.ValueOf(myObj)
m := v.MethodByName("Process")
if m.IsValid() {
m.Call(nil)
}Verifica dell'esistenza di un metodo
Verifichi sempre m.IsValid() prima della chiamata: MethodByName restituisce il Value zero se il metodo non viene trovato e la chiamata del Value zero causa un panic.
Casi d'uso del dispatch dinamico
Le chiamate dinamiche alle funzioni vengono utilizzate nei sistemi di plugin (chiamare funzioni tramite nome stringa), nei framework di test (chiamare funzioni TestXxx), nei dispatcher RPC (mappare i nomi dei metodi agli handler) e nei decorator.
Prestazioni
reflect.Call è circa 10-50 volte più lento di una chiamata diretta. Memorizzi nella cache il reflect.Value delle funzioni chiamate frequentemente ed eviti di utilizzarlo nei cicli ad alta frequenza.
Wrapper type-safe
Avvolga le chiamate dinamiche in un helper tipizzato che esegua una sola volta la logica di reflection durante l'avvio e chiami ripetutamente il Value memorizzato nella cache:
type Processor func(context.Context, []byte) ([]byte, error)
// Build at startup, reuse at request timeGestione del valore di errore
Se la funzione restituisce un errore come ultimo risultato, lo estragga e lo verifichi:
results := fn.Call(args)
if !results[len(results)-1].IsNil() {
return results[len(results)-1].Interface().(error)
}Alternative alla reflection
Se l'insieme di funzioni è noto a compile time, utilizzi una mappa di valori funzione (map[string]func(...)) invece della reflection: è più sicura e veloce.
handlers := map[string]func(ctx context.Context, req []byte) []byte{
"greet": greetHandler,
}Verifica rapida
Che cosa restituisce reflect.Value.Call?
Riepilogo: chiamate dinamiche alle funzioni
Punti chiave:
- Value.Call([]reflect.Value) invoca la funzione e restituisce []reflect.Value
- Verificare m.IsValid() prima di chiamare il risultato di MethodByName
- MakeFunc crea a runtime una nuova funzione con un determinato tipo
- Preferire map[string]func alla reflection per insiemi di funzioni noti
Domande Frequenti
La lezione «Chiamate dinamiche di funzioni» è gratuita?
Sì — il testo completo di «Chiamate dinamiche di funzioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.
Cosa imparerò in «Chiamate dinamiche di funzioni»?
Chiamare funzioni e impostare valori tramite reflect Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Go Academy?
Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Chiamate dinamiche di funzioni»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Go Academy?
Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- reflect.Type e reflect.Value
- Ispezionare i campi e i tag delle struct
- Chiamate dinamiche di funzioni
- Reflection pratica: serializzatori