我如何在go映射中存储类型,以便在以后进行初始化

我如何在go映射中存储类型,以便在以后进行初始化,go,Go,我正在尝试实现一个工厂函数,它将返回满足接口X契约的许多结构之一的实例 m := make(map[string] ?) func init () { m["a"] = ? m["b"] = ? } type X interface { y() } type A struct {} func (a * A) y () {} type B struct {} func (b * B) y () {} function factory(name string) X

我正在尝试实现一个工厂函数,它将返回满足接口
X
契约的许多结构之一的实例

m := make(map[string] ?)
func init () {
    m["a"] = ?
    m["b"] = ?
}

type X interface { 
    y()
}

type A struct {}
func (a * A) y () {}

type B struct {}
func (b * B) y () {}


function factory(name string) X {
    return &m[name]{}
}

上面的代码只是我试图实现的一个简化演示-寻找指针,看看这是否可行,或者是否有一个不同的go习惯用法来解决我所缺少的此类需求。

您可以使用
map[string]X
,使用X作为接口(可以引用与X合同有关的任何对象的值或指针)

或者,如果有一个不同的围棋习语来解决我缺少的这种需求

您还可以使用反射(如“”)来实现工厂

reflect.New(yourtype).Elem().Interface()
您可以在“”中看到工厂示例


工厂方法的更快方法(每次返回一个新实例)是使用开关(如:


如果您有一个简单的值类型,那么正如@VonC所说,您可以使用
map[string]X
并返回示例值的副本

对于其他任何东西,我不使用反射,而是使用创建函数的映射

例如:():


谢谢@VonC。看起来使用实例注册类型会有一点额外的开销,但我猜该实例会很快被垃圾收集?@Ali AkberSaifee是的,它会。但是一般来说,反射速度较慢,所以如果你打算每秒数百次给工厂打电话,映射会更快。@Ali AkberSaifee你认为呢您的工厂是否返回a或B的新实例?如果是,我已经编辑了答案。对于我当前的用例,我可以只获取一个新实例-但就试图理解语言而言,我很好奇我是否可以返回比我的答案更有效的typeA函数图。+1
// Create a new Widget interface based on WidgetType and set WidgetInfo
func New(wt WidgetType, wi WidgetInfo) Widget_iface {
    switch wt {
    case Widget_A:
        return newWidgetA(wi)
    case Widget_B:
        return newWidgetB(wi)
    }
    return nil
} 
package main

import "fmt"

type X interface {
        y()
}

type newXFunc func() X

// Here just a map variable and two functions, but
// this could be a type with two methods instead.

var m = map[string]newXFunc{}

func register(name string, fn newXFunc) {
        m[name] = fn
}

func factory(name string) X {
        return m[name]()
}

func init() {
        // If register is exported than these
        // calls can be in other packages that
        // implement A and B.
        register("a", NewA)
        // For simple things that don't have/need
        // their own stand-alone "new" function.
        register("b", func() X { return B{} })
}

type A struct{}

func (a *A) y() {}
func NewA() X   { return &A{} }

type B struct{}

func (b B) y() {}

func main() {
        a1 := factory("a")
        b1 := factory("b")
        fmt.Printf("%T\n", a1)
        fmt.Printf("%T\n", b1)
}