How can I turn map[string]interface{} to different type of struct?

Question

I'm calling an API which will return Json objects like this:

{
  name: "XXX"
  type: "TYPE_1"
  shared_fields: {...}
  type_1_fields: {...}
  ..
  type_2_fields: {...}
}

Based on different types, this object will have different kinds of fields, but these fields are certain for different types. So, I unmarshal the Json string to map[string]interface{} to fetch the the different type but how can I turn these map[string]interface{} to a certain struct?

  var f map[string]interface{}
  err := json.Unmarshal(b, &f)
  type := f["type"]
  switch type {
    case "type_1":
      //initialize struct of type_1
    case "type_2":
      //initialize struct of type_2
  }

Answer 1

For this sort of two-step json decoding you will probably want to check out json.RawMessage. It allows you to defer processing of parts of your json response. The example in the docs shows how.

Answer 2

One way to do it would be to have a constructor function (one that starts with New…) that takes a map as input parameter.

A second way, much slower in my opinion, would be to redo the unmarshalling to the right struct type.

Answer 3

If the types are different enough and you want to be lazy you can just try to decode it in each format:

  f1 := type1{}
  err := json.Unmarshal(b, &f1)
  if err == nil {
      return f1
  }
  f2 := type2{}
  err := json.Unmarshal(b, &f2)
  if err == nil {
     return f2
  }
  ...

If the objects are similar or you want to be less lazy, you could just decode the type and then do something:

  type BasicInfo struct {
     Type string `json:"type"`
  }

  f := BasicInfo{}
  err := json.Unmarshal(b, &f)
  switch f.Type {
    case "type_1":
      //initialize struct of type_1
    case "type_2":
      //initialize struct of type_2
  }