如何解析嵌套的JSON对象中的内部字段

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

How to parse an inner field in a nested JSON object

问题

{
"name": "Cain",
"parents": {
"mother" : "Eve",
"father" : "Adam"
}
}

现在我想将"name"和"mother"解析到这个结构体中：

struct {
Name String
Mother String json:"???"
}

我想用json:...结构标签指定JSON字段名，但是我不知道该使用什么作为标签，因为我对顶层对象不感兴趣。我在encoding/json包的文档中找不到关于此的任何信息，也没有在流行的博客文章JSON and Go中找到。我还测试了mother，parents/mother和parents.mother。

英文:

I have a JSON object similar to this one:

  1. {
  2.   "name": "Cain",
  3.   "parents": {
  4.     "mother" : "Eve",
  5.     "father" : "Adam"
  6.   }
  7. }

Now I want to parse "name" and "mother" into this struct:

  1. struct {
  2.   Name String
  3.   Mother String `json:"???"`
  4. }

I want to specify the JSON field name with the json:... struct tag, however I don't know what to use as tag, because it is not the top object I am interested in. I found nothing about this in the encoding/json package docs nor in the popular blog post JSON and Go. I also tested mother, parents/mother and parents.mother.

答案1

得分: 20

你可以使用结构体，只要你的输入数据不太动态。

http://play.golang.org/p/bUZ8l6WgvL

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"encoding/json"
  6. 	)
  8. type User struct {
  9. 	Name string
  10. 	Parents struct {
  11. 		Mother string
  12. 		Father string
  13. 	}
  14. }
  16. func main() {
  17. 	encoded := `{
  18. 	    "name": "Cain",
  19. 	    "parents": {
  20. 	        "mother": "Eve",
  21. 	        "father": "Adam"
  22. 	    }
  23. 	}`
  25. 	// 解码json对象
  26. 	u := &User{}
  27. 	err := json.Unmarshal([]byte(encoded), &u)
  28. 	if err != nil {
  29. 		panic(err)
  30. 	}
  32. 	// 打印出母亲和父亲
  33. 	fmt.Printf("Mother: %s\n", u.Parents.Mother)
  34. 	fmt.Printf("Father: %s\n", u.Parents.Father)
  35. }
英文:

You could use structs so long as your incoming data isn't too dynamic.

http://play.golang.org/p/bUZ8l6WgvL

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"encoding/json"
  6. 	)
  8. type User struct {
  9. 	Name string
  10. 	Parents struct {
  11. 		Mother string
  12. 		Father string
  13. 	}
  14. }
  16. func main() {
  17. 	encoded := `{
  18. 	    "name": "Cain",
  19. 	    "parents": {
  20. 	        "mother": "Eve",
  21. 	        "father": "Adam"
  22. 	    }
  23. 	}`
  25. 	// Decode the json object
  26. 	u := &User{}
  27. 	err := json.Unmarshal([]byte(encoded), &u)
  28. 	if err != nil {
  29. 		panic(err)
  30. 	}
  32. 	// Print out mother and father
  33. 	fmt.Printf("Mother: %s\n", u.Parents.Mother)
  34. 	fmt.Printf("Father: %s\n", u.Parents.Father)
  35. }

答案2

得分: 19

不幸的是，与encoding/xml不同，json包没有提供访问嵌套值的方法。您可以创建一个单独的Parents结构体或将类型分配为map[string]string。例如：

  1. type Person struct {
  2.     Name string
  3.     Parents map[string]string
  4. }

然后，您可以提供一个获取母亲的方法：

  1. func (p *Person) Mother() string {
  2.     return p.Parents["mother"]
  3. }

这可能与您当前的代码库有关，如果将Mother字段重构为方法调用不在计划中，那么您可能需要创建一个单独的方法来进行解码并符合您当前的结构体。

英文:

Unfortunately, unlike encoding/xml, the json package doesn't provide a way to access nested values. You'll want to either create a separate Parents struct or assign the type to be map[string]string. For example:

  1. type Person struct {
  2.     Name string
  3.     Parents map[string]string
  4. }

You could then provide a getter for mother as so:

  1. func (p *Person) Mother() string {
  2.     return p.Parents["mother"]
  3. }

This may or may not play into your current codebase and if refactoring the Mother field to a method call is not on the menu, then you may want to create a separate method for decoding and conforming to your current struct.

答案3

得分: 6

这是我在Go Playground中快速编写的一些代码

