Go中如何调用参数数量未知的非可变参数函数？

问题背景 #

定义如下结构体和函数映射表：

// fninfo holds a function and its arity.
type fninfo struct {
    arity int // number of arguments that fn takes
    fn    any // fn must take string arguments and return one string
}

var fnmap = map[string]fninfo{
    "not": fninfo{
        arity: 1,
        fn: func(a string) string { /* 函数体省略 */ },
    },
    "add": fninfo{
        arity: 2,
        fn: func(a, b string) string { /* 函数体省略 */ },
    },
    // 更多函数项...
}

期望实现的逻辑是：根据函数名从fnmap中取出fninfo，从栈中弹出对应arity数量的字符串作为参数，调用目标函数。但遇到两个问题：

1. info.fn类型为any，无法直接调用
2. 目标函数非可变参数，不能直接用切片传参

目前通过手动类型断言处理1-3个参数的函数，冗余且难以维护，需要更通用的解决方法。

方案一：无反射——统一包装函数类型 #

通过定义统一的函数类型，将不同参数数量的函数适配为接受切片参数的形式，彻底规避类型和传参问题。

修改结构体定义 #

import "fmt"

// 统一的函数类型：接受字符串切片参数，返回字符串和错误
type StringFunc func([]string) (string, error)

type fninfo struct {
    arity int
    fn    StringFunc
}

初始化映射表 #

将原有函数包装为StringFunc类型，在包装层处理参数数量校验：

var fnmap = map[string]fninfo{
    "not": {
        arity: 1,
        fn: func(args []string) (string, error) {
            if len(args) != 1 {
                return "", fmt.Errorf("not函数需要1个参数，实际传入%d个", len(args))
            }
            // 执行原not函数逻辑
            return "not " + args[0], nil
        },
    },
    "add": {
        arity: 2,
        fn: func(args []string) (string, error) {
            if len(args) != 2 {
                return "", fmt.Errorf("add函数需要2个参数，实际传入%d个", len(args))
            }
            // 执行原add函数逻辑
            return args[0] + args[1], nil
        },
    },
    // 新增函数时只需添加对应的包装逻辑
}

调用逻辑 #

info := fnmap[fnname]
args := make([]string, info.arity)
for i := 0; i < len(args); i++ {
    var err error
    args[i], err = stk.pop()
    if err != nil {
        // 处理栈弹出错误
        return err
    }
}

result, err := info.fn(args)
if err != nil {
    // 处理函数调用错误
    return err
}
// 使用返回结果result

这种方案类型安全，无反射开销，新增函数时只需添加对应的包装逻辑，维护成本低。

方案二：使用反射——动态调用原有函数 #

如果不想修改原有函数的定义，可以利用Go的reflect包实现动态调用，适配不同参数数量的函数。

调用逻辑实现 #

import (
    "fmt"
    "reflect"
)

info := fnmap[fnname]
args := make([]string, info.arity)
for i := 0; i < len(args); i++ {
    var err error
    args[i], err = stk.pop()
    if err != nil {
        // 处理栈弹出错误
        return err
    }
}

// 将字符串参数转换为reflect.Value切片
reflectArgs := make([]reflect.Value, len(args))
for i, arg := range args {
    reflectArgs[i] = reflect.ValueOf(arg)
}

// 获取函数的反射值并调用
fnValue := reflect.ValueOf(info.fn)
// 校验参数数量是否匹配
if fnValue.Type().NumIn() != len(reflectArgs) {
    return fmt.Errorf("函数期望%d个参数，实际传入%d个", fnValue.Type().NumIn(), len(reflectArgs))
}

// 调用函数并处理返回值
results := fnValue.Call(reflectArgs)
if len(results) != 1 {
    return fmt.Errorf("函数未返回预期的1个值")
}
result, ok := results[0].Interface().(string)
if !ok {
    return fmt.Errorf("函数返回值不是字符串类型")
}

// 使用返回结果result

这种方案无需修改原有函数，但存在反射性能开销，且需要额外的类型校验逻辑，适合已有大量函数的场景。

内容的提问来源于stack exchange，提问作者ban_javascript