我想知道如何做类似的事情。我目前有多个具有相同结构和功能的包，但它们实际上从多个 API 检索值。我还加载了一个配置，该配置具有一个带有参数的数组，以便每个数组项使用这些包之一。 我想知道如何根据配置值创建一个使用这些包之一的变量。希望这已经足够清楚了。这是我编写的用于解释的伪代码。提前致谢

package main

import (
    "errors"
    "flag"
    "os"
    "project/lib"
    "project/morelib"
    "project/extralib"
    "fmt"
    "math"
    "math/rand"
    "time"
)

func stuff(info RunInfo) (err error) {

    apiKey:= "stuff1" // actually in the config
    apiSecret := "stuff2" // actually in the config
    variable := lib.New(apiKey, apiSecret) //returns *Lib struct 
    //this is where I have to comment out the other libs and uncomment them as needed
    // variable := morelib.New(apiKey, apiSecret)
    // variable := extralib.New(apiKey, apiSecret)

//trying to switch between libraries like this or in a switch statement
    if info.libname == "lib"{
        variable = lib.New(apiKey, apiSecret) //.New("", "") returns *Lib struct
    }else if info.libname == "morelib"{
        variable = morelib.New(apiKey, apiSecret) //.New("", "") returns *MoreLib struct
    }else if info.libname == "extralib"{
        variable = extralib.New(apiKey, apiSecret) //.New("", "") returns *ExtraLib struct
    }else{
        err = errors.New("there was an error with the value.....")
        return err
    }

    mystuffs, err := variable.GetBalance("USD")
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("mystuff value: %v", mystuffs.value)

    return 

}
type RunInfo struct{
    libname string
    //other stuff
}
func main() {
    //load from config with array 
    config := config.Load()
    for i:=0; i<compare; i++{
        var runInfo RunInfo
        runInfo.libname = config.libname
        stuff(runInfo)
    }
}

伪库代码:

func New(apiKey, apiSecret string) *Lib {
client := NewClient(apiKey, apiSecret)
return &Lib{client}
}
func NewClient(apiKey, apiSecret string) (c *client) {
    return &client{apiKey, apiSecret, &http.Client{}, false}
}
type Lib struct {
    client *client
}
type client struct {
    apiKey     string
    apiSecret  string
    httpClient *http.Client
    debug      bool
}

func (b *Lib) GetBalance(currency string) (balance Balance, err error) {
    payload, err := json.Marshal(BalanceParams{Currency: currency})
    if err != nil {
        return
    }
    r, err := b.client.do("POST", "GetBalance", string(payload), true)
    if err != nil {
        return
    }
    var response jsonResponse
    if err = json.Unmarshal(r, &response); err != nil {
        return
    }
    if err = handleErr(response); err != nil {
        return
    }
    err = json.Unmarshal(response.Result, &balance)

    return
}

最佳答案

在问题中使用 and if 语句、switch 语句或映射。

我假设 New 函数返回的类型是以下接口(interface):

type GetStuffer interface 
    GetStuff(string) (Stuff, error)
}

switch语句是:

var variable GetStuffer
switch info.CompareVal {
case "lib":
    variable = lib.New(string1, string2) 
case "morelib":
    variable = morelib.New(string1, string2)
case "extralib":
    variable = extralib.New(string1, string2)
default:
     return errors.New("there was an error with the value.....")
}

mystuffs, err := variable.GetMyStuff()
if err != nil {
    fmt.Println(err)
    return
}

对于 map ，用 map 初始化一个包级变量:

var m = map[string]func(string,string) GetStuffer {
   "lib": lib.New,
   "morelib": morelib.New,
   "extralib": extralib.New,
}

并像这样使用它:

fn := m[info.CompareValue]
if m == nil {
     return errors.New("there was an error with the value.....")
}
variable := fn(string1, string2)
mystuffs, err := variable.GetMyStuff()
if err != nil {
    fmt.Println(err)
    return
}

如果上面关于返回类型的假设不正确，那么有两种选择。第一个也是最简单的方法是修改 New 函数以返回类型 GetStuffer。如果那不可能，则编写一些适配器函数:

 var m = map[string]func(string,string) GetStuffer {
   "lib":func(s1, s2 string) GetStuffer { return lib.New(s1, s2) }
   "morelib":func(s1, s2 string) GetStuffer { return morelib.New(s1, s2) }
   "extralib":func(s1, s2 string) GetStuffer { return extralib.New(s1, s2) }
}

关于pointers - 如何在 Go 中引用具有相同功能的多个库并在它们之间内联切换，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49040690/