在 golang 中解组 JSON

Question

我在让我的程序运行时遇到了很多麻烦。我想解组一些非常简单的东西，但不幸的是，它给我带来了很多问题。

这是我要解组的响应：

{"error":[],"result":{"XXBTZUSD":[[1647365820,"39192.0","39192.0","39191.9","39191.9","39191.9","0.18008008",10],[1647365880,"39186.1","39186.1","39172.0","39176.0","39174.4","0.13120077",10]],"last":1647408900}}

我编写了这些结构来帮助解组

type Resp struct {
    Error   []string        `json:"error"`
    Result  Trades          `json:"result"`
}

type Trades struct {
    Pair    []OHLC          `json:"XXBTZUSD"`
    Last    float64         `json:"last"`
}

type OHLC struct {
    Time    float64
    Open    string
    High    string
    Low     string
    Close   string
    Vwa     string
    Volume  string
    Count   float64
}

我有一个函数调用可以发出 http 请求，然后解组数据。无论出于何种原因，当 Pair 类型为 []OHLC 或 []*OHLC 时，我的代码甚至会在启动 http 请求函数调用和后续解组之前结束。如果我将 Pair 类型更改为 interface{}，它就会运行。不过，我想让它与 OHLC 结构一起使用。下面是完整的代码：

package main

import (
    "fmt"
    "net/http"
    //"strings"
    "io/ioutil"
    "encoding/json"
)

type Resp struct {
    Error   []string        `json:"error"`
    Result  Trades          `json:"result"`
}

type Trades struct {
    Pair    []OHLC          `json:"XXBTZUSD"`
    Last    float64         `json:"last"`
}

type OHLC struct {
    TT      float64
    Open    string
    High    string
    Low     string
    Close   string
    Vwap    string
    Volume  string
    Count   float64
}

/*func main() {
    var data = [...]Trade{
        Trade{5, "op", "hi", "lo", "cl", "vw", "vo", 2},
        Trade{5, "op", "hi", "lo", "cl", "vw", "vo", 2},
    }
}*/



func main() {
    fmt.Println("in main");
    getOhlc()

}

func getOhlc() {
    fmt.Println("in ohlc func")
    resp, err := http.Get("https://api.kraken.com/0/public/OHLC?pair=XXBTZUSD");
    if err != nil {
        fmt.Errorf("error after request")
        return;
    }

    defer resp.Body.Close();

    body, err := ioutil.ReadAll(resp.Body);
    if err != nil {
        fmt.Errorf("error when reading")
        return;
    }

    var jsonData Resp;
    err = json.Unmarshal(body, &jsonData);
    if err != nil {
        fmt.Errorf("error when unmarshalling")
        return
    }

    if(len(jsonData.Error) > 0) {
        fmt.Errorf("error");
        return;
    }
    
    fmt.Println(jsonData);
}

对可能发生的事情有什么想法吗？

Answer 1

您的代码有一些问题：

去掉行尾的分号，这是多余的。
fmt.Errorf return 错误，不打印它，每次检查你的错误并传播它。
我们可以在 golang 中将数字数组和字符串转换为结构。

为了实现您想要的输出，我们需要先转换为中间容器，然后再转换为我们想要的输出：

package main

import (
    "errors"
    "fmt"
    "log"
    "net/http"

    //"strings"
    "encoding/json"
    "io/ioutil"
)

type Resp struct {
    Error  []string `json:"error"`
    Result Trades   `json:"result"`
}

type IntermediateResp struct {
    Error  []string           `json:"error"`
    Result IntermediateTrades `json:"result"`
}

type IntermediateTrades struct {
    Pair [][]interface{} `json:"XXBTZUSD"`
    Last int             `json:"last"`
}

type Trades struct {
    Pair []OHLC `json:"result"`
    Last int    `json:"last"`
}

type OHLC struct {
    TT     float64
    Open   string
    High   string
    Low    string
    Close  string
    Vwap   string
    Volume string
    Count  float64
}

