为了账号安全,请及时绑定邮箱和手机立即绑定

在 golang 中解组 JSON

在 golang 中解组 JSON

Go
开心每一天1111 2022-11-23 15:27:25

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


这是我要解组的响应:


{"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 结构一起使用。


查看完整描述

2 回答

?
鸿蒙传说

TA贡献1566条经验 获得超7个赞

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

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

如果您只是打印来自 json.Unmarshal 的错误,您会清楚地看到这就是问题所在:

json:无法将数组解组到main.OHLC 类型的 Go 结构字段 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


查看完整回答
反对 回复 5天前
?
ITMISS

TA贡献1534条经验 获得超8个赞

您的代码有一些问题:

  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

}

我们定义 IntermediateResp 和 IntermediateTrades 用于 Unmarshaling json,然后将其转换为实际的 Resp。


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


查看完整回答
反对 回复 5天前

添加回答

举报

0/150
提交
取消
意见反馈 帮助中心 APP下载
官方微信