如何创建具有不同签名的函数切片

Question

如何创建具有不同签名的函数切片？我试过下面的代码，但感觉很糟糕。我们只是咬紧牙关，使用切片接口｛｝吗？

package main
import (
    "fmt"
)
type OneParams func(string) string
type TwoParams func(string, string) string
type ThreeParams func(string, string, string) string
func (o OneParams) Union() string {
    return "Single string"
}
func (t TwoParams) Union() string {
    return "Double string"
}
func (t ThreeParams) Union() string {
    return "Triple string"
}
type Functions interface {
    Union() string
}
func Single(str string) string {
    return str
}
func Double(str1 string, str2 string) string {
    return str1 + " " + str2
}
func Triple(str1 string, str2 string, str3 string) string {
    return str1 + " " + str2 + " " + str3
}
func main() {
    fmt.Println("Slice Of Functions Program!nn")
    fSlice := []Functions{
        OneParams(Single),
        TwoParams(Double),
        ThreeParams(Triple),
    }
    for _, value := range fSlice {
        switch t := value.(type) {
        case OneParams:
            fmt.Printf("One: %sn", t("one"))
        case TwoParams:
            fmt.Printf("Two: %sn", t("one", "two"))
        case ThreeParams:
            fmt.Printf("Three: %sn", t("one", "two", "three"))
        default:
            fmt.Println("Huh! What's that?")
        }
    }
    fmt.Println("nn")
}

这只是一个试图用Go做太多事情的例子吗？

Answer 1

请检查一下，我不知道它是否符合您的要求。因为我不知道你到底想要什么。

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}
    f[0].(func())()
    f[1].(func(int))(15)
    f[2].(func(string, float32))("TEST", 90)
    fmt.Println("n******* another thing ******")
    for a, v := range f {
        v := reflect.TypeOf(v)
        fmt.Println("#######", a)
        fmt.Println("num param :", v.NumIn())
        for i := 0; i < v.NumIn(); i++ {
            fmt.Println("param :", i, "type is ", v.In(i))
        }
    }
}

检查Go Playground

这里我有另一个使用反射调用的例子

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}
        f[0].(func())()
        f[1].(func(int))(15)
        f[2].(func(string, float32))("TEST", 90)
        fmt.Println("n******* calling with reflect ******")
        for a, v := range f {
            v := reflect.TypeOf(v)
            //calling the function from reflect
            val := reflect.ValueOf(f[a])
            params := make([]reflect.Value, v.NumIn())
            if v.NumIn() == 1 {
                params[0] = reflect.ValueOf(1564)
            } else if v.NumIn() == 2 {
                params[0] = reflect.ValueOf("Test FROM reflect")
                params[1] = reflect.ValueOf(float32(123456))
            }
            val.Call(params)
        }
    }

检查Go Playground

Answer 2

取决于您需要的不同。以你为例，我们可以使用varadic。

package main
import(
    "fmt"
    "strings"
)
func foo(ss ...string) string{
    return strings.Join(ss, " ")
}
func main(){
    fmt.Println(foo("one"))
    fmt.Println(foo("one", "two"))
    fmt.Println(foo("one", "two", "three"))
}