解码仅存在于数组外的 JSON 响应

Question

我在解码 JSON 响应时遇到问题。 我已经尝试解决这个问题了几个星期，但在网上找不到有效的解决方案。

这是我得到响应的 Go 代码：

package main

import (
    "fmt"

    "time"
    "strconv"
    "encoding/json"

    "net/http"
    "io"
)

const (
    binanceUrl_0 = "https://api.binance.com"
    binanceUrl_1 = "https://api1.binance.com"
    binanceUrl_2 = "https://api2.binance.com"
    binanceUrl_3 = "https://api3.binance.com"

    //select which url to use
    binanceUrl = binanceUrl_0

    binance_GetServerTime   = binanceUrl + "/api/v3/time"
    binance_Ping            = binanceUrl + "/api/v3/ping"
    binance_GetExhangeInfo  = binanceUrl + "/api/v3/exchangeInfo"
    binance_GetExhangeInfo_Symbol   = binanceUrl + "/api/v3/exchangeInfo?symbol=BNBBTC"
    binance_GetKlineData    = binanceUrl + "/api/v1/klines"
)

type Binance_klines struct {
    OpenTime        int64       

    open            float32     
    high            float32     
    low             float32     
    close           float32     
    volume          float32     
    CloseTime        int64      
    QuoteVolume      float32    
    NumTrades        int64      
    TakerBaseVolume  float32    
    TakerQuoteVolume float32    
}

func GetKlines_wEndTime(symbol string, interval string, limit int, endTime time.Time) ([]Binance_klines, error) {
    var url string
    url = binance_GetKlineData + "?" +
         "symbol=" + symbol + 
         "&interval=" + interval + 
         "&limit=" + strconv.FormatInt(int64(limit), 10) + 
         "&endTime=" + strconv.FormatInt(endTime.Unix(),10 ) + "000"

    response, err := http.Get(url)
    if err != nil {
        return nil, err
    }   

    data, err := respToKlines(response.Body)
    if err != nil {
        return nil, err
    }   
    
    response.Body.Close()   

    return data, nil
}

func respToKlines(data io.Reader)  ([]Binance_klines, error) {
    var klines []Binance_klines

    var decoded []interface{}
    decoder := json.NewDecoder(data)    
    err := decoder.Decode(&decoded)
    if err != nil {
        return nil, err 
    }

    //Attempt 1:
    //kline = (decoded).([]Binance_klines)
    //err: invalid operation: (decoded) (variable of type []interface{}) is not an interface

    //Attempt 2:
    for i:=0; i<len(decoded); i++ {  
        
        to_parse := decoded[i]
        fmt.Println("to_parse",to_parse)

        //prints: to_parse [1.66427838e+12 20982.91000000 20992.61000000 20977.90000000 20980.95000000 0.68063000 1.664278439999e+12 14282.75833530 57 0.27942000 5864.01792110 0]
        var kline Binance_klines
        kline = (to_parse).(Binance_klines)
        //err: interface conversion: interface {} is []interface {}, not dsBinance.Binance_klines   

        fmt.Println("kline",kline)
    }
    return klines, nil
}

func main() {
    result, err := GetKlines_wEndTime( "BTCEUR", "1m", 3, time.Now() )
    fmt.Println(result, err)
}

这是我得到的响应（从字节转换为字符串）：

[[1664277480000,"20980.42000000","20984.06000000","20966.57000000","20970.14000000","6.10441000",1664277539999,"128041.93403330",142,"2.97844000","62486.29173860","0"],[1664277540000,"20969.14000000","20976.08000000","20955.69000000","20970.15000000","3.17365000",1664277599999,"66548.64583140",88,"2.39827000","50292.47196580","0"],[1664277600000,"20970.15000000","20970.15000000","20970.15000000","20970.15000000","0.00000000",1664277659999,"0.00000000",0,"0.00000000","0.00000000","0"]]

我的问题是，我做错了什么？ 当我使用https://mholt.github.io/json-to-go/之类的工具时，它希望我制作一个 [][] 接口{}。 但是在我的 for 循环中，您可以看到它打印了一个（在我看来）有效的：[]interface{}，但我无法将其转换为 Binance_Klines 类型的结构。 这条线有问题吗：

kline = (to_parse).(Binance_klines)

还是我只是误解了什么？ 我需要更改什么才能使用类型断言？ 还是立即将其解码为正确的结构？

Answer 1

您不能将[]interface{}转换为Binance_klines 。 所以kline = (to_parse).(Binance_klines)失败。 你必须自己写翻译。

---

返回的数据是一个二维数组。 这是您已格式化的 json 有效负载。 类型是string和float64的混合，因此 Go 使用interface{}来存储值。

[
   [
      1664277480000,
      "20980.42000000",
      "20984.06000000",
      "20966.57000000",
      "20970.14000000",
      "6.10441000",
      1664277539999,
      "128041.93403330",
      142,
      "2.97844000",
      "62486.29173860",
      "0"
   ],
   [
      1664277540000,
      "20969.14000000",
      "20976.08000000",
      "20955.69000000",
      "20970.15000000",
      "3.17365000",
      1664277599999,
      "66548.64583140",
      88,
      "2.39827000",
      "50292.47196580",
      "0"
   ],
   [
      1664277600000,
      "20970.15000000",
      "20970.15000000",
      "20970.15000000",
      "20970.15000000",
      "0.00000000",
      1664277659999,
      "0.00000000",
      0,
      "0.00000000",
      "0.00000000",
      "0"
   ]
]

json 解码器无法将其转换为您的Binance_klines结构。 但是您可以自己覆盖默认的解组行为。

首先，我为有时引用的数字制作了一个类型，有时不是。

type BinanceNumber string

func (b *BinanceNumber) UnmarshalJSON(data []byte) error {
    *b = BinanceNumber(strings.Trim(string(data), "\""))
    return nil
}

func (b BinanceNumber) Float64() float64 {
    f, err := strconv.ParseFloat(string(b), 64)
    if err != nil {
        panic(err)
    }
    return f
}

func (b BinanceNumber) Int64() int64 {
    i, err := strconv.ParseInt(string(b), 10, 64)
    if err != nil {
        panic(err)
    }
    return i
}

然后你覆盖Binance_klines解组。

func (b *Binance_klines) UnmarshalJSON(data []byte) error {
    var array []BinanceNumber
    err := json.Unmarshal(data, &array)
    if err != nil {
        return err
    }

    b.OpenTime = array[0].Int64()
    b.Open = float32(array[1].Float64())
    b.High = float32(array[2].Float64())
    b.Low = float32(array[3].Float64())
    b.Close = float32(array[4].Float64())
    b.Volume = float32(array[5].Float64())
    b.CloseTime = array[6].Int64()
    b.QuoteVolume = float32(array[7].Float64())
    b.NumTrades = array[8].Int64()
    b.TakerBaseVolume = float32(array[9].Float64())
    b.TakerQuoteVolume = float32(array[10].Float64())

    return nil
}

把它们放在一起： https://go.dev/play/p/SGGbWEUFxJr 。

Answer 2

这部分：

var kline Binance_klines
kline = (to_parse).(Binance_klines)

需要成为

var kline Binance_klines
kline.OpenTimer = to_parse[0].(int64)
kline.open = strconv.ParseFloat(to_parse[1].(string), 64)
...

您没有收到Binance_klines结构的 json 表示，而是任何（混合或数字和字符串）的一部分。