如何在 Go 中使用反射检查函数签名

funcType := reflect.TypeOf(myFunc).In(0).Type()

import (
   "fmt"
   "reflect"
)

// Define an interface for input validators
type Validator func(interface{}) error

// Check the signature of an input validator function
func checkValidatorSignature(val Validator) error {
   // Get the function type
   funcType := reflect.TypeOf(val)
   
   // Check if it is a function with one input and one output
   if funcType.Kind() != reflect.Func || funcType.NumIn() != 1 || funcType.NumOut() != 1 {
       return fmt.Errorf("invalid validator signature")
   }
   
   // Check if the input parameter is an interface
   inType := funcType.In(0)
   if inType.Kind() != reflect.Interface {
       return fmt.Errorf("input parameter must be an interface")
   }

   // Check if the output parameter is an error
   outType := funcType.Out(0)
   if outType.Kind() != reflect.Interface || outType.Implements(reflect.TypeOf((*error)(nil)).Elem()) {
       return fmt.Errorf("output parameter must be an error")
   }
   
   return nil
}

// Example usage
func main() {
   // Define a valid input validator function
   validValidator := func(input interface{}) error {
       return nil
   }

   // Define an invalid input validator function (wrong number of inputs)
   invalidValidator := func(a, b interface{}) error {
       return nil
   }

   // Check the signatures of the functions
   if err := checkValidatorSignature(validValidator); err != nil {
       fmt.Println(err)
   }

   if err := checkValidatorSignature(invalidValidator); err != nil {
       fmt.Println(err)
   }
}