0Pricing
Go Academy · Leçon

Appels de fonctions dynamiques

Appeler des fonctions et définir des valeurs avec reflect

Appels de fonctions dynamiques est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

reflect.Value.Call

Value.Call(args) appelle la fonction représentée par la Value avec les arguments fournis (sous forme de []reflect.Value) et renvoie les résultats sous forme de []reflect.Value.

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

Vérification du type des arguments

Vérifiez que les types des arguments correspondent à la signature de la fonction avant de l’appeler. Des types incompatibles provoquent une panique.

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") }
}

Fonctions variadiques

Appelez une fonction variadique avec Value.Call (en développant la slice) ou Value.CallSlice (en transmettant les arguments variadiques sous forme de valeur 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 crée une nouvelle fonction lors de l’exécution avec un type donné et un corps enveloppant. Il est utilisé pour générer des fonctions adaptatrices destinées aux 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)))}
})

Appel de méthodes par leur nom

Récupérez une méthode par son nom et appelez-la :

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

Vérifier l’existence d’une méthode

Vérifiez toujours m.IsValid() avant l’appel : MethodByName renvoie la Value nulle si la méthode est introuvable, et l’appel de cette Value nulle provoque une panique.

Cas d’utilisation de l’appel dynamique

Les appels de fonctions dynamiques sont utilisés dans les systèmes de modules d’extension (appeler des fonctions par leur nom sous forme de chaîne), les infrastructures de test (appeler des fonctions TestXxx), les répartiteurs RPC (associer des noms de méthodes à des gestionnaires) et les décorateurs.

Performances

reflect.Call est environ 10 à 50 fois plus lent qu’un appel direct. Mettez en cache le reflect.Value des fonctions fréquemment appelées ; évitez de les utiliser dans les boucles critiques.

Enveloppe à typage sûr

Enveloppez les appels dynamiques dans un assistant typé qui effectue une seule fois le mécanisme de réflexion au démarrage, puis appelle plusieurs fois la Value mise en cache :

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

Gestion de la valeur d’erreur renvoyée

Si la fonction renvoie une erreur comme dernier résultat, extrayez-la et vérifiez-la :

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

Alternatives à la réflexion

Si l’ensemble des fonctions est connu à la compilation, utilisez une map de valeurs de fonctions (map[string]func(...)) plutôt que la réflexion : cette solution est plus sûre et plus rapide.

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

Vérification rapide

Que renvoie reflect.Value.Call ?

Récapitulatif : appels de fonctions dynamiques

Points clés :

  • Value.Call([]reflect.Value) invoque la fonction et renvoie []reflect.Value
  • Vérifier m.IsValid() avant d’appeler le résultat de MethodByName
  • MakeFunc crée une nouvelle fonction du type donné lors de l’exécution
  • Préférer map[string]func à la réflexion pour les ensembles de fonctions connus

Questions Fréquemment Posées

La leçon « Appels de fonctions dynamiques » est-elle gratuite ?

Oui — le texte complet de « Appels de fonctions dynamiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Appels de fonctions dynamiques » ?

Appeler des fonctions et définir des valeurs avec reflect Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Appels de fonctions dynamiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. reflect.Type et reflect.Value
  2. Inspecter les champs et balises des structs
  3. Appels de fonctions dynamiques
  4. Réflexion pratique : sérialiseurs
← Retour à Go Academy