[英]How to unmarshall an array of different types correctly?
As long as I have key-value pairs unmarshalling is pretty straight forward but how would I unmarshall an array of different types in different order? 只要我有键值对,解组很简单,但是如何以不同的顺序解组不同类型的数组呢? The single elements are well defined and known but the order is not.
单个元素定义明确且已知,但顺序不是。
I can not come up with a beautiful solution. 我无法想出一个漂亮的解决方案。
Would I try and error over all elements? 我会尝试对所有元素进行错误吗? Is there some kind of union type that could do that for me?
是否有某种联合类型可以为我做到这一点?
package main
import (
"encoding/json"
"fmt"
)
var my_json string = `{
"an_array":[
"with_a string",
{
"and":"some_more",
"different":["nested", "types"]
}
]
}`
type MyInner struct {
And string
Different []string
}
type MyJSON struct {
An_array []json.RawMessage
}
func main() {
var my_json_test MyJSON
e := json.Unmarshal([]byte(my_json), &my_json_test)
if e != nil {
fmt.Println(e)
} else {
for index, value := range my_json_test.An_array {
fmt.Println("index: ", index)
fmt.Println("value: ", string(value))
}
var my_inner MyInner
err := json.Unmarshal(my_json_test.An_array[1], &my_inner)
if err != nil {
fmt.Println(err)
} else {
fmt.Println("inner structure: ", my_inner)
}
}
}
Go official blog has a nice article about encoding/json
: JSON and GO . Go官方博客有一篇关于
encoding/json
的好文章: JSON和GO 。 It's possible to "Decode arbitrary data" into an interface{} and use type assertion to determine the type dynamically. 可以将“解码任意数据”解码为接口{}并使用类型断言来动态确定类型。
Your code can be probably modified to this: 你的代码可能修改为:
package main
import (
"encoding/json"
"fmt"
)
var my_json string = `{
"an_array":[
"with_a string",
{
"and":"some_more",
"different":["nested", "types"]
}
]
}`
func WTHisThisJSON(f interface{}) {
switch vf := f.(type) {
case map[string]interface{}:
fmt.Println("is a map:")
for k, v := range vf {
switch vv := v.(type) {
case string:
fmt.Printf("%v: is string - %q\n", k, vv)
case int:
fmt.Printf("%v: is int - %q\n", k, vv)
default:
fmt.Printf("%v: ", k)
WTHisThisJSON(v)
}
}
case []interface{}:
fmt.Println("is an array:")
for k, v := range vf {
switch vv := v.(type) {
case string:
fmt.Printf("%v: is string - %q\n", k, vv)
case int:
fmt.Printf("%v: is int - %q\n", k, vv)
default:
fmt.Printf("%v: ", k)
WTHisThisJSON(v)
}
}
}
}
func main() {
fmt.Println("JSON:\n", my_json, "\n")
var f interface{}
err := json.Unmarshal([]byte(my_json), &f)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("JSON: ")
WTHisThisJSON(f)
}
}
It gives output as follows: 它给出如下输出:
JSON:
{
"an_array":[
"with_a string",
{
"and":"some_more",
"different":["nested", "types"]
}
]
}
JSON: is a map:
an_array: is an array:
0: is string - "with_a string"
1: is a map:
and: is string - "some_more"
different: is an array:
0: is string - "nested"
1: is string - "types"
It's not complete yet, but shows how it's gonna work. 它尚未完成,但展示了它将如何运作。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.