Go语言中基于字符串动态创建类型实例的策略

package main  import (     "encoding/JSon"     "fmt" )  // ActionHandler 定义了所有动作必须实现的行为：执行和创建新实例 type ActionHandler interface {     Exec()     New() ActionHandler }  // mactions 是一个全局映射，用于存储动作的零值实例，键为动作名称 var mActions = make(map[string]ActionHandler)  // aExit 是一个具体的动作类型，表示退出程序 type aExit struct{}  // Exec 实现了 aExit 的执行逻辑 func (s *aExit) Exec() { fmt.Println("Good bye") }  // New 实现了 aExit 的新实例创建逻辑 func (s *aExit) New() ActionHandler { return new(aExit) }  // init 函数用于注册 aExit 类型到 mActions func init() {     var a *aExit // 使用零值指针注册     mActions[`exit`] = a }  // aSay 是另一个具体的动作类型，表示说一句话 type aSay struct {     To  string     Msg string }  // Exec 实现了 aSay 的执行逻辑 func (s *aSay) Exec() { fmt.Println(`You say, "` + s.Msg + `" to ` + s.To) }  // New 实现了 aSay 的新实例创建逻辑 func (s *aSay) New() ActionHandler { return new(aSay) }  // init 函数用于注册 aSay 类型到 mActions func init() {     var a *aSay // 使用零值指针注册     mActions[`say`] = a }  // inHandler 模拟一个输入处理器，根据动作名称和json数据执行操作 func inHandler(action string, data []byte) {     // 从映射中获取零值实例，并调用其New()方法创建新的具体实例     actionInstance := mActions[action].New()     // 如果需要，可以将JSON数据反序列化到新实例中     json.Unmarshal(data, &actionInstance)     actionInstance.Exec() }  func main() {     inHandler(`say`, []byte(`{"To":"Sonia","Msg":"Please help me!"}`))     inHandler(`exit`, []byte(`{}`)) }

Copilot

Copilot是由微软公司开发的一款AI生产力工具，旨在通过先进的人工智能技术，帮助用户快速完成各种任务，提升工作效率。

63

查看详情

package main  import (     "fmt"     "reflect" )  type ta struct {     A int } type tb struct {     B float64 } type tc struct {     C string }  // mTypes 是一个全局映射，用于存储类型名称与 reflect.Type 的关联 var mTypes map[string]reflect.Type = make(map[string]reflect.Type)  // init 函数用于注册各种类型到 mTypes func init() {     var a ta     mTypes[`ta`] = reflect.TypeOf(a)     var b tb     mTypes[`tb`] = reflect.TypeOf(b)     var c tc     mTypes[`tc`] = reflect.TypeOf(c) // 注意：这里原示例是ta，已更正为tc }  // MagicVarFunc 根据字符串名称动态创建对应类型的零值实例 func MagicVarFunc(typeName string) interface{} {     typ, ok := mTypes[typeName]     if !ok {         fmt.Printf("Error: Type '%s' not registered.n", typeName)         return nil     }     // reflect.Zero(typ) 返回该类型的零值，然后通过 .Interface() 转换为 interface{}     return reflect.Zero(typ).Interface() }  func main() {     // 动态创建 ta 类型的零值实例     tA := "ta"     vA := MagicVarFunc(tA)     if vA != nil {         fmt.Printf("Created type: %T, value: %+vn", vA, vA)         // 需要进行类型断言才能访问具体字段         if instance, ok := vA.(ta); ok {             instance.A = 10             fmt.Printf("Modified instance: %+vn", instance)         }     }      // 动态创建 tb 类型的零值实例     tB := "tb"     vB := MagicVarFunc(tB)     if vB != nil {         fmt.Printf("Created type: %T, value: %+vn", vB, vB)         // 需要进行类型断言才能访问具体字段         if instance, ok := vB.(tb); ok {             instance.B = 8.3             fmt.Printf("Modified instance: %+vn", instance)         }     }      // 动态创建 tc 类型的零值实例     tC := "tc"     vC := MagicVarFunc(tC)     if vC != nil {         fmt.Printf("Created type: %T, value: %+vn", vC, vC)         // 需要进行类型断言才能访问具体字段         if instance, ok := vC.(tc); ok {             instance.C = "hello"             fmt.Printf("Modified instance: %+vn", instance)         }     }      // 尝试创建未注册的类型     tUnknown := "tUnknown"     vUnknown := MagicVarFunc(tUnknown)     fmt.Printf("Created type: %T, value: %+vn", vUnknown, vUnknown) }

func MagicVarFuncPtr(typeName string) interface{} {     typ, ok := mTypes[typeName]     if !ok {         fmt.Printf("Error: Type '%s' not registered.n", typeName)         return nil     }     // reflect.New(typ) 返回一个 Value 类型，代表指向新分配的零值的指针     // 调用 .Interface() 获取 interface{} 类型的指针     return reflect.New(typ).Interface() }  func mainPtr() {     tB := "tb"     vB_ptr := MagicVarFuncPtr(tB) // 返回 *tb 类型的 interface{}     if vB_ptr != nil {         fmt.Printf("Created pointer type: %T, value: %+vn", vB_ptr, vB_ptr)         // 需要进行类型断言，并解引用才能访问具体字段         if instancePtr, ok := vB_ptr.(*tb); ok {             instancePtr.B = 8.3             fmt.Printf("Modified instance via pointer: %+vn", *instancePtr)         }     } }