如何在Golang中正确地解析没有键的JSON数组？

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

How to Unmarshall key-less JSON array in Golang correctly?

问题

我有一个看起来像这样的JSON数据：

[
{
"globalTradeID": 64201000,
"tradeID": 549285,
"date": "2016-11-11 23:51:58",
"type": "buy",
"rate": "10.33999779",
"amount": "0.02176472",
"total": "0.22504715"
},
{
"globalTradeID": 64200631,
"tradeID": 549284,
"date": "2016-11-11 23:48:39",
"type": "buy",
"rate": "10.33999822",
"amount": "0.18211700",
"total": "1.88308945"
}...
]

我尝试通过定义一个类型来解析这个JSON：

type TradeHistoryResponse []TradeHistoryInfo

type TradeHistoryInfo struct {
GlobalTradeID int64 json:"globalTradeID"
TradeID int64 json:"tradeID"
Date string json:"date"
Type string json:"type"
Rate float64 json:"rate,string"
Amount float64 json:"amount,string"
Total float64 json:"total,string"
}

然后按如下方式提取JSON数据：

//读取响应
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("[Poloniex] (doRequest) Failed to parse response for query to %s! (%s)", reqURL, err.Error())
}

//将JSON转换为结构体
var THR TradeHistoryResponse
err = json.Unmarshal(body, &THR)
if err != nil {
return nil, fmt.Errorf("[Poloniex] (doRequest) Failed to convert response into JSON for query to %s! (%s)", reqURL, err.Error())
}

我得到以下错误：

(json: cannot unmarshal object into Go value of type poloniex.TradeHistoryResponse)

我最好的猜测是Unmarshal无法工作的原因是数组没有键值？

希望能对如何解决这个问题有一些澄清。

英文:

I have JSON data which looks like this:

  1. [
  2.   {
  3.     "globalTradeID": 64201000,
  4.     "tradeID": 549285,
  5.     "date": "2016-11-11 23:51:58",
  6.     "type": "buy",
  7.     "rate": "10.33999779",
  8.     "amount": "0.02176472",
  9.     "total": "0.22504715"
  10.   },
  11.   {
  12.     "globalTradeID": 64200631,
  13.     "tradeID": 549284,
  14.     "date": "2016-11-11 23:48:39",
  15.     "type": "buy",
  16.     "rate": "10.33999822",
  17.     "amount": "0.18211700",
  18.     "total": "1.88308945"
  19.   }...
  20. ]

I've tried to unmarshall this JSON by defining a type:

  1. type TradeHistoryResponse 	[]TradeHistoryInfo
  3. type TradeHistoryInfo struct {
  4. 	GlobalTradeID 	int64 	`json:"globalTradeID"`
  5. 	TradeID 		int64 	`json:"tradeID"`
  6. 	Date 			string 	`json:"date"`
  7. 	Type 			string 	`json:"type"`
  8. 	Rate 			float64 `json:"rate,string"`
  9. 	Amount 			float64 `json:"amount,string"`
  10. 	Total 			float64 `json:"total,string"`
  11. }

And then pulling the JSON data as so:

  1. 	//Read response
  2. 	body, err := ioutil.ReadAll(resp.Body)
  3. 	if err != nil {
  4. 		return nil, fmt.Errorf("[Poloniex] (doRequest) Failed to parse response for query to %s! (%s)", reqURL, err.Error())
  5. 	} 
  7. 	//Convert JSON to struct
  8.     
  9. 	var THR TradeHistoryResponse
  10.     err = json.Unmarshal(body, &THR)
  11. 	if err != nil {
  12. 		return nil, fmt.Errorf("[Poloniex] (doRequest) Failed to convert response into JSON for query to %s! (%s)", reqURL, err.Error())
  13. 	}

I get the following error:

  1. (json: cannot unmarshal object into Go value of type poloniex.TradeHistoryResponse)

