3

简单版
如何根据字符串的值创建某种类型的变量？

type ta struct { a int }
type tb struct { b float }
type tc struct { c string }

t := "tb"
v := MagicVarFunc(t) // Returns a new allocated var of type interface{}
v.(tb).b = 8.3

真正的例子
在下面的工作示例中，令人惊讶的是，我正在基于字符串动态创建变量。这是通过在映射中注册每个结构类型来完成的，其中字符串是键，类型的空指针是值。
每种类型都使用 New() 方法实现一个接口，该方法返回该特定类型的新变量。

下面的示例非常接近我想要做的，其中每个操作都有一组 JSON 编码数据，这些数据将填充相应的结构。我构建它的方式也是因为我希望能够创建我注册到地图的新的独立操作。

我不确定现在是否在滥用语言。
如果我完全失去理智，有人可以给我任何指示吗？有明显更简单的方法吗？

package main

import (
    "fmt"
    "encoding/json"
)

// All I require of an action is that it may be executed
type ActionHandler interface {
    Exec()
    New() ActionHandler
}

// My list of actions
var mActions = make(map[string]ActionHandler)

// Action Exit (leaving the program)
type aExit struct {}
func (s *aExit) Exec() { fmt.Println("Good bye") }
func (s *aExit) New() ActionHandler { return new(aExit) }
func init() {
    var a *aExit
    mActions[`exit`] = a
}

// Action Say (say a message to someone)
type aSay struct {
    To  string
    Msg string
}
func (s *aSay) Exec() { fmt.Println(`You say, "` + s.Msg + `" to ` + s.To) }
func (s *aSay) New() ActionHandler { return new(aSay) }
func init() {
    var a *aSay
    mActions[`say`] = a
}

func inHandler(action string, data []byte) {
    a := mActions[action].New()
    json.Unmarshal(data, &a)
    a.Exec()
}

func main(){
    inHandler(`say`, []byte(`{"to":"Sonia","msg":"Please help me!"}`))
    inHandler(`exit`, []byte(`{}`))
}
4

3 回答 3

7

如果可以在运行时获取值，则可以使用反射来获取零值，或使用反射分配new类型的新值（如 ）Type。但是，我认为没有办法Type从字符串中获取。您需要具有该类型的值才能获取类型本身。

我采纳了你的想法，使用地图。我将字符串映射到类型本身，您可以使用reflect.TypeOf它从接口值中获取类型。然后我用来reflect.Zero获取该类型的零值（每个类型都存在的方便值）。然后我将值作为接口输出。

package main
import "reflect"

type ta struct { a int }
type tb struct { b float64 }
type tc struct { c string }

var mActions map[string]reflect.Type = make(map[string]reflect.Type)
func init() {
  var a ta
  mActions[`ta`] = reflect.TypeOf(a)
  var b tb
  mActions[`tb`] = reflect.TypeOf(b)
  var c ta
  mActions[`tc`] = reflect.TypeOf(c)
}

func MagicVarFunc(action string) interface{} {
  return reflect.Zero(mActions[action]).Interface()
}

func main() {
  t := "tb"
  v := MagicVarFunc(t) // Returns a new allocated var of type interface{}
  x := v.(tb)
  x.b = 8.3
}
于 2012-06-21T01:56:48.013 回答
2

首先定义一个做你想做的事情的函数类型：

type Producer func([]byte) interface{}

做几个：

func FooProducer(raw []byte) interface{} {
    foo := new(Foo)
    ... // do something to foo
    return foo
}

func BarProducter(raw []byte) interface{} {
    bar := new(Bar)
    ... // do something to bar
    return bar
}

把它们贴在地图上：

likeThis := map[string]Producer{
    "foo": FooProducer,
    "bar": BarProducer,
}

然后只需执行以下操作之一：

myVal := likeThis[someString](raw)

但您可能想定义一些接口并使您的生产者更像：

type Producer func([]byte) MyAwesomeInterface

因为您可能想要对正在解码的那些事情做一些常见的事情。您可能还想处理错误字符串输入的情况，例如：

f, ok := likeThis[someString]
if !ok {
    // return, break, panic... something, just get the hell away from here.
}
myVal := f(raw)

检查类型的整个概念在 Go 中有点麻烦。与尝试使用类型系统进行反射体操相比，添加新类型通常更少工作。

于 2012-06-21T04:22:29.350 回答
2

jorelli 的回答非常好。我只是要展示几个选项。您的“真实示例”看起来基本上像命令调度，命令参数用 JSON 指定。从执行此操作的简单代码开始，

package main

import (
    "encoding/json"
    "fmt"
)

func inHandler(action string, data []byte) {
    arg := make(map[string]interface{})
    json.Unmarshal(data, &arg)
    switch action {
    case "say":
        fmt.Printf("You say, %q to %s\n", arg["msg"], arg["to"])
    case "exit":
        fmt.Println("Good bye")
    }
}

func main() {
    inHandler(`say`, []byte(`{"to":"Sonia","msg":"Please help me!"}`))
    inHandler(`exit`, []byte(`{}`))
}

通过在 switch 语句中添加 case 来注册新命令。是的，没想到你会喜欢。因此，添加您的地图和 init() 想法，

package main

import (
    "encoding/json"
    "fmt"
)

type jmap map[string]interface{}

var mActions = map[string]func(jmap){}

func init() {
    mActions["say"] = func(arg jmap) {
        fmt.Printf("You say, %q to %s\n", arg["msg"], arg["to"])
    }
}

func init() {
    mActions["exit"] = func(jmap) { fmt.Println("Good bye") }
}

func inHandler(action string, data []byte) {
    args := make(jmap)
    json.Unmarshal(data, &args)
    mActions[action](args)
}

func main() {
    inHandler(`say`, []byte(`{"to":"Sonia","msg":"Please help me!"}`))
    inHandler(`exit`, []byte(`{}`))
}

现在，如果您愿意，您可以将这些 init 函数中的每一个放在一个单独的源文件中，并且可以通过使用新的 init 函数创建一个新的源文件来注册新命令。

程序的其余部分通过一些假设进行了简化，即命令具有平面参数列表，JSON 将始终编码为对象。这允许您为每个命令省去单独的 Go 结构定义。inHandler 只是为所有命令创建相同类型的对象（映射），将其解组，然后将其传递给命令。如果您想处理更多任意 JSON，您可以解组为一个空接口，并且这些函数必须做一些额外的工作来挖掘参数。如果这工作量太大，并且您真的想直接解组到结构中，那么您将接近 jorelli 的解决方案，即让每个命令函数解组其自己的 JSON。

于 2012-06-22T22:40:22.067 回答