http://play.golang.org/p/PiWwpUbBqt

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"encoding/json"
  6. 	)
  8. func main() {
  9. 	encoded := `{
  10. 	    "name": "Cain",
  11. 	    "parents": {
  12. 	        "mother": "Eve",
  13.             "father": "Adam"
  14. 	    }
  15. 	}`
  17. 	// 解码json对象
  18. 	var j map[string]interface{}
  19. 	err := json.Unmarshal([]byte(encoded), &j)
  20. 	if err != nil {
  21. 		panic(err)
  22. 	}
  24. 	// 提取出parents对象
  25. 	parents := j["parents"].(map[string]interface{})
  27. 	// 打印出母亲和父亲
  28. 	fmt.Printf("Mother: %s\n", parents["mother"].(string))
  29. 	fmt.Printf("Father: %s\n", parents["father"].(string))
  30. }

可能有更好的方法。我期待看到其他答案。 如何解析嵌套的JSON对象中的内部字段

英文:

Here's some code I baked up real quick in the Go Playground

http://play.golang.org/p/PiWwpUbBqt

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"encoding/json"
  6. 	)
  8. func main() {
  9. 	encoded := `{
  10. 	    "name": "Cain",
  11. 	    "parents": {
  12. 	        "mother": "Eve"
  13.             "father": "Adam"
  14. 	    }
  15. 	}`
  17. 	// Decode the json object
  18. 	var j map[string]interface{}
  19. 	err := json.Unmarshal([]byte(encoded), &j)
  20. 	if err != nil {
  21. 		panic(err)
  22. 	}
  24. 	// pull out the parents object
  25. 	parents := j["parents"].(map[string]interface{})
  27. 	// Print out mother and father
  28. 	fmt.Printf("Mother: %s\n", parents["mother"].(string))
  29. 	fmt.Printf("Father: %s\n", parents["father"].(string))
  30. }

There might be a better way. I'm looking forward to seeing the other answers. 如何解析嵌套的JSON对象中的内部字段

答案4

得分: 5

最近，gjson 支持选择嵌套的 JSON 属性。

  1. name := gjson.Get(json, "name")
  2. mother := gjson.Get(json, "parents.mother")
英文:

More recently, gjson supports selection of nested JSON properties.

  1. name := gjson.Get(json, "name")
  2. mother := gjson.Get(json, "parents.mother")

答案5

得分: 2

如何使用上面建议的中间结构体进行解析，然后将相关的值放入您的“真实”结构体中？

  1. import (
  2.     "fmt"
  3.     "encoding/json"
  4. )
  6. type MyObject struct{
  7.   Name string
  8.   Mother string
  9. }
  11. type MyParseObj struct{
  12.    Name string
  13.    Parents struct {
  14.          Mother string
  15.          Father string
  16.    } 
  17. }
  20. func main() {
  21.     encoded := `{
  22.          "name": "Cain",
  23.          "parents": {
  24.              "mother": "Eve",
  25.              "father": "Adam"
  26.          }
  27.     }`
  29.     pj := &MyParseObj{}
  30.     if err := json.Unmarshal([]byte(encoded), pj); err != nil {
  31.         return
  32.     }
  33.     final := &MyObject{Name: pj.Name, Mother: pj.Parents.Mother}
  34.     fmt.Println(final)  
  35. }
英文:

How about using an intermediary struct as the one suggested above for parsing, and then putting the relevant values in your "real" struct?

  1. import (
  2.     "fmt"
  3.     "encoding/json"
  4.     )
  6. type MyObject struct{
  7.   Name string
  8.   Mother string
  9. }
  11. type MyParseObj struct{
  12.    Name string
  13.    Parents struct {
  14.          Mother string
  15.          Father string
  16.    } 
  17. }
  20. func main() {
  21.     encoded := `{
  22.          "name": "Cain",
  23.          "parents": {
  24.              "mother": "Eve",
  25.              "father": "Adam"
  26.          }
  27.     }`
  29.     pj := &MyParseObj{}
  30.     if err := json.Unmarshal([]byte(encoded), pj); err != nil {
  31.         return
  32.     }
  33.     final := &MyObject{Name: pj.Name, Mother: pj.Parents.Mother}
  34.     fmt.Println(final)  
  35. }

huangapple
  • 本文由 发表于 2012年11月28日 05:36:38
  • 转载请务必保留本文链接：https://go.coder-hub.com/13593519.html
  • go
  • json
匿名

发表评论

匿名网友

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

确定