Comment puis-je gérer efficacement des tranches de fonctions avec des signatures variables dans Go ?

Implémentation de tranches de fonctions avec des signatures variables

Problème :

Créer une tranche de fonctions avec des signatures variables dans Golang est stimulant. En utilisant l'extrait de code fourni, l'approche semble quelque peu « hacky ». Est-il nécessaire d'utiliser une tranche d'interface{} comme solution de contournement ?

Solution :

Utiliser une tranche d'interface{} est en effet une solution valable pour créer des tranches contenant des fonctions avec des signatures différentes. Cependant, une approche alternative consiste à tirer parti de la réflexion pour déterminer dynamiquement le nombre et les types de paramètres d'entrée pour chaque fonction.

Voici un exemple de code alternatif illustrant l'utilisation de la réflexion :

package main

import (
    "fmt"
    "reflect"
)

func A() {
    fmt.Println("A")
}

func B(a int) {
    fmt.Println("B", a)
}

func C(a string, b float32) {
    fmt.Println("C", a, b)
}

func main() {
    f := []interface{}{A, B, C}

    for _, v := range f {
        fn := reflect.ValueOf(v)
        fmt.Printf("Function: %v\n", fn.Type())

        numArgs := fn.Type().NumIn()
        fmt.Printf("Number of arguments: %v\n", numArgs)

        for i := 0; i < numArgs; i++ {
            argType := fn.Type().In(i)
            fmt.Printf("Arg %v Type: %v\n", i+1, argType)
        }

        fmt.Printf("Calling function using reflection...\n")
        callArgs := []reflect.Value{}
        for i := 0; i < numArgs; i++ {
            switch fn.Type().In(i).Kind() {
            case reflect.Int:
                callArgs = append(callArgs, reflect.ValueOf(i+1))
            case reflect.String:
                callArgs = append(callArgs, reflect.ValueOf(fmt.Sprintf("Arg-%v", i+1)))
            case reflect.Float32:
                callArgs = append(callArgs, reflect.ValueOf(float32(i+1)))
            }
        }
        fn.Call(callArgs)
    }
}

Cette approche fournit un accès direct aux paramètres de fonction individuels (types et valeurs) par réflexion, permettant une gestion plus dynamique des tranches de fonctions avec des signatures différentes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!