将JSON对象解组成具有键和值的结构体切片。

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

Unmarshal JSON object into slice of structs with key and value

问题

我正在学习GO，并且被以下问题困扰：
我收到一个JSON字符串，我想在GO中进行解组。
JSON的格式如下：

  1. {
  2.   "MAINKEY": {
  3.     "key1": 1,
  4.     "key2": [1, 2]
  5.   }
  6. }

我只对MAINKEY的内容感兴趣，但是与这个问题类似，我不知道键的名称，这些键应该反映在映射的名称上。

最终，我想要以下对象：

  1. type Result struct {
  2. 	Key   string
  3. 	Value []int
  4. }
  6. expectedResult := []Result{
  7. 	{"key1", []int{1}},
  8. 	{"key2", []int{1, 2}},
  9. }
  10. fmt.Printf("WANT: %+v\n", expectedResult)
  11. //> WANT: [{Key:key1 Value:[1]} {Key:key2 Value:[1 2]}]

如果可能的话，我不想先解组为map[string]interface{}（但如果没有其他方法，那也可以）。

到目前为止，完整的代码如下：

  1. package main
  3. import (
  4. 	"encoding/json"
  5. 	"fmt"
  6. )
  8. // does produce expected result at the moment...
  9. type Result struct {
  10. 	Key   string
  11. 	Value []int
  12. }
  14. type Outer struct {
  15. 	Key Result `json:"MAINKEY"`
  16. }
  18. func main() {
  20. 	input := `{"MAINKEY": {"key1": 1, "key2": [1, 2]}}`
  22. 	var cont Outer
  23. 	json.Unmarshal([]byte(input), &cont)
  24. 	fmt.Printf("GOT: %+v\n", cont)
  26. 	expectedResult := []Result{
  27. 		{"key1", []int{1}},
  28. 		{"key2", []int{1, 2}},
  29. 	}
  30. 	fmt.Printf("WANT: %+v\n", expectedResult)
  31. }
英文:

I am still learning GO and I am stumped by the following problem:
I receive a JSON string that I want to unmarshal in GO.
The JSON looks like this

  1. {
  2.   "MAINKEY": {
  3.     "key1": 1,
  4.     "key2": [1, 2]
  5.   }
  6. }

I am only interested in the contents of the MAINKEY, but similar to this question, I do not know the names of the keys, which should reflect the names of the map.

In the end, I want to have the following object:

  1. type Result struct {
  2. 	Key   string
  3. 	Value []int
  4. }
  6. expectedResult := []Result{
  7. 	{"key1", []int{1}},
  8. 	{"key2", []int{1, 2}},
  9. }
  10. fmt.Printf("WANT: %+v\n", expectedResult)
  11. //> WANT: [{Key:key1 Value:[1]} {Key:key2 Value:[1 2]}]

If possible, I don't want to unmarshal into a map[string]interface{} first (but if there is no other way, that would be ok too).

Full code so far is:

  1. package main
  3. import (
  4. 	"encoding/json"
  5. 	"fmt"
  6. )
  8. // does produce expected result at the moment...
  9. type Result struct {
  10. 	Key   string
  11. 	Value []int
  12. }
  14. type Outer struct {
  15. 	Key Result `json:"MAINKEY"`
  16. }
  18. func main() {
  20. 	input := `{"MAINKEY": {"key1": 1, "key2": [1, 2]}}`
  22. 	var cont Outer
  23. 	json.Unmarshal([]byte(input), &cont)
  24. 	fmt.Printf("GOT: %+v\n", cont)
  26. 	expectedResult := []Result{
  27. 		{"key1", []int{1}},
  28. 		{"key2", []int{1, 2}},
  29. 	}
  30. 	fmt.Printf("WANT: %+v\n", expectedResult)
  31. }

答案1

得分: 3

你可以使用自定义的解组器（unmarshaler）来处理 map 类型：

  1. type ResultList []Result
  3. func (ls *ResultList) UnmarshalJSON(data []byte) error {
  4. 	var obj map[string]json.RawMessage
  5. 	if err := json.Unmarshal(data, &obj); err != nil {
  6. 		return err
  7. 	}
  9. 	for key, raw := range obj {
  10. 		r := Result{Key: key}
  11. 		if raw[0] == '[' { // 假设是 int 数组
  12. 			if err := json.Unmarshal(raw, &r.Value); err != nil {
  13. 				return err
  14. 			}
  15. 		} else { // 假设是单个 int
  16. 			var i int
  17. 			if err := json.Unmarshal(raw, &i); err != nil {
  18. 				return err
  19. 			}
  20. 			r.Value = append(r.Value, i)
  21. 		}
  22. 		*ls = append(*ls, r)
  23. 	}
  24. 	return nil
  25. }

如果你需要保留顺序，你可以对输入进行分词：

  1. type ResultList []Result
  3. func (ls *ResultList) UnmarshalJSON(data []byte) error {
  4. 	d := json.NewDecoder(bytes.NewReader(data))
  5. 	i := -1
  6. 	for {
  7. 		t, err := d.Token()
  8. 		if err == io.EOF {
  9. 			break
  10. 		}
  11. 		if err != nil {
  12. 			return err
  13. 		}
  15. 		switch v := t.(type) {
  16. 		case string:
  17. 			*ls = append(*ls, Result{Key: v})
  18. 			i += 1
  19. 		case float64:
  20. 			(*ls)[i].Value = append((*ls)[i].Value, int(v))
  21. 		}
  22. 	}
  23. 	return nil
  24. }
英文:

You can use a custom unmarshaler with a map:

  1. type ResultList []Result
  3. func (ls *ResultList) UnmarshalJSON(data []byte) error {
  4. 	var obj map[string]json.RawMessage
  5. 	if err := json.Unmarshal(data, &obj); err != nil {
  6. 		return err
  7. 	}
  9. 	for key, raw := range obj {
  10. 		r := Result{Key: key}
  11. 		if raw[0] == '[' { // assume array of ints
  12. 			if err := json.Unmarshal(raw, &r.Value); err != nil {
  13. 				return err
  14. 			}
  15. 		} else { // assume single int
  16. 			var i int
  17. 			if err := json.Unmarshal(raw, &i); err != nil {
  18. 				return err
  19. 			}
  20. 			r.Value = append(r.Value, i)
  21. 		}
  22. 		*ls = append(*ls, r)
  23. 	}
  24. 	return nil
  25. }

https://go.dev/play/p/Epd6cLwyWUm

Or, if you need to retain the order, you can tokenize the input:

  1. type ResultList []Result
  3. func (ls *ResultList) UnmarshalJSON(data []byte) error {
  4. 	d := json.NewDecoder(bytes.NewReader(data))
  5. 	i := -1
  6. 	for {
  7. 		t, err := d.Token()
  8. 		if err == io.EOF {
  9. 			break
  10. 		}
  11. 		if err != nil {
  12. 			return err
  13. 		}
  15. 		switch v := t.(type) {
  16. 		case string:
  17. 			*ls = append(*ls, Result{Key: v})
  18. 			i += 1
  19. 		case float64:
  20. 			(*ls)[i].Value = append((*ls)[i].Value, int(v))
  21. 		}
  22. 	}
  23. 	return nil
  24. }

https://go.dev/play/p/nABjw5IHZ7R

huangapple
  • 本文由 发表于 2022年11月11日 22:20:21
  • 转载请务必保留本文链接：https://go.coder-hub.com/74403870.html
  • go
  • json
  • unmarshalling
匿名

发表评论

匿名网友

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

确定