在Go中，如何在运行时根据结构的类型创建结构的新实例

Question

在Go中，如何在运行时从对象的类型创建对象的实例?我想你也需要先得到对象的实际type ?

我正在尝试做延迟实例化以节省内存。

Answer 1

为了做到这一点，你需要reflect。

package main
import (
    "fmt"
    "reflect"
)
func main() {
    // one way is to have a value of the type you want already
    a := 1
    // reflect.New works kind of like the built-in function new
    // We'll get a reflected pointer to a new int value
    intPtr := reflect.New(reflect.TypeOf(a))
    // Just to prove it
    b := intPtr.Elem().Interface().(int)
    // Prints 0
    fmt.Println(b)
    // We can also use reflect.New without having a value of the type
    var nilInt *int
    intType := reflect.TypeOf(nilInt).Elem()
    intPtr2 := reflect.New(intType)
    // Same as above
    c := intPtr2.Elem().Interface().(int)
    // Prints 0 again
    fmt.Println(c)
}

可以用struct类型而不是int类型做同样的事情。或者别的什么，真的。当涉及到映射类型和切片类型时，一定要知道new和make之间的区别。

Answer 2

由于reflect.New不会自动生成struct字段中使用的引用类型，因此可以使用以下代码递归地初始化这些字段类型(注意本例中的递归struct定义):

package main
import (
    "fmt"
    "reflect"
)
type Config struct {
    Name string
    Meta struct {
        Desc string
        Properties map[string]string
        Users []string
    }
}
func initializeStruct(t reflect.Type, v reflect.Value) {
  for i := 0; i < v.NumField(); i++ {
    f := v.Field(i)
    ft := t.Field(i)
    switch ft.Type.Kind() {
    case reflect.Map:
      f.Set(reflect.MakeMap(ft.Type))
    case reflect.Slice:
      f.Set(reflect.MakeSlice(ft.Type, 0, 0))
    case reflect.Chan:
      f.Set(reflect.MakeChan(ft.Type, 0))
    case reflect.Struct:
      initializeStruct(ft.Type, f)
    case reflect.Ptr:
      fv := reflect.New(ft.Type.Elem())
      initializeStruct(ft.Type.Elem(), fv.Elem())
      f.Set(fv)
    default:
    }
  }
}
func main() {
    t := reflect.TypeOf(Config{})
    v := reflect.New(t)
    initializeStruct(t, v.Elem())
    c := v.Interface().(*Config)
    c.Meta.Properties["color"] = "red" // map was already made!
    c.Meta.Users = append(c.Meta.Users, "srid") // so was the slice.
    fmt.Println(v.Interface())
}

Answer 3

您可以使用reflect.Zero()，它将返回结构类型的零值的表示。(类似于如果你做var foo StructType)这与reflect.New()不同，因为后者将动态分配结构并给你一个指针，类似于new(StructType)

Answer 4

这是一个基本的例子，就像Evan Shaw给出的，但有一个结构体:

package main
import (
    "fmt"
    "reflect"
)
func main() {
    type Product struct {
        Name  string
        Price string
    }
    var product Product
    productType := reflect.TypeOf(product)       // this type of this variable is reflect.Type
    productPointer := reflect.New(productType)   // this type of this variable is reflect.Value. 
    productValue := productPointer.Elem()        // this type of this variable is reflect.Value.
    productInterface := productValue.Interface() // this type of this variable is interface{}
    product2 := productInterface.(Product)       // this type of this variable is product
    product2.Name = "Toothbrush"
    product2.Price = "2.50"
    fmt.Println(product2.Name)
    fmt.Println(product2.Price)
}

每个newacct的响应，使用Reflect。0则为:

   var product Product
   productType := reflect.TypeOf(product)       // this type of this variable is reflect.Type
   productValue := reflect.Zero(productType)    // this type of this variable is reflect.Value
   productInterface := productValue.Interface() // this type of this variable is interface{}
   product2 := productInterface.(Product)       // the type of this variable is Product

这是一篇很棒的关于go中的反射基础的文章。

Answer 5

您不需要reflect，如果它们共享相同的接口，您可以使用工厂模式轻松完成此操作:

package main
import (
    "fmt"
)
// Interface common for all classes
type MainInterface interface {
    GetId() string
}
// First type of object
type FirstType struct {
    Id string
}
func (ft *FirstType) GetId() string {
    return ft.Id
}
// FirstType factory
func InitializeFirstType(id string) MainInterface {
    return &FirstType{Id: id}
}

// Second type of object
type SecondType struct {
    Id string
}
func (st *SecondType) GetId() string {
    return st.Id
}
// SecondType factory
func InitializeSecondType(id string) MainInterface {
    return &SecondType{Id: id}
}

func main() {
    // Map of strings to factories
    classes := map[string]func(string) MainInterface{
        "first": InitializeFirstType,
        "second": InitializeSecondType,
    }
    // Create a new FirstType object with value of 10 using the factory
    newObject := classes["first"]("10")
    // Show that we have the object correctly created
    fmt.Printf("%vn", newObject.GetId())

    // Create a new SecondType object with value of 20 using the factory
    newObject2 := classes["second"]("20")
    // Show that we have the object correctly created
    fmt.Printf("%vn", newObject2.GetId())
}