Go语言如何实现支持可变参数的泛型函数以适配任意函数调用？

问题说明 #

开发任务记账模块时，需要实现能接收任意函数与参数列表并调用目标函数的功能。测试代码里Run函数可正常运行，但RunVarArgs调用fn1和fn2时均编译失败：

1. 调用RunVarArgs(fn1, data)：无法将func(s someStruct)转为func(...T)，也无法将someStruct类型的data转为T
2. 调用RunVarArgs(fn2, "Hello", " World")：无法将func(str1 string, str2 string)转为func(...string)

测试代码如下：

package main

import (
    "fmt"
    "time"
)

func Run[T any](f func(T), args T) {
    f(args)
}

func RunVarArgs[T any](f func(...T), args ...T) {
    f(args...)
}

type someStruct struct {
    str  string
    time int
}

func fn1(s someStruct) {
    time.Sleep(time.Duration(s.time) * time.Second)
    fmt.Println(s.str + " ")
}

func fn2(str1 string, str2 string) {
    fmt.Println(str1 + str2)
}

func main() {
    data := someStruct{
        str:  "Hello World",
        time: 5,
    }

    // 可正常编译运行
    Run(fn1, data)

    // 编译报错
    // RunVarArgs(fn1, data)

    // 编译报错
    // RunVarArgs(fn2, "Hello", " World")
}

解决方案 #

Go的泛型无法直接把固定参数函数和可变参数函数（...T）隐式转换，要实现需求有两种可行方案：

方案1：用反射实现通用调用 #

反射能绕过编译期类型检查，动态调用任意函数和参数，是最通用的方案：

package main

import (
    "fmt"
    "reflect"
    "time"
)

type someStruct struct {
    str  string
    time int
}

func fn1(s someStruct) {
    time.Sleep(time.Duration(s.time) * time.Second)
    fmt.Println(s.str)
}

func fn2(str1 string, str2 string) {
    fmt.Println(str1 + str2)
}

// 通用调用函数：接收任意函数和参数
func CallFunc(fn interface{}, args ...interface{}) error {
    fnVal := reflect.ValueOf(fn)
    if fnVal.Kind() != reflect.Func {
        return fmt.Errorf("传入的不是函数")
    }

    // 把参数转换成reflect.Value切片
    argVals := make([]reflect.Value, len(args))
    for i, arg := range args {
        argVals[i] = reflect.ValueOf(arg)
    }

    // 检查参数数量是否匹配
    if len(argVals) != fnVal.Type().NumIn() {
        return fmt.Errorf("参数数量不匹配：预期%d个，传入%d个", fnVal.Type().NumIn(), len(argVals))
    }

    // 动态调用函数
    fnVal.Call(argVals)
    return nil
}

func main() {
    data := someStruct{
        str:  "Hello World",
        time: 1, // 缩短等待时间方便测试
    }

    _ = CallFunc(fn1, data)
    _ = CallFunc(fn2, "Hello", " World")
}

• 优势：能处理任意签名的函数，完全通用
• 劣势：失去编译期类型检查，需要自己处理参数匹配错误

方案2：泛型+函数包装（类型安全但扩展性有限） #

如果不想用反射，可以针对不同参数数量的函数写泛型适配函数，或者手动把固定参数函数包装成可变参数函数：

package main

import (
    "fmt"
    "time"
)

type someStruct struct {
    str  string
    time int
}

func fn1(s someStruct) {
    time.Sleep(time.Duration(s.time) * time.Second)
    fmt.Println(s.str)
}

func fn2(str1 string, str2 string) {
    fmt.Println(str1 + str2)
}

// 适配单参数函数的泛型调用
func RunSingle[T any](f func(T), arg T) {
    f(arg)
}

// 适配双参数同类型函数的泛型调用
func RunDouble[T any](f func(T, T), arg1, arg2 T) {
    f(arg1, arg2)
}

// 原RunVarArgs函数
func RunVarArgs[T any](f func(...T), args ...T) {
    f(args...)
}

func main() {
    data := someStruct{
        str:  "Hello World",
        time: 1,
    }

    // 直接调用适配函数
    RunSingle(fn1, data)
    RunDouble(fn2, "Hello", " World")

    // 手动包装fn2为可变参数函数后调用原RunVarArgs
    wrappedFn2 := func(strs ...string) {
        if len(strs) >= 2 {
            fn2(strs[0], strs[1])
        }
    }
    RunVarArgs(wrappedFn2, "Hello", " World")
}

• 优势：保留编译期类型安全，不会出现运行时类型错误
• 劣势：需要为不同参数数量/类型组合编写适配函数，扩展性差

总结 #

如果需要完全通用的任意函数调用能力，反射方案是最优选择；如果函数签名有限且追求类型安全，可以使用泛型适配方案。

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