在 Python 中将任何 JSON 转换为标准字典相当于什么？

Question

在Python中，您可以执行以下操作：

r = requests.get("http://wikidata.org/w/api.php", params=params)
data = r.json()

现在data是一个dict或哈希表（而且，我不需要预先定义dict的结构），我可以通过执行data["entities"]、data["Entity"]["Q12"]等操作来访问键的值。

在戈兰我该怎么做？到目前为止，我有这个：

resp, err := http.Get("http://wikidata.org/w/api.php?"+v.Encode())
if err != nil {
    // handle error
}
defer resp.Body.Close()
decoder := json.NewDecoder(resp.Body)
var data interface{}
decodeErr := decoder.Decode(&data)
if decodeErr != nil {
    // handle error
}
fmt.Println(data["entities"], data["entities"]["Q"+id])

这给了我编译错误：invalid operation: data["entities"] (index of type interface {})

那么var data应该是什么类型呢？我是否需要预先为JSON定义一个结构，或者是否可以在不修改代码的情况下处理任何JSON文件/流？

Answer 1

如果您想要一个字典，请使用Go类型map[string]interface{}（这是一个具有string键和任何类型值的map）：

var data map[string]interface{}

然后你可以参考它的元素，比如：

data["entities"]

参见此示例：

s := `{"text":"I'm a text.","number":1234,"floats":[1.1,2.2,3.3],
    "innermap":{"foo":1,"bar":2}}`
var data map[string]interface{}
err := json.Unmarshal([]byte(s), &data)
if err != nil {
    panic(err)
}
fmt.Println("text =", data["text"])
fmt.Println("number =", data["number"])
fmt.Println("floats =", data["floats"])
fmt.Println("innermap =", data["innermap"])
innermap, ok := data["innermap"].(map[string]interface{})
if !ok {
    panic("inner map is not a map!")
}
fmt.Println("innermap.foo =", innermap["foo"])
fmt.Println("innermap.bar =", innermap["bar"])
fmt.Println("The whole map:", data)

输出：

text = I'm a text.
number = 1234
floats = [1.1 2.2 3.3]
innermap = map[foo:1 bar:2]
innermap.foo = 1
innermap.bar = 2
The whole map: map[text:I'm a text. number:1234 floats:[1.1 2.2 3.3]
    innermap:map[foo:1 bar:2]]

在围棋场上试试吧。

注意：

基本上，如果你的映射是多级的（map包含另一个map），就像上面例子中的"innermap"一样，当你访问内部映射时，你可以使用Type断言将其作为另一个映射：

innermap, ok := data["innermap"].(map[string]interface{})
// If ok, innermap is of type map[string]interface{}
// and you can refer to its elements.

Answer 2

我更喜欢添加类型声明，这样您就可以添加方法来简化类型断言：

package main
type mapType map[string]interface{}
func (t mapType) m(s string) mapType {
   return t[s].(map[string]interface{})
}
func (t mapType) f(s string) float64 {
   return t[s].(float64)
}

示例：

package main
import (
   "encoding/json"
   "net/http"
)
func main() {
   req, err := http.NewRequest("GET", "http://wikidata.org/w/api.php", nil)
   if err != nil {
      panic(err)
   }
   q := req.URL.Query()
   q.Set("action", "wbgetentities")
   q.Set("format", "json")
   q.Set("ids", "Q24871")
   req.URL.RawQuery = q.Encode()
   res, err := new(http.Client).Do(req)
   if err != nil {
      panic(err)
   }
   defer res.Body.Close()
   var t mapType
   json.NewDecoder(res.Body).Decode(&t)
   println(t.m("entities").m("Q24871").f("pageid") == 28268)
}

https://golang.org/ref/spec#Type_declarations