本文共 3281 字，大约阅读时间需要 10 分钟。

   
    
    
     
JSON常用方法示例
    
     
    
     
        package main
        import (
            "encoding/json"
            "fmt"
            "os"
            "time"
        )
        
        type info struct {
            Name  string `json:"name"`
            Age  int   `json:"age"`
            Extra interface{} `json:"extra"`
        }
        
        // JSON Unmarshal 将字符串解析为对应的结构体
        func testUnmarshal() {
            str := `{"name": "code-machine", "age": 18, 
                     "extra": {"phoneNumber": "8008208820", "hobby": ["LOL", "CF", "CS", "CSGO"]}}`
            
            var s info
            if err := json.Unmarshal([]byte(str), &s); err != nil {
                panic(err)
            }
            fmt.Println(s.Name)
            fmt.Println(s.Age)
            fmt.Println(s.Extra)
        }
        
        // JSON Marshal 将结构体解析为[]byte
        func testMarshal() {
            type extra struct {
                PhoneNumber string `json:"phoneNumber"`
                Hobby     []string `json:"hobby"`
            }
            
            e := extra{
                PhoneNumber: "8008208820",
                Hobby:     []string{"LOL", "CF", "CS", "CSGO"},
            }
            
            s := &info{
                Name:  "code-machine",
                Age:  18,
                Extra: e,
            }
            
            ret, err := json.Marshal(s)
            if err != nil {
                panic(err)
            }
            fmt.Println(string(ret))
        }
        
        // 从io.Reader中读取内容并解析为对应的结构体
        func testDecode() {
            type moreInfo struct {
                Address string `json:"address"`
                Job     string `json:"job"`
            }
            
            f, err := os.Open("./test-file")
            if err != nil {
                panic(err)
            }
            defer f.Close()
            
            s := &info{}
            d := json.NewDecoder(f)
            
            if err := d.Decode(s); err != nil {
                panic(err)
            }
            fmt.Println(s)
            
            remainder := d.Buffered()
            more := &moreInfo{}
            b := make([]byte, 100)
            n, err := remainder.Read(b)
            if err != nil {
                panic(err)
            }
            fmt.Println(string(b))
            
            if err := json.Unmarshal(b[:n], more); err != nil {
                panic(err)
            }
            fmt.Println(more)
        }
        
        // 将结构体解析为字符串后写入io.Writer
        func testEncode() {
            type encode struct {
                Time int64 `json:"time"`
                Context string `json:"context"`
            }
            
            f, err := os.OpenFile("./test-file", os.O_APPEND, os.ModeAppend)
            if err != nil {
                panic(err)
            }
            
            e := json.NewEncoder(f)
            s := &encode{
                Time:  time.Now().Unix(),
                Context: "test json",
            }
            
            if err := e.Encode(s); err != nil {
                panic(err)
            }
        }
        
        func main() {
            //testUnmarshal()
            //testMarshal()
            //testDecode()
            testEncode()
        }