如何正确地反序列化不同类型的数组？

huangapple
go评论139阅读模式
英文:

How to unmarshall an array of different types correctly?

问题

只要我有键值对，解组就很简单，但是如何解组一个不同类型的数组并且顺序不同呢？单个元素是明确定义和已知的，但是顺序不确定。

我想不出一个优雅的解决方案。

我应该尝试所有元素吗？
是否有一种可以为我做到这一点的联合类型？

playground版本

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. var my_json string = `{
  9.     "an_array":[
  10.         "with_a string",
  11.         {
  12.             "and":"some_more",
  13.             "different":["nested", "types"]
  14.         }
  15.     ]
  16. }`
  18. type MyInner struct {
  19.     And     string
  20.     Different   []string
  21. }
  23. type MyJSON struct {
  24.     An_array []json.RawMessage
  25. }
  27. func main() {
  28.     var my_json_test MyJSON
  30.     e := json.Unmarshal([]byte(my_json), &my_json_test)
  31.     if e != nil {
  32.         fmt.Println(e)
  33.     } else {
  34.         for index, value := range my_json_test.An_array {
  35.             fmt.Println("index: ", index)
  36.             fmt.Println("value: ", string(value))
  37.         }
  38.         var my_inner MyInner
  39.         err := json.Unmarshal(my_json_test.An_array[1], &my_inner)
  40.         if err != nil {
  41.             fmt.Println(err)
  42.         } else {
  43.             fmt.Println("inner structure: ", my_inner)
  44.         }
  45.     }
  46. }
英文:

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?

playground version

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. var my_json string = `{
  9.     "an_array":[
  10.         "with_a string",
  11.         {
  12.             "and":"some_more",
  13.             "different":["nested", "types"]
  14.         }
  15.     ]
  16. }`
  18. type MyInner struct {
  19.     And     string
  20.     Different   []string
  21. }
  23. type MyJSON struct {
  24.     An_array []json.RawMessage
  25. }
  27. func main() {
  28.     var my_json_test MyJSON
  30.     e := json.Unmarshal([]byte(my_json), &my_json_test)
  31.     if e != nil {
  32.         fmt.Println(e)
  33.     } else {
  34.         for index, value := range my_json_test.An_array {
  35.             fmt.Println("index: ", index)
  36.             fmt.Println("value: ", string(value))
  37.         }
  38.         var my_inner MyInner
  39.         err := json.Unmarshal(my_json_test.An_array[1], &my_inner)
  40.         if err != nil {
  41.             fmt.Println(err)
  42.         } else {
  43.             fmt.Println("inner structure: ", my_inner)
  44.         }
  45.     }
  46. }

答案1

得分: 22

Go官方博客有一篇关于encoding/json的好文章：JSON和GO。可以将任意数据解码为interface{}，并使用类型断言来动态确定类型。

你的代码可以修改为以下形式：

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. var my_json string = `{
  9.     "an_array":[
  10.     "with_a string",
  11.     {
  12.         "and":"some_more",
  13.         "different":["nested", "types"]
  14.     }
  15.     ]
  16. }`
  18. func WTHisThisJSON(f interface{}) {
  19.     switch vf := f.(type) {
  20.     case map[string]interface{}:
  21.         fmt.Println("是一个map：")
  22.         for k, v := range vf {
  23.             switch vv := v.(type) {
  24.             case string:
  25.                 fmt.Printf("%v: 是字符串 - %q\n", k, vv)
  26.             case int:
  27.                 fmt.Printf("%v: 是整数 - %q\n", k, vv)
  28.             default:
  29.                 fmt.Printf("%v: ", k)
  30.                 WTHisThisJSON(v)
  31.             }
  33.         }
  34.     case []interface{}:
  35.         fmt.Println("是一个数组：")
  36.         for k, v := range vf {
  37.             switch vv := v.(type) {
  38.             case string:
  39.                 fmt.Printf("%v: 是字符串 - %q\n", k, vv)
  40.             case int:
  41.                 fmt.Printf("%v: 是整数 - %q\n", k, vv)
  42.             default:
  43.                 fmt.Printf("%v: ", k)
  44.                 WTHisThisJSON(v)
  45.             }
  47.         }
  48.     }
  49. }
  51. func main() {
  53.     fmt.Println("JSON:\n", my_json, "\n")
  55.     var f interface{}
  56.     err := json.Unmarshal([]byte(my_json), &f)
  57.     if err != nil {
  58.         fmt.Println(err)
  59.     } else {
  60.         fmt.Printf("JSON: ")
  61.         WTHisThisJSON(f)
  62.     }
  63. }

