Go-json解码到接口及根据键获取值

Go-json解码到接口及根据键获取值

package main

import (
    "encoding/json"
    "fmt"
    "github.com/bitly/go-simplejson"
)

type JsonServer struct {
    ServerName string
    ServerIP   string
}

type JsonServers struct {
    Servers []JsonServer
}

func main() {
    var s JsonServers
    str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`
    json.Unmarshal([]byte(str), &s)

    fmt.Println(s) //{[{Shanghai_VPN 127.0.0.1} {Beijing_VPN 127.0.0.2}]}

    b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
    var f interface{}
    json.Unmarshal(b, &f)
    fmt.Printf("%+v\n", f) // map[Name:Wednesday Age:6 Parents:[Gomez Morticia]]

    m := f.(map[string]interface{})
    for k, v := range m {
        switch vv := v.(type) {
        case string:
            fmt.Println(k, "is string", vv) //Name is string Wednesday
        case int:
            fmt.Println(k, "is int", vv)
        case float64:
            fmt.Println(k, "is float64", vv) //Age is float64 6
        case []interface{}:
            fmt.Println(k, "is an array:") //Parents is an array:
            //0 Gomez
            //1 Morticia
            for i, u := range vv {
                fmt.Println(i, u)
            }
        default:
            fmt.Println(k, "is of a type I don't know how to handle")
        }
    }

    /**
    如您所见，我们现在可以通过interface{}解析未知格式的JSON并键入断言。
    以上示例是官方解决方案，但类型断言并不总是方便。
    因此，我推荐一个名为simplejson的开源项目，由bitly创建和维护。
    以下是如何使用此项目处理未知格式的JSON的示例：
    go get ithub.com/bitly/go-simplejson
    */
        // 根据键获取值
    js, err := simplejson.NewJson([]byte(`{
    "test": {
        "array": [1, "2", 3],
        "int": 10,
        "float": 5.150,
        "bignum": 9223372036854775807,
        "string": "simplejson",
        "bool": true
    }
}`))
    if err != nil {
        fmt.Println("err:", err)
    }

    arr, _ := js.Get("test").Get("array").Array() //arr: [1 2 3]
    fmt.Println("arr:", arr)
    i, _ := js.Get("test").Get("int").Int() //i: 10
    fmt.Println("i:", i)
    ms := js.Get("test").Get("string").MustString() //ms: simplejson
    fmt.Println("ms:", ms)
}

json解码到接口

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonBuf := `
    {
        "company": "itcast",
        "subjects": [
            "Go",
            "C++",
            "Python",
            "Test"
        ],
        "isok": true,
        "price": 666.666
    }
    `
    //创建一个map
    m := make(map[string]interface{}, 4)
    err := json.Unmarshal([]byte(jsonBuf), &m)
    if err != nil {
        fmt.Println("err=", err)
        return
    }
    fmt.Println("m=", m)     //m= map[company:itcast subjects:[Go C++ Python Test] isok:true price:666.666]
    fmt.Printf("m=%+v\n", m) //m=map[isok:true price:666.666 company:itcast subjects:[Go C++ Python Test]]

    var s string
    s = m["company"].(string)
    fmt.Println("s= ", s) //s=  itcast

    var s1 bool
    s1 = m["isok"].(bool)
    fmt.Println("s1= ", s1) //s1=  true

    var s2 float64
    s2 = m["price"].(float64)
    fmt.Println("s2= ", s2) //s2=  666.666

    var str string
    //类型断言
    for key, value := range m {
        // fmt.Printf("%v===>%v\n", key, value)
        switch data := value.(type) {
        case string:
            str = data
            fmt.Printf("map[%s]的值类型为string，内容为%s\n", key, str)
        case bool:
            fmt.Printf("map[%s]的值类型为bool，内容为%v\n", key, data)
        case float64:
            fmt.Printf("map[%s]的值类型为float64，内容为%v\n", key, data)
        case []string:
            fmt.Printf("map[%s]的值类型为[]stiring1，内容为%v\n", key, data)
        case []interface{}:
            fmt.Printf("map[%s]的值类型为[]stiring2，内容为%v\n", key, data)
        }
        /*
            map[company]的值类型为string，内容为itcast
            map[subjects]的值类型为[]stiring2，内容为[Go C++ Python Test]
            map[isok]的值类型为bool，内容为true
            map[price]的值类型为float64，内容为666.666
        */
    }
}