无效操作：type interface {} 不支持索引

Question

我是 golang 新手，在读取嵌套的 JSON 响应时遇到问题。

var d interface{}
json.NewDecoder(response.Body).Decode(&d)
test :=d["data"].(map[string]interface{})["type"]

response.Body 看起来像这样

{
    "links": {
      "self": "/domains/test.one"
    },
    "data": {
        "type": "domains",
        "id": "test.one",
        "attributes": {
            "product": " Website",
            "package": "Professional",
            "created_at": "2016-08-19T11:37:01Z"
        }
    }
}

我得到的错误是这样的：

invalid operation: d["data"] (type interface {} does not support indexing)

Answer 1

你也可以这样做：

var inputJson string = "..."

var decoded map[string]map[string]interface{}

json.Unmarshal([]byte(inputJson), &decoded)

test := decoded["data"]["type"]

fmt.Println(test)
// output: domains

Answer 2

d 是interface{} 类型，所以你不能像d["data"] 那样索引它，你需要另一个类型断言：

test := d.(map[string]interface{})["data"].(map[string]interface{})["type"]
fmt.Println(test)

然后它将起作用。输出将是"domains"。请参阅Go Playground 上的工作示例。

还请注意，如果您将d 声明为map[string]interface{} 类型，则可以省略第一个类型断言：

var d map[string]interface{}
if err := json.NewDecoder(response.Body).Decode(&d); err != nil {
    panic(err)
}
test := d["data"].(map[string]interface{})["type"]
fmt.Println(test)

输出是一样的。在Go Playground 上试试这个。

如果您需要多次执行这些和类似操作，您可能会发现我的 github.com/icza/dyno 库很有用（其主要目标是帮助处理动态对象）。

Answer 3

你需要一些技巧来处理你的情况。
就像使用反射一样，您可以参考 golang mongo driver mgo 中有关 bson.M 的 Marshall&&UnMarshall 代码

使用反射解码的代码示例嵌套如下：

package main

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

func main() {
    keys := []string{"hello", "world", "dude", "kind", "cool"}
    a := make(map[string]interface{})
    a[keys[4]] = "perfect"
    b := make(map[string]interface{})
    b[keys[3]] = a
    c := make(map[string]interface{})
    c[keys[2]] = b
    d := make(map[string]interface{})
    d[keys[1]] = c
    e := make(map[string]interface{})
    e[keys[0]] = d
    fmt.Println(e)

    if buf, err := json.Marshal(e); nil == err {
        dd := make(map[string]interface{})
        err = json.Unmarshal(buf, &dd)
        if nil != err {
            fmt.Println("failed", err)
        }

        for k, v := range dd {
            travel(dd, k, v)
        }
        fmt.Println(dd)

    } else {
        fmt.Println("failed marshal")
    }
}

func travel(dd map[string]interface{}, key string, value interface{}) {
    vv := reflect.ValueOf(value)
    switch vv.Kind() {
    case reflect.Map:
        m := value.(map[string]interface{})
        dd[key] = m
        for k, v := range m {
            travel(m, k, v)
        }
    case reflect.String:
        dd[key] = value.(string)
    }
}