它的输出如下：

  1. JSON:
  2.  {
  3.     "an_array":[
  4.     "with_a string",
  5.     {
  6.         "and":"some_more",
  7.         "different":["nested", "types"]
  8.     }
  9.     ]
  10. } 
  12. JSON: 是一个map：
  13. an_array: 是一个数组：
  14. 0: 是字符串 - "with_a string"
  15. 1: 是一个map：
  16. and: 是字符串 - "some_more"
  17. different: 是一个数组：
  18. 0: 是字符串 - "nested"
  19. 1: 是字符串 - "types"

它还不完整，但展示了它将如何工作。

英文:

Go official blog has a nice article about encoding/json: JSON and 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:

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. var my_json string = `{
  9.     "an_array":[
  10.     "with_a string",
  11.     {
  12.         "and":"some_more",
  13.         "different":["nested", "types"]
  14.     }
  15.     ]
  16. }`
  18. func WTHisThisJSON(f interface{}) {
  19.     switch vf := f.(type) {
  20.     case map[string]interface{}:
  21.         fmt.Println("is a map:")
  22.         for k, v := range vf {
  23.             switch vv := v.(type) {
  24.             case string:
  25.                 fmt.Printf("%v: is string - %q\n", k, vv)
  26.             case int:
  27.                 fmt.Printf("%v: is int - %q\n", k, vv)
  28.             default:
  29.                 fmt.Printf("%v: ", k)
  30.                 WTHisThisJSON(v)
  31.             }
  33.         }
  34.     case []interface{}:
  35.         fmt.Println("is an array:")
  36.         for k, v := range vf {
  37.             switch vv := v.(type) {
  38.             case string:
  39.                 fmt.Printf("%v: is string - %q\n", k, vv)
  40.             case int:
  41.                 fmt.Printf("%v: is int - %q\n", k, vv)
  42.             default:
  43.                 fmt.Printf("%v: ", k)
  44.                 WTHisThisJSON(v)
  45.             }
  47.         }
  48.     }
  49. }
  51. func main() {
  53.     fmt.Println("JSON:\n", my_json, "\n")
  55.     var f interface{}
  56.     err := json.Unmarshal([]byte(my_json), &f)
  57.     if err != nil {
  58.         fmt.Println(err)
  59.     } else {
  60.         fmt.Printf("JSON: ")
  61.         WTHisThisJSON(f)
  62.     }
  63. }

It gives output as follows:

  1. JSON:
  2.  {
  3.     "an_array":[
  4.     "with_a string",
  5.     {
  6.         "and":"some_more",
  7.         "different":["nested", "types"]
  8.     }
  9.     ]
  10. } 
  12. JSON: is a map:
  13. an_array: is an array:
  14. 0: is string - "with_a string"
  15. 1: is a map:
  16. and: is string - "some_more"
  17. different: is an array:
  18. 0: is string - "nested"
  19. 1: is string - "types"

It's not complete yet, but shows how it's gonna work.

huangapple
  • 本文由 发表于 2012年11月14日 00:02:46
  • 转载请务必保留本文链接：https://go.coder-hub.com/13364181.html
  • go
  • json
  • unmarshalling
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定