分析仅包含在数组中的 JSON 响应

在解码 JSON 响应时，如果响应仅包含在数组中，则无法使用类型断言将 []interface{} 转换为特定结构。这是因为 []interface{} 是一个包含各种类型元素的切片，而类型断言只能将元素转换为与目标类型完全匹配的类型。因此，需要编写自定义解码器来处理数组中的不同元素类型并将其转换为所需的结构。

我在解码 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/ 这样的工具时，它希望我制作一个 [][]interface{}。但在我的 for 循环中，您可以看到它打印了（在我看来）有效的：[]interface{}，但我无法将其转换为 binance_klines 类型的结构。 这行有问题吗：

kline = (to_parse).(Binance_klines)

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

正确答案

您无法将 []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。

这部分：

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 表示形式，而是收到任何结构的切片（数字和字符串的混合）。

今天关于《分析仅包含在数组中的 JSON 响应》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！