My best guess why the Unmarshall doesn't work is because the array is key-less?

Would love to have some clarification on the matter on how I might best get this working.

答案1

得分: 1

我没有认为在 JSON 中解组装一个数组是可以的，但是对于 encoding/json 的属性来说是可以的。以下是示例代码：

  1. package main
  3. import (
  4. 	"encoding/json"
  5. 	"fmt"
  6. 	"log"
  7. )
  9. var mjs string = "[" +
  10. 	"{\"globalTradeID\": 64201000," +
  11. 	"\"tradeID\": 549285," +
  12. 	"\"date\": \"2016-11-11 23:51:58\"," +
  13. 	"\"type\": \"buy\"," +
  14. 	"\"rate\": \"10.33999779\"," +
  15. 	"\"amount\": \"0.02176472\"," +
  16. 	"\"total\": \"0.22504715\"" +
  17. 	"}," +
  18. 	"{" +
  19. 	"\"globalTradeID\": 64200631," +
  20. 	"\"tradeID\": 549284," +
  21. 	"\"date\": \"2016-11-11 23:48:39\"," +
  22. 	"\"type\": \"buy\"," +
  23. 	"\"rate\": \"10.33999822\"," +
  24. 	"\"amount\": \"0.18211700\"," +
  25. 	"\"total\": \"1.88308945\"" +
  26. 	"}" +
  27. 	"]"
  29. type TradeHistoryResponse []TradeHistoryInfo
  31. type TradeHistoryInfo struct {
  32. 	GlobalTradeID int64   `json:"globalTradeID"`
  33. 	TradeID       int64   `json:"tradeID"`
  34. 	Date          string  `json:"date"`
  35. 	Type          string  `json:"type"`
  36. 	Rate          float64 `json:"rate,string"`
  37. 	Amount        float64 `json:"amount,string"`
  38. 	Total         float64 `json:"total,string"`
  39. }
  41. func main() {
  43. 	// 将 JSON 转换为结构体
  45. 	var THR TradeHistoryResponse
  46. 	err := json.Unmarshal([]byte(mjs), &THR)
  47. 	if err != nil {
  48. 		log.Fatal(err)
  49. 	}
  50. 	for _, v := range THR {
  51. 		fmt.Printf("%+v", v)
  52. 		fmt.Printf("\n")
  53. 	}
  54. }

这将按预期打印出所有的值。所以它没有问题将 JSON 值转换为浮点数/整数（这可能是我的第二个猜测）。

你确定你没有以任何方式修改 Body 吗？你给出的示例是否涵盖了所有边缘情况？

你可以添加以下代码：

  1. fmt.Println(string(body))

到第二个错误块，并在这里记录它给出的错误。

