golang-Json編碼解碼

時間 2019-12-10

標籤 golang json 編碼解碼欄目 Go 简体版

原文原文鏈接

目錄html

在線工具：https://www.json.cnpython

一. 類型映射

golang和json的數據類型不一致，在編碼或解碼的過程當中必然須要作類型映射。

1.從golang到json：golang

golang	json
bool	Boolean
int、float等數字	Number
string	String
[]byte(base64編碼)	String
struct	Object，再遞歸打包
array/slice	Array
map	Object
interface{}	按實際類型轉換
nil	null
channel,func	UnsupportedTypeError

2.從json到golang：json

json	golang
Boolean	bool
Number	float64
String	string
Array	[]interface{}
Object	map[string]interface{}
null	nil

二. 輸出控制

第一個標籤爲別名,後面控制標籤可疊加。
編碼或解碼的中間數據狀態爲字節數組。

type User struct {
   Name string `json:"user_name"` //修改別名
   Age uint8 `json:",string"` //修改類型
   Addr string `json:"-"` //忽略字段
   Vip bool `json:",omitempty"` //排除缺省值
   Asset int64 `json:"amount,string,omitempty"` //標籤疊加
   Skill []string `json:"skill"` //複雜類型
}

func main() {
   obj :=User{Name:"tom",Age:18,Addr:"BJ",Vip:false,Asset:888,Skill:[]string{"golang","python"}}
   bts, _ := json.MarshalIndent(obj,"","\t") //縮進
   fmt.Println(string(bts))
}

三. 類型編碼

1.結構體/結構體指針： 映射爲Object數組

func main() {
   obj := struct {A string;B int64}{"a", 1}
   bts, _ := json.Marshal(obj) //結構體
   fmt.Println(string(bts))

   ptr := &obj //結構體指針
   bts, _ = json.Marshal(ptr)
   fmt.Println(string(bts))
}

2.數組/切片： 映射爲Array函數

func main() {
   arr := []string{"a","b","c"}
   bts, _ := json.Marshal(arr) 
   fmt.Println(string(bts))
}

3.字典： 映射爲Object工具

func main() {
   mp := map[int]string{1:"a",2:"b",3:"c"}
   bts, _ := json.Marshal(mp)
   fmt.Println(string(bts))
}

四. 類型解碼

1.對象解碼ui

func main() {
   str := `{"A":"a","B":1}`
   obj := new(struct {A string;B int64})
   _ = json.Unmarshal([]byte(str), &obj )
   fmt.Println(obj)
}

2.數組解碼編碼

func main() {
   arr := `["a","b","c"]`

   slise:=make([]string,0)
   _ = json.Unmarshal([]byte(arr),&slise)
   fmt.Println(slise)
}

3.字典解碼.net

func main() {
   str := `{"1":"a","2":"b","3":"c"}`

   mp := make(map[int]string)
   _ = json.Unmarshal([]byte(str), &mp)
   fmt.Println(mp)
}

五. 輸出重寫

Marshal函數將會遞歸遍歷整個對象，並根據類型數據的MarshalJSON方法打印輸出格式。

//自定義的Json時間格式
type Jtime time.Time

//實現了encoding/json/encode.go的Marshaler接口
func (p Jtime) MarshalJSON() ([]byte, error) {
   var stamp = fmt.Sprintf("%d", time.Time(p).Unix())
   //var stamp = fmt.Sprintf("\"%s\"", time.Time(p).Format("2006-01-02 15:04:05"))
   return []byte(stamp), nil
}

func main() {
   obj := struct {
      Name string `json:"nick_name"`
      Date Jtime `json:"create_at"`
   }{"Jack", Jtime(time.Date(2018, 1, 1, 00, 00, 00, 00, time.Local))}

   //編碼
   bts, _ := json.MarshalIndent(obj, "", "\t")
   fmt.Println(string(bts))

   //解碼
   _ = json.Unmarshal(bts, obj)
   fmt.Printf("%s %q", obj.Name, time.Time(obj.Date))
}

六. 擴展功能

1. Json格式驗證：json.Valid()

func main() {
   str := `{"nick_name":"Lucy","user_age":28}` //Object
   str = `["a","b"]` //Array
   ok := json.Valid([]byte(str))
   fmt.Println(ok)
}

