Golang Unmarshal JSON

我的输入JSON有一个不同元素的列表。
我对响应的第一个元素的数量有问题

:

输出错误。我不明白错误在哪里。请帮帮我

---

---

您的响应json无效。对于类型D中指定的字段，您使用数组而不是结构。

1-这是工作代码，请尝试：

输出：

{777 [{888 999 888 hello} {999 888 999 goodbye}]}

---

我有一个不同的方法：

您所要做的就是实现接口并在方法UnmarshalJSON中添加逻辑。它与另一个解决方案类似，但更具可移植性，因为您不必在主方法或外部方法中执行此操作，而且它更健壮：）

主程序包
进口(
“编码/json”
“fmt”
“日志”
)
变量j=`{
“答复”：[
777,
{
“id”：888，
“from_id”：999，
“收件人id”：888，
“文本”：“你好…”
},
{
“id”：999，
“from_id”：888，
“收件人id”：999，
“文本”：“再见…”
}
]
}`
D型结构{
Id int`json:“Id”`
FromId int`json:“from_id”`
ToId int`json:“to_id”`
文本字符串`json:“文本”`
}
R型结构{
计数整数
答复[]D
}
func（r*r）解组JSON（数据[]字节）错误{
变量值结构{
Resp[]接口{}`json:“响应”`
}
如果err:=json.Unmarshal（数据和值）；err！=nil{
返回错误
}
如果len（值Resp）<1{
返回fmt.Errorf（“空响应%v”，值响应）
}
count，isNumber:=value.Resp[0]。（float64）
如果！我的号码是多少{
返回fmt.Errorf（“第一个元素必须是一个数字，我们得到了'%T'，values.Resp[0]）
}
r、 计数=整数（计数）
对于u，elem:=范围值。Resp[1:]{
de，err:=json.Marshal（elem）
如果错误！=零{
返回错误
}
变量d
如果err:=json.Unmarshal（de，&d）；err！=nil{
返回错误
}
r、 响应=追加（r.Response，d）
}
归零
}
func main（）{
var数据=新（R）
如果err:=json.Unmarshal（[]字节（j），&data）；err！=nil{
log.Fatal（错误）
}
fmt.Println（*数据）
}

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    var d *R
    err := json.Unmarshal([]byte(str), &d)
    if err != nil {
        panic(err)
    }
    var data R2
    data.Count = int(d.Response[0].(float64))

    for _, v := range d.Response[1:] {    
        bs, err := json.Marshal(v)
        if err != nil {
            panic(err)
        }
        var d1 *D
        err = json.Unmarshal(bs, &d1)
        if err != nil {
            panic(err)
        }
        data.Response = append(data.Response, *d1)
    }
    fmt.Println(data)    
}

type R struct {
    Response []interface{} `json:"response"`
}

var str = ` {
  "response": [
    777,  
    {
      "id": 888,
      "from_id": 999,
      "to_id": 888,
      "text": "hello"
    },
        {
      "id": 999,
      "from_id": 888,
      "to_id": 999,
            "text": "goodbye"
    }
  ]
}`

type D struct {
    Id     int    `json:"id"`
    FromId int    `json:"from_id"`
    ToId   int    `json:"to_id"`
    Text   string `json:"text"`
}
type R2 struct {
    Count    int
    Response []D
}

{777 [{888 999 888 hello} {999 888 999 goodbye}]}

package main

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

var j = `{
  "response": [
    777,
    {
      "id": 888,
      "from_id": 999,
      "to_id": 888,
      "text": "hello..."
    },
    {
      "id": 999,
      "from_id": 888,
      "to_id": 999,
            "text": "goodbye..."
    }
  ]
}`

type D struct {
    Id     int    `json:"id"`
    FromId int    `json:"from_id"`
    ToId   int    `json:"to_id"`
    Text   string `json:"text"`
}

type R struct {
    Count    int
    Response []D
}

func (r *R) UnmarshalJSON(data []byte) error {
    var values struct {
        Resp []interface{} `json:"response"`
    }

    if err := json.Unmarshal(data, &values); err != nil {
        return err
    }

    if len(values.Resp) < 1 {
        return fmt.Errorf("empty response %v", values.Resp)
    }

    count, isNumber := values.Resp[0].(float64)
    if !isNumber {
        return fmt.Errorf("first element has to be a number, we got '%T'", values.Resp[0])
    }
    r.Count = int(count)

    for _, elem := range values.Resp[1:] {
        de, err := json.Marshal(elem)
        if err != nil {
            return err
        }
        var d D
        if err := json.Unmarshal(de, &d); err != nil {
            return err
        }
        r.Response = append(r.Response, d)
    }
    return nil
}

func main() {
    var data = new(R)
    if err := json.Unmarshal([]byte(j), &data); err != nil {
        log.Fatal(err)
    }
    fmt.Println(*data)
}