编辑代码

package main

import (
    "fmt"
    "reflect"
    "encoding/gob"
    "bytes"
)

type value struct {
    Data interface{}
    DataType string
}

type s struct {
    Data map[string]*value
}

func main() {
    testGob()
}

func testGob() {
    gob.Register(map[string]interface{}{})
    gob.Register([]interface{}{})
    var s1 = s{
        Data: make(map[string]*value),
    }
    v1 := &value{
        Data: "zpValue",
        DataType: "n",
    }

    v2 := &value{
        Data: []interface{}{},
        DataType: "l",
    }

    list := v2.Data.([]interface{})

    list = append(list, 3)

    v2.Data = list

    v3 := &value{
        Data: map[string]interface{}{},
        DataType: "d",
    }

    dict := v3.Data.(map[string]interface{})
    dict["dzp"] = "dzpValue"

    v3.Data = dict
    

    s1.Data["zp"] = v1
    s1.Data["zpl"] = v2
    s1.Data["zpd"] = v3
    fmt.Printf("value:%v, type:%T\n", s1, s1)

    // encode
    buf := new(bytes.Buffer)
    enc := gob.NewEncoder(buf)
    err := enc.Encode(s1)
    if err != nil {
        fmt.Println("gob encode failed, err:", err)
        return
    }
    b := buf.Bytes()
    fmt.Println(b)

    var s2 = s{
        Data: make(map[string]*value),
    }
    // decode
    dec := gob.NewDecoder(bytes.NewBuffer(b))
    err = dec.Decode(&s2)
    if err != nil {
        fmt.Println("gob decode failed, err", err)
        return
    }
    fmt.Println(s2)
    for _, v := range s2.Data {
        fmt.Printf("value:%v, type:%T\n", v, v)
    }

}

// func gobDemo() {
//     gob.Register(map[string]interface{}{})
//     gob.Register([]interface{}{})
//     var s1 = s{
//         Data: make(map[string]interface{}),
//     }
//     s1.Data["count"] = []interface{}{3,4,5}
    
    
//     // encode
//     buf := new(bytes.Buffer)
//     enc := gob.NewEncoder(buf)
//     err := enc.Encode(s1)
//     if err != nil {
//         fmt.Println("gob encode failed, err:", err)
//         return
//     }
//     b := buf.Bytes()
//     fmt.Println(b)
//     var s2 = s{
//         Data: make(map[string]interface{}, 8),
//     }
//     // decode
//     dec := gob.NewDecoder(bytes.NewBuffer(b))
//     err = dec.Decode(&s2)
//     if err != nil {
//         fmt.Println("gob decode failed, err", err)
//         return
//     }
//     fmt.Println(s2)
//     l := s2.Data["count"].([]interface{})
//     fmt.Println(l)
//     for _, v := range s2.Data {
//         fmt.Printf("value:%v, type:%T\n", v, v)
//     }
// }


func typeof(v interface{}) string {
    return reflect.TypeOf(v).String()
}