2. 自定義編碼器:json.NewEncoder()

func main() {
   obj := struct {
      Name string `json:"nick_name"`
      Age uint `json:"user_age"`
   }{"Lucy", 28}

   outer, _ := os.Create("json.txt") //文件輸出
   outer = os.Stdout //標準輸出
   encoder := json.NewEncoder(outer)
   encoder.SetIndent("", "\t")
   encoder.Encode(obj)
}

3. 縮進處理:json.Indent(),對已編碼對字節數組進行縮進

func main() {
   obj := struct {Name string;Age uint}{"Lucy", 28}
   bts, _ := json.Marshal(obj)
   
   var buf bytes.Buffer
   _=json.Indent(&buf,bts,"","\t")
   buf.WriteTo(os.Stdout)
}

4. Json字符串壓縮:json.Compact()

func main() {
   str := `
{
   "nick_name": "Lucy",
   "user_age": 28
}`

   var buf bytes.Buffer
   _ = json.Compact(&buf, []byte(str)) //壓縮
   buf.WriteTo(os.Stdout)
}

5. Html編碼處理:json.HTMLEscape()

func main() {
   str := `{"content": "<a src=\"http://www.xxx.com\">Link</a>"}`
   var buf bytes.Buffer
   json.HTMLEscape(&buf, []byte(str)) 
   buf.WriteTo(os.Stdout)
}

6. 二次解碼：json.RawMessage,根據json數據包的某個標識，分別解碼成不一樣類型的對象。

type Student struct {
   Sno string //學號
   Name string //姓名
   Major string //專業
}

type Teacher struct {
   Name string //姓名
   Subject string //學科
}

// 任何對象都能裝的數據容器，具體類型根據Type字段區分
type JsonObject struct {
   Type int //對象類型
   Obj interface{} //對象數據
}

func main() {
   user := `{"Type":1,"Obj":{"Sno":"S001","Name":"Tom","Major":"computer"}}` //Student
   user = `{"Type":2,"Obj":{"Name":"Bob","Subject":"quantum mechanics"}}` //Teacher

   var obj json.RawMessage
   pkg := JsonObject{Obj: &obj}

   //第一次解碼: 先解碼外部包裝數據對象，獲取類型依據
   if err := json.Unmarshal([]byte(user), &pkg); err != nil {
      panic(err)
   }

   //第二次解碼: 根據第一次的解碼結果,再次對內部對象Obj進行解碼
   switch pkg.Type {
   case 1:
      var stu = Student{}
      _ = json.Unmarshal(obj, &stu)
      fmt.Println(stu)
   case 2:
      var tch = Teacher{}
      _ = json.Unmarshal(obj, &tch)
      fmt.Println(tch)
   }
}

七. Bson編碼

Bson基於json格式，是mongoDB的數據存儲格式。
1.速度快：json以字符串形式存儲，須要文件掃描，結構匹配。bson是按結構存儲，能夠精準定位，高效讀寫。
2.操做簡單：json無數據類型，是基於字符的操做，面臨很大的操做開銷。bson能夠指定數據類型。
3.字節數組：二進制的存儲再也不須要先base64轉換後再存成json，大大減小了計算開銷和數據大小。

import "gopkg.in/mgo.v2/bson"
type Person struct {
   Name string `bson:"nick_name"`
   Age int32 `bson:"-"`
   Phone string `bson:",omitempty"`
}
func main() {
   p := &Person{"Bob", 18, ""}

   bytes, _ := bson.Marshal(p) //Bson編碼
   fmt.Printf("%q\n", bytes)

   um := &Person{}
   bson.Unmarshal(bytes, &um) //strust解碼
   fmt.Println(um)

   mp := bson.M{}
   bson.Unmarshal(bytes, mp) //map解碼
   fmt.Println(mp)
}

參考：
http://www.cnblogs.com/chuanheng/p/go_bson_struct.html
http://blog.csdn.net/tiaotiaoyly/article/details/38942311
https://studygolang.com/articles/2552
http://labix.org/gobson
http://blog.csdn.net/hengyunabc/article/details/6897540
https://godoc.org/gopkg.in/mgo.v2/bson