go json转换

package main
import (
    "encoding/json"
    "fmt"
)
type F struct {
    H string
    K int
}
type A struct {
    B string
    C int
    D map[string]int
    E []int
    F F
}
func main() {
    txt := `{"b":"hello word","c":1,"d":{"a":1,"b":2},"e":[2,3,4,5],"f":{"h":"a","k":1}}`
    var ab A
    json.Unmarshal([]byte(txt), &ab)
    fmt.Println(ab.B)
    fmt.Println(ab.C)
    for key, val := range(ab.D){
        fmt.Println(key, val)
    }
    for _, e := range(ab.E){
        fmt.Println(e)
    }
    fmt.Println(ab.F.H)
    fmt.Println(ab.F.K)
}

package main
import (
    "encoding/json"
    "fmt"
)
func Decode(obj map[string]interface{}){
    for k, v := range obj {
        switch vv := v.(type) {
        case string:
            fmt.Println(k, "is string", vv)
        case int:
            fmt.Println(k, "is int", vv)
        case float64:
            fmt.Println(k,"is float64",vv)
        case []interface{}:
            fmt.Println(k, "is an array:")
            for i, u := range vv {
                fmt.Println(i, u)
            }
        default:
            fmt.Println(k, "is of a type I don't know how to handle")
        }
    }
}
func main() {
    txt := `{"a":1,"b":"hello","c":{"a":1,"b":2.5},"d":["a","b","c"]}`
    var ab map[string]interface{}
    json.Unmarshal([]byte(txt), &ab)
    Decode(ab)
}

package main
import (
    "encoding/json"
    "fmt"
)
func JsonDecode(str []byte) map[string]interface{} {
    var dict map[string]interface{}
    err := json.Unmarshal(str, &dict)
    if err != nil {
        fmt.Println(err)
        return nil
    }
    return dict
}
func JsonEncode(dict interface{}) []byte {
    str, err := json.Marshal(dict)
    if err != nil {
        fmt.Println(err)
        return nil
    }
    println(string(str))
    return str
}
type A struct {
    B string
    C int
    D *A
}
func main() {
    var a A
    var hk A
    a = A{
        B:"hello word!",
        C:1,
        D:&A{
            B:"hello ABC",
            C:2,
            D:nil,
        },
    }
    fmt.Println(a.B)
    str, _ := json.Marshal(a)
    println(string(str))
    json.Unmarshal(str, &hk)
    fmt.Println(hk.D.B)
}