解组没有密钥的嵌套 json

在Golang实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《解组没有密钥的嵌套 json》，聊聊，希望可以帮助到正在努力赚钱的你。

我无法将以下 json 转换为 golang 中的结构（从 kraken api 接收）：

{
    "error": [],
    "result": {
        "linkusd": {
            "asks": [
                ["2.049720", "183.556", 1576323009],
                ["2.049750", "555.125", 1576323009],
                ["2.049760", "393.580", 1576323008],
                ["2.049980", "206.514", 1576322995]
            ],
            "bids": [
                ["2.043800", "20.691", 1576322350],
                ["2.039080", "755.396", 1576323007],
                ["2.036960", "214.621", 1576323006],
                ["2.036930", "700.792", 1576322987]
            ]
        }
    }
}

使用 json-to-go，他给了我以下结构：

type autogenerated struct {
    error  []interface{} `json:"error"`
    result struct {
        linkusd struct {
            asks [][]interface{} `json:"asks"`
            bids [][]interface{} `json:"bids"`
        } `json:"linkusd"`
    } `json:"result"`
}

显然，我无法对 linkusd 进行硬编码，因为它会针对每个货币对而改变。

我创建了两个结构来完成任务，但我无法将结果投射到结构中。

type bitfinexorderbook struct {
    pair string          `json:"pair"`
    asks []bitfinexorder `json:"asks"`
    bids []bitfinexorder `json:"bids"`
}

type bitfinexorder struct {
    price     string
    volume    string
    timestamp time.time
}

我的第一次尝试是使用反射。阅读上面发布的 json 数据，我能够检索包含 asks 和 bids 列表的接口。

// just used as a divisor
const div string = " ---------------------------------"
func test(data []byte) error {
    var err error

    // creating the maps for the json data
    m := map[string]interface{}{}

    // parsing/unmarshalling the json readed from the file
    err = json.unmarshal(data, &m)

    if err != nil {
        log.println("error unmarshalling data: " + err.error())
        return err
    }

    // extract the "result" only
    a := reflect.valueof(m["result"])

    if a.kind() == reflect.map {
        key := a.mapkeys()[0] // extract the key -> linkusd
        log.println("key: ", key, div)
        strct := a.mapindex(key) // extract the value -> asks and bids array
        log.println("map: ", strct, div)
        m, _ := strct.interface().(map[string]interface{})
        log.println("asks: ", m["asks"], div) // this will print [[value, value, value] ...] related to asks
        log.println("bids: ", m["bids"], div) // this will print [[value, value, value] ...] related to bids

        // parse the interface into a []byte
        asks_data, err := json.marshal(m["asks"])
        log.println("ok: ", err, div)
        log.println("asks: ", string(asks_data), div)
        // tried without array to (datastructure.bitfinexorder)
        var asks []datastructure.bitfinexorder
        err = json.unmarshal(asks_data, &asks)
        log.println("error: ", err, div)
        log.println("unmarshal: ", asks, div)

    }
    return errors.new("unable_parse_value")
}

下面的两个打印 m, _ := strct.interface().(map[string]interface{}) 将显示以下类似的数据，由于它们是 interface ，所以我无法转换这些数据类型：

[[2.049720 183.556 1.576323009e+09] [2.049750 555.125 1.576323009e+09] [2.049760 393.580 1.576323008e+09] [2.049980 206.514 1.576322995e+09]]

但我无法解组数据。

所以我尝试了 @chmike 提供的不同函数：

// UnmarshalJSON decode a BifinexOrder.
func UnmarshalJSON(data []byte) (datastructure.BitfinexOrder, error) {
    var packedData []json.Number

    var order datastructure.BitfinexOrder
    err := json.Unmarshal(data, &packedData)
    if err != nil {
        return order, err
    }
    order.Price = packedData[0].String()
    order.Volume = packedData[1].String()
    t, err := packedData[2].Int64()
    if err != nil {
        return order, err
    }
    order.Timestamp = time.Unix(t, 0)
    return order, nil
}

但我收到以下错误：

json：无法将数组解组为 json.number 类型的 go 值

一些技巧？

注意：我之前的问题已作为“unmarshal 2 different structs in a slice”的重复问题而关闭。但是，如果您阅读这些问题，我不会处理两个不同的结构...我正在处理一个 json，其中包含我之前不知道的密钥。我也无法封送 bitfinexorder

解决方案

从@mkopriva和@chmike找到的解决方案：

谢谢大家！

package main

import (
    "fmt"
    "time"
    "encoding/json"
)

var data = []byte(`{
    "error": [],
    "result": {
        "LINKUSD": {
            "asks": [
                ["2.049720", "183.556", 1576323009],
                ["2.049750", "555.125", 1576323009],
                ["2.049760", "393.580", 1576323008],
                ["2.049980", "206.514", 1576322995]
            ],
            "bids": [
                ["2.043800", "20.691", 1576322350],
                ["2.039080", "755.396", 1576323007],
                ["2.036960", "214.621", 1576323006],
                ["2.036930", "700.792", 1576322987]
            ]
        }
    }
}`)

type Response struct {
    Error  []interface{}          `json:"error"`
    Result map[string]Order `json:"result"`
}

type Order struct {
    Asks []BitfinexOrder `json:"asks"`
    Bids []BitfinexOrder `json:"bids"`
}

type BitfinexOrder struct {
    Price     string
    Volume    string
    Timestamp time.Time
}

// UnmarshalJSON decode a BifinexOrder.
func (b *BitfinexOrder) UnmarshalJSON(data []byte) error {
    var packedData []json.Number
    err := json.Unmarshal(data, &packedData)
    if err != nil {
        return err
    }
    b.Price = packedData[0].String()
    b.Volume = packedData[1].String()
    t, err := packedData[2].Int64()
    if err != nil {
        return err
    }
    b.Timestamp = time.Unix(t, 0)
    return nil
}

func main() {
    res := &Response{}
    if err := json.Unmarshal(data, res); err != nil {
        panic(err)
    }

    for key, value := range res.Result {
        fmt.Println(key)
        for i, ask := range value.Asks {
            fmt.Printf("Asks[%d] = %#v\n", i, ask)
        }
        for i, bid := range value.Bids {
            fmt.Printf("Bids[%d] = %#v\n", i, bid)
        }
    }
}

以上就是《解组没有密钥的嵌套 json》的详细内容，更多关于的资料请关注golang学习网公众号！