另外，你使用的是哪个版本的 Go？我不排除 encoding/json 在不同版本之间发生了变化的可能性。最后，如果确实是这种情况，简单的解决方法是将响应作为字符串处理，删除所有空格，并在“}{”处分割，如下所示：

  1. fmtBody := strings.Replace(string(body), "\n", "", -1)
  2. fmtBody = strings.Replace(string(fmtBody), " ", "", -1)
  3. fmtBody = strings.Replace(string(fmtBody), "[", "", -1)
  4. fmtBody = strings.Replace(string(fmtBody), "]", "", -1)
  5. var goArrOfYourJsonsObj []string = strings.Split(fmtBody, "},{")
  6. for k, _ := range goArrOfYourJsonsObj {
  7. 	goArrOfYourJsonsObj[k] += "}"
  8. }

现在，你的 JSON 对象已经整齐地分隔成一个 Go 数组，类型为字符串，可以在 Unmarshal 中使用 []byte(val)。

英文:

I didn't think unmarhsalling an array in a JSON like you intended actually works but to the props of encoding/json it does. Example code:
package main

  1. import (
  2. 	"encoding/json"
  3. 	"fmt"
  4. 	"log"
  5. )
  7. var mjs string = "[" +
  8. 	"{" +
  9. 	`"globalTradeID": 64201000,
  10.                           "tradeID": 549285,
  11.                           "date": "2016-11-11 23:51:58",
  12.                           "type": "buy",
  13.                           "rate": "10.33999779",
  14.                           "amount": "0.02176472",
  15.                           "total": "0.22504715"
  16.                         },
  17.                         {
  18.                           "globalTradeID": 64200631,
  19.                           "tradeID": 549284,
  20.                           "date": "2016-11-11 23:48:39",
  21.                           "type": "buy",
  22.                           "rate": "10.33999822",
  23.                           "amount": "0.18211700",
  24.                           "total": "1.88308945"
  25.                         }
  26.                         ]`
  28. type TradeHistoryResponse []TradeHistoryInfo
  30. type TradeHistoryInfo struct {
  31. 	GlobalTradeID int64   `json:"globalTradeID"`
  32. 	TradeID       int64   `json:"tradeID"`
  33. 	Date          string  `json:"date"`
  34. 	Type          string  `json:"type"`
  35. 	Rate          float64 `json:"rate,string"`
  36. 	Amount        float64 `json:"amount,string"`
  37. 	Total         float64 `json:"total,string"`
  38. }
  40. func main() {
  42. 	//Convert JSON to struct
  44. 	var THR TradeHistoryResponse
  45. 	err := json.Unmarshal([]byte(mjs), &THR)
  46. 	if err != nil {
  47.     log.Fatal(err)
  48. 	}
  49.   for _, v := range THR {
  50.     fmt.Printf("%+v", v)
  51.     fmt.Printf("\n")
  52.   }
  53. }

This prints out all the values as expected. So it doesn't have a problem converting the json values to float/int either (which would have been my second guess).

Are you sure you aren't modifying the Body in any way ? And that the example you give cover all edge cases ?

Could you add:

  1. fmt.Println(string(body))

to the second error block and log the error it give here.

Also what version of go are you using ? I wouldn't exclude the possibility of encoding/json to have changed between versions. In the end, if this is indeed the case the easy fix would be taking your response as a string, removing all whitespaces and splitting at "}'{" as in:

  1. fmtBody := strings.Replace(string(body), "\n", "", -1)
  2. fmtBody = strings.Replace(string(fmtBody), "\w", "", -1)
  3. fmtBody = strings.Replace(string(fmtBody), "[", "", -1)
  4. fmtBody = strings.Replace(string(fmtBody), "]", "", -1)
  5. var goArrOfYourJsonsObj []String = strings.Split(fmtBody, "},{")
  6. for k, _ := range goArrOfYourJsonsObj {
  7.   goArrOfYourJsonsObj[k] += "}"
  8. }

And now you have your JSON objects neatly separated into a go array of types String which, can be used in Unmarshall as []byte(val).

答案2

得分: 0

TradeHistoryResponse 是一个类型而不是一个变量，你需要创建一个类型为 TradeHistoryResponse 的变量，像这样：

  1. var th TradeHistoryResponse
  3. // 将 JSON 转换为结构体
  4. err = json.Unmarshal(body, &th)
  5. // ...
  7. fmt.Printf("%+v\n", th)

请注意，这只是一个示例代码，你需要根据实际情况进行适当的修改。

英文:

TradeHistoryResponse is a type no a variable, you have to create a var of type TradeHistoryResponse, like this:

  1. var th TradeHistoryResponse
  3. //Convert JSON to struct
  4. err = json.Unmarshal(body, &th)
  5. // ...
  7. fmt.Printf("%+v\n", th)

huangapple
  • 本文由 发表于 2016年11月16日 09:09:35
  • 转载请务必保留本文链接：https://go.coder-hub.com/40622459.html
  • go
  • json
  • unmarshalling
匿名

发表评论

匿名网友

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

确定