编写可变函数

在 Go 语言中，需要实现一个函数，该函数接受一个类型可变的对象（结构），并根据输入参数的类型执行不同的操作。该函数中需要使用一个动态函数 variableFunc，它可以根据输入对象的类型应用不同的逻辑。由于已经存在一个 switch-case 语句来确定对象的类型，希望避免额外的 switch-case。本文将提供一种解决方案，利用延迟或使用可变函数参数，以在 switch-case 内部实现所需的灵活性。

我需要在 golang 中实现一个现有的逻辑。一般来说，它是这样的：

// Function receives an object with a variable type (struct)
func(dynObject interface{}) {

    var variableFunc ... // What should be here?

    // Some things to do depending on the input param type
    switch dynObject.(type) {
    case *objA:
        // do some job
    case *objB:
        // do some job
    }

    // ...
    // Creating and calculating some variables for the following loop
    // ...

    humans := []*Humans{ ....... }
    sum := []int{}

    for _, human := range humans {
        result := variableFunc(dynObject, human)
        sum = append(sum, result)
    }
}

如您所见 - 作为输入，有一个 dynobject，它是一个结构，但可以是任何预定义的结构。后来有一个函数 variablefunc 必须拿这个对象进行处理，处理逻辑也取决于类型。因此 obja 类型需要与 objb 不同的逻辑。

我不知道实现这个的正常方法。如何创建这个动态函数，它可以采用不同的结构作为输入并对其应用所需的逻辑？目前我收到错误，该函数需要另一种类型作为输入。我希望避免额外的 switch-case，因为已经存在了。

当然，我尝试创建一个预定义的函数，并使用接口，然后以某种方式在现有的 switch-case 内部重新定义它，但没有运气。我需要你的帮助

解决方案

package main

import "fmt"

func main() {
    common(4)
    common("whitespace")
}
func common(a interface{}) {
    switch a.(type) {
    case int:
        div(a.(int), 2)
        break
    case string:
        sayhello(a.(string))
        break
    default:
        //nothing
    }
    return
}
func div(a, b int) {
    fmt.printf("%d", a/b)
    return
}
func sayhello(a string) {
    fmt.printf("%s", a)
}

main 函数调用 common 函数，这又调用两个不同的函数，它们具有不同的函数签名。您可以看到它们执行不同的操作。因此，这将为不同的输入打印不同的结果。如果您想要在 switch 语句中调用不同的函数（正如我可以从您的评论中收集到的那样），那么这应该可以做到。让我知道。

package stackoverflow

import "fmt"

func common(a interface{}) {
    switch a.(type) {
    case int:
        defer func(b int) {
            fmt.printf("%d \n", b/2)
        }(a.(int))
        break
    case string:
        defer func(b string) {
            fmt.printf("hello %s \n", b)
        }(a.(string))
        break
    default:
        //nothing
    }

    //do something here
    fmt.println("did something here test")
    // the function gets called after
    return
}

您可以使用延迟。因此，这不是 defer 的常规用法。但从技术上讲，它可以用于类似的事情。上述功能仅在 //something 完成后才会执行，我相信这就是您所追求的灵活性。如果某些函数发生恐慌，该语句将出现在执行和退出之间。所以，你必须知道你在做什么。

或者您可以使用它，以防稍后有参数传入。

package stackoverflow

import "fmt"

func common(a interface{}) {
    var f func(interface{}, int)
    switch a.(type) {
    case int:
        f = func(s interface{}, b int) {
            fmt.Printf("%d and %d\n", s.(int)/2, b)
        }
        break
    case string:
        f = func(b interface{}, c int) {
            fmt.Printf("hello %s and %d \n", b.(string), c)
        }
        break
    default:
        //nothing
    }
    //do something here
    fmt.Println("did something here test")
    // the function gets called after
    var x int = 21

    f(a, x)

    return
}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。