/*func main() {
    var data = [...]Trade{
        Trade{5, "op", "hi", "lo", "cl", "vw", "vo", 2},
        Trade{5, "op", "hi", "lo", "cl", "vw", "vo", 2},
    }
}*/

func main() {
    fmt.Println("in main")
    err := getOhlc()
    if err != nil {
        log.Fatal(err)
    }
}

func buildOHLC(l []interface{}) (*OHLC, error) {
    if len(l) < 8 {
        return nil, errors.New("short list")
    }
    return &OHLC{
        TT:     l[0].(float64),
        Open:   l[1].(string),
        High:   l[2].(string),
        Low:    l[3].(string),
        Close:  l[4].(string),
        Vwap:   l[5].(string),
        Volume: l[6].(string),
        Count:  l[7].(float64),
    }, nil
}

func convert(r IntermediateResp) (*Resp, error) {
    result := &Resp{Error: r.Error, Result: Trades{Pair: make([]OHLC, len(r.Result.Pair)), Last: r.Result.Last}}
    for i, v := range r.Result.Pair {
        ohlc, err := buildOHLC(v)
        if err != nil {
            return nil, err
        }
        result.Result.Pair[i] = *ohlc
    }
    return result, nil
}

func getOhlc() error {
    fmt.Println("in ohlc func")
    resp, err := http.Get("https://api.kraken.com/0/public/OHLC?pair=XXBTZUSD")
    if err != nil {
        return fmt.Errorf("error after request, %v", err)
    }

    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
    if err != nil {

        return fmt.Errorf("error when reading %v", err)
    }

    var jsonData IntermediateResp
    err = json.Unmarshal(body, &jsonData)
    if err != nil {

        return fmt.Errorf("error when unmarshalling %v", err)
    }

    if len(jsonData.Error) > 0 {
        return fmt.Errorf("error")
    }

    convertedOhlc, err := convert(jsonData)
    if err != nil {
        return fmt.Errorf("error when convertedOhlc %v", err)
    }
    fmt.Println(convertedOhlc)
    return nil
}

我们为解组定义 IntermediateResp 和 IntermediateTrades json，然后将其转换为实际的 Resp。

我认为另一种方法是对 Trades 结构使用自定义 Unmarshal。

Answer 2

“对可能发生的事情有什么想法吗？”

"XXBTZUSD"JSON数组中的元素本身就是数组，即"XXBTZUSD"是数组的数组。 OHLC 类型是结构类型。 stdlib 本身不会将 JSON 数组解组为 Go 结构。 Go 结构可用于解组 JSON 对象。 JSON 数组可以解组为 Go 切片或数组。

如果您只打印来自 json.Unmarshal:

的错误，您会清楚地看到这就是问题所在

json: cannot unmarshal array into Go struct field Trades.result.XXBTZUSD of type main.OHLC

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

如果你想将一个 JSON 数组解组为 Go 结构，你必须让 Go 结构类型实现 json.Unmarshaler 接口。

func (o *OHLC) UnmarshalJSON(data []byte) error {
    // first unmarshal the array into a slice of raw json
    raw := []json.RawMessage{}
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }

    // create a function that unmarshals each raw json element into a field
    unmarshalFields := func(raw []json.RawMessage, fields ...interface{}) error {
        if len(raw) != len(fields) {
            return errors.New("bad number of elements in json array")
        }
        for i := range raw {
            if err := json.Unmarshal([]byte(raw[i]), fields[i]); err != nil {
                return err
            }
        }
        return nil
    }

    // call the function
    return unmarshalFields(
        raw,
        &o.Time,
        &o.Open,
        &o.High,
        &o.Low,
        &o.Close,
        &o.Vwa,
        &o.Volume,
        &o.Count,
    )
}

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

在 golang 中解组 JSON

Unmarshaling JSON in golang

json

struct

go

unmarshalling