欢迎大家来到IT世界,在知识的湖畔探索吧!

对 JSON 的处理分为编码和解码两个部分。

编码

对一组数据进行 JSON 格式编码

b, err := json.Marshal(gobook)

欢迎大家来到IT世界,在知识的湖畔探索吧!

gobook 是 Book 类型的实例对象

欢迎大家来到IT世界,在知识的湖畔探索吧!gobook := Book{
  "Go",
  ["x","b"],
  "ituring.com.cn",
  true,
  9.99
}

type Book struct {
     Title string
     Authors []string
     Publisher string
     IsPublished bool
     Price float
}

如果编码成功，err 将赋予 nil，b 是一个进行 JSON 格式化之后的 []byte 类型。

b == []byte('
    {
         "Title":"Go",

         "Authors":["x","b"],

         "Publisher":"ituring.com.cn",

         "IsPublished": true,

         "Price":9.99
    }
')

当调用 json.Marshal(gobook) 语句时，会递归遍历 gobookk 对象，如果发现 gobook 这个数据结构实现了 json.Marshaler 接口，且包含有效值，Marshal() 就会调用其 MarshalJSON() 方法将该数据结构生产 JSON 格式的文本。

Go 中大多数数据类型都可以转化为有效的 JSON 文本，除了 channel、complex、函数。它的功能和 Python 中的 json.dumps() 相同。

JSON 转化前后的数据类型映射：

解码

已知 JSON 结构

欢迎大家来到IT世界,在知识的湖畔探索吧!var book Book

err := json.Unmarshal(b, &book)

如果 JSON 中的字段在 Go 目标类型中不存在，json.Unmarshal() 函数在解码过程中会丢弃该字段。

未知 JSON 结构

Go 中允许使用 map[string]interface{} 和 []interface{} 类型的值来分别存放未知结构的 JSON 对象或数组，

b := []byte("
            "
)

r 被定义为一个空接口。json.Unmarshal() 函数将一个 JSON 对象解码到空接口 r 中，最终 r 将会是一个键值对的 map[string] interface{} 结构：

map[string] interface{} {
  "title":"name"
}

要访问解码后的数据结构，需要先判断目标结构是否为预期的数据类型

gobook, ok := r.(map[string] interface{})

通过 for 循环搭配 range 语句一一访问解码后的目标数据：

if ok {
  for k, v := range gobook {
      switch v2 := v.(type) {
        case string:
           fmt.Println(k, "is string", v2)
        case int:
           fmt.Println(k, "is int", v2)
        case bool:
           fmt.Println(k, "is bool", v2)
        case []interface{}:
           fmt.Println(k, "is an array:")
           for i, iv := range v2 {
               fmt.Println(i, iv) 
           }
        default:
          fmt.Println(k, "is another type not handle yet")
      }
  }
}

JSON 流式读写

package main
import (
     "encoding/json"
     "log"
     "os"
  )


func main() {
    dec := json.NewDecoder(os.Stdin)
    enc := json.NewEncoder(os.Stdout)
  
    for {
       var v map[strint] interface{}
      
       if err := dec.Decode(&v); err != nil {
           log.Println(err)
           return
       }
      
       for k := range v {
           if k != "Title" {
              delete(v, k) 
           }
       }
      
       if err := enc.Encode(&v); err != nil {
           log.Println(err) 
       }
    }
  
}