Golang通过反射动态调用包下面方法、动态调用结构体下方法，类似JS的eval

1. Golang通过反射动态调用包下面方法 --> 需要先注册

2. 动态调用结构体下方法

3. 类似JS的eval

eval.go

package util

import (
	"errors"
	"fmt"
	"reflect"
)

// 调用结构体下方法
func CallMethod(instance interface{}, methodName string, args ...interface{}) ([]interface{}, error) {
	// 获取方法的反射值
	methodValue := reflect.ValueOf(instance).MethodByName(methodName)

	// 检查方法是否存在
	if !methodValue.IsValid() {
		return nil, fmt.Errorf("method not found: %s", methodName)
	}

	// 如果方法是通过指针接收者定义的，则获取指针类型的反射值
	if methodValue.Type().IsVariadic() {
		ptrValue := reflect.ValueOf(instance)
		methodValue = ptrValue.MethodByName(methodName)
	}

	// 构造方法的参数列表
	methodArgs := make([]reflect.Value, len(args))
	for i, arg := range args {
		methodArgs[i] = reflect.ValueOf(arg)
	}

	// 调用方法并获取返回值
	resultValues := methodValue.Call(methodArgs)

	// 如果方法没有返回值，则返回 nil
	if len(resultValues) == 0 {
		return nil, nil
	}

	// 将返回值转为 interface{} 类型并返回
	results := make([]interface{}, len(resultValues))
	for i, v := range resultValues {
		results[i] = v.Interface()
	}
	return results, nil
}

// 注册变量
var importedFunctions = make(map[string]map[string]interface{})

// 注册
func RegisterFunction(packageName, funcName string, function interface{}) {
	if importedFunctions[packageName] == nil {
		importedFunctions[packageName] = make(map[string]interface{})
	}
	importedFunctions[packageName][funcName] = function
}

// 调用包下面的方法
func Eval(packageName string, funcName string, args ...interface{}) ([]interface{}, error) {
	// Get the function's reflect.Value using the package path and function name
	funcValue := reflect.ValueOf(importedFunctions[packageName][funcName])

	// Check if the function exists
	if !funcValue.IsValid() {
		return nil, errors.New("Failed to find function: " + funcName)
	}

	// Construct the function's argument list
	funcArgs := make([]reflect.Value, len(args))
	for i, arg := range args {
		funcArgs[i] = reflect.ValueOf(arg)
	}

	// Call the function and get the return values
	resultValues := funcValue.Call(funcArgs)

	// Convert the return values to interface{} and save them in the result slice
	results := make([]interface{}, len(resultValues))
	for i, result := range resultValues {
		results[i] = result.Interface()
	}

	return results, nil
}

main.go

package main

import (
	"fmt"
	"reflect"
	"test/util"
)

type MyStruct struct{}

func (s MyStruct) Hello(name string) string {
	return "Hello, " + name + "!"
}

func (s *MyStruct) Add(a, b int) int {
	return a + b
}

func Add(a, b int) int {
	return a + b
}

func init() {
	// 注册
	util.RegisterFunction("main", "Add", Add)
}

func main() {
	// 通过包名和方法名动态调用
	packageName := "main"
	funcName := "Add"
	args := []interface{}{10, 20}
	results, err := util.Eval(packageName, funcName, args...)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	sum := results[0].(int)
	fmt.Println("Result:", sum) // Output: Result: 30

	// 通过结构体动态调用地下方法
	instance := MyStruct{}

	// 调用 Hello 方法
	result1, _ := util.CallMethod(instance, "Hello", "John")
	fmt.Println(result1[0].(string)) // Output: Hello, John!

	// 调用 Add 方法
	args2 := []interface{}{10, 20}
	result2, _ := util.CallMethod(&instance, "Add", args2...)
	fmt.Println(result2[0].(int)) // Output: 30
}

运行截图