Golang-如何创建具有不同签名的函数片段？

Question

How do you create a slice of functions with different signatures? I tried the code below but its feels hack-ish. Do we just bite the bullet and use a slice interface{}?

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!

")

    fSlice := []Functions{
        OneParams(Single),
        TwoParams(Double),
        ThreeParams(Triple),
    }

    for _, value := range fSlice {
        switch t := value.(type) {
        case OneParams:
            fmt.Printf("One: %s
", t("one"))
        case TwoParams:
            fmt.Printf("Two: %s
", t("one", "two"))
        case ThreeParams:
            fmt.Printf("Three: %s
", t("one", "two", "three"))
        default:
            fmt.Println("Huh! What's that?")
        }
    }

    fmt.Println("

")

}

Is this just a case of trying to do too much with Golang?

Answer 1

Please check it, I don't know if it what you want. Because I don't know what are you exactly want.

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("
******* 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))
        }
    }
}

Check on Go Playground

Here I have another example calling using reflect

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("
******* 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)
        }
    }

Check on Go Playground