在 golang 中解组 JSON

小伙伴们对Golang编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《在 golang 中解组 JSON》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

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

这是我想要解组的响应：

{"错误":[],"结果":{"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]],"最后":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);
}

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

正确答案

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

"xxbtzusd" json 数组中的元素本身就是数组，即 "xxbtzusd" 是数组的数组。 ohlc 类型是结构类型。 stdlib 本身不会将 json 数组解组为 go 结构。 go 结构体可用于解组 json 对象。 json 数组可以被解组为 go 切片或数组。

如果您只是从 json.unmarshal 打印错误，您会清楚地看到这就是问题所在：

json：无法将数组解组到 go 结构字段 main.ohlc 类型的 trades.result.xxbtzusd

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

您的代码存在一些问题：

1. 删除行尾的分号，这是多余的。
2. fmt.errorf 返回错误，并且不打印它，每次检查错误并传播它。
3. 我们可以在 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
}

我们为 unmarshaling json 定义 intermediateresp 和 intermediatetrades，然后将其转换为实际的 resp。

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

好了，本文到此结束，带大家了解了《在 golang 中解组 JSON》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！