golang：处理JSON编码

忘是亡心i 2022-02-23 01:26 264阅读 0赞

### 文章目录 ###

*  JSON
 *  数据结构map
 *  基本结构编码
 *  map编码
 *  嵌套编码
 *  StructTag 字段重名
 *  \-忽略字段
 *  omitempty可选字段
 *  string选项

# JSON #

http的交互的生命周期包含请求和响应。前面我们介绍了很多关于发起请求，处理请求的内容，现在该聊一聊返回响应内容了。对于web服务的响应。对于web服务的响应，以前常见的响应是返回服务端渲染的模板。浏览器只要展示模板即可。随着Restful风格的api出现，已经前后端分离，更多的返回格式是json字串。本节我们将讨论在golang中如何编码和解码json。  
JSON是一种数据格式描述语言。以key和value构成的哈系结构，类似javascript中的对象，python中的字典。通常json格式的key是字串，其值可以是任意类型，字串，数字，数组或者对象结构

# 数据结构map #

json源于javascript的对象结构，golang中直接对应的数据结构，可是golang的map也是key-value结构，同时struct结构体也可以描述json。当然，对于json的数据类型，go也会有对象的结构所匹配。大致对应关系如下：

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>JSON</th> 
   <th>Golang</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字串</td> 
   <td>string</td> 
   <td>string</td> 
  </tr> 
  <tr> 
   <td>整数</td> 
   <td>number</td> 
   <td>int64</td> 
  </tr> 
  <tr> 
   <td>浮点数</td> 
   <td>number</td> 
   <td>flaot64</td> 
  </tr> 
  <tr> 
   <td>数组</td> 
   <td>arrary</td> 
   <td>slice</td> 
  </tr> 
  <tr> 
   <td>对象</td> 
   <td>object</td> 
   <td>struct</td> 
  </tr> 
  <tr> 
   <td>布尔</td> 
   <td>bool</td> 
   <td>bool</td> 
  </tr> 
  <tr> 
   <td>空值</td> 
   <td>null</td> 
   <td>nil</td> 
  </tr> 
 </tbody> 
</table>

# 基本结构编码 #

golang提供了encoding/json的标准库用于编码json。大致需要两步：

*  首先定义json结构体。
 *  使用 Marshal方法序列化。

定义结构体的时候，只有字段名是大写的，才会被编码到json当中。

type Account struct {
        
        Email string
        password string
        Money float64
    }
    
    func main() {
        
        account := Account{
        
            Email: "rsj217@gmail.com",
            password: "123456",
            Money: 100.5,
        }
    
        rs, err := json.Marshal(account)
        if err != nil{
        
            log.Fatalln(err)
        }
    
        fmt.Println(rs)
        fmt.Println(string(rs))
    }

可以看到输出如下，Marshal方法接受一个空接口的参数，返回一个\[\]byte结构。小写命名的password字段没有被编码到json当中，生成的json结构字段和Account结构一致。

[123 34 69 109 97 105 108 34 58 34 114 115 106 50 49 55 64 103 109 97 105 108 46 99 111 109 34 44 34 77 111 110 101 121 34 58 49 48 48 46 53 125]
    {
        "Email":"rsj217@gmail.com","Money":100.5}

# map编码 #

func main() {
        
    	skill := make(map[string]interface{
        })
    	skill["id"] = 1
    	skill["name"] = "name"
    	skill["friends"] = []string{
        "ploat", "maroan"}
    	skill["hunhe"] = []interface{
        }{
        0, "a", []int{
        1, 2, 3}}
    
    	rs, err := json.Marshal(skill)
    	if err != nil{
        
    		fmt.Println(err)
    	}
    
    	fmt.Println(string(rs))  //{"friends":["ploat","maroan"],"hunhe":[0,"a",[1,2,3]],"id":1,"name":"name"}
    
    	skill1 := make(map[int]interface{
        })
    	skill1[1] = 1
    	skill1[2] = "name"
    	skill1[3] = []string{
        "ploat", "maroan"}
    	skill1[4] = []interface{
        }{
        0, "a", []int{
        1, 2, 3}}
    
    	rs, err = json.Marshal(skill1)
    	if err != nil{
        
    		fmt.Println(err)
    	}
       //{"1":1,"2":"name","3":["ploat","maroan"],"4":[0,"a",[1,2,3]]}
    	fmt.Println(string(rs))
    }

输出

{
        "friends":[
    	"ploat",
    	"maroan"
    	],
    	"hunhe":[0,"a",[1,2,3]],"id":1,"name":"name"}

备注：原文好像有点问题，修改了:map的key必须是字符串，如果不是字符串会将他转成字符串。  
map的值可以是任意类型

# 嵌套编码 #

type User struct {
        
        Name    string
        Age     int
        Roles   []string
        Skill   map[string]float64
    }
    
    func main() {
        
    
        skill := make(map[string]float64)
    
        skill["python"] = 99.5
        skill["elixir"] = 90
        skill["ruby"] = 80.0
    
        user := User{
        
            Name:"rsj217",
            Age: 27,
            Roles: []string{
        "Owner", "Master"},
            Skill: skill,
        }
    
        rs, err := json.Marshal(user)
        if err != nil{
        
            log.Fatalln(err)
        }
        fmt.Println(string(rs))
    }

输入

{
        
        "Name":"rsj217",
        "Age":27,
        "Roles":[
            "Owner",
            "Master"
        ],
        "Skill":{
        
            "elixir":90,
            "python":99.5,
            "ruby":80
        }
    }

也可以在结构体中嵌套结构体，数组，map等：

package main
    
    import (
    	"fmt"
    	"gopkg.in/gin-gonic/gin.v1/json"
    	"log"
    )
    
    type Account struct {
        
    	Email string
    	password string
    	Money float64
    }
    
    type User struct {
        
    	Name    string
    	Age     int
    	Roles   []string
    	Skill   map[string]float64
    	Account Account
    	Extra []interface{
        }
    }
    func main() {
        
    
    	skill := make(map[string]float64)
    
    	skill["python"] = 99.5
    	skill["elixir"] = 90
    	skill["ruby"] = 80.0
    
    	account := Account{
        
    		Email: "rsj217@gmail.com",
    		password: "123456",
    		Money: 100.5,
    	}
    
    	extra := []interface{
        }{
        123, "hello world"}
    
    
    	user := User{
        
    		Name:"rsj217",
    		Age: 27,
    		Roles: []string{
        "Owner", "Master"},
    		Skill: skill,
    		Account:account,
    		Extra:extra,
    	}
    	rs, err := json.Marshal(user)
    	if err != nil{
        
    		log.Fatalln(err)
    	}
    	fmt.Println(string(rs))
    }

输出

{
        
        "Name":"rsj217",
        "Age":27,
        "Roles":[
            "Owner",
            "Master"
        ],
        "Skill":{
        
            "elixir":90,
            "python":99.5,
            "ruby":80
        },
        "Account":{
        
            "Email":"rsj217@gmail.com",
            "Money":100.5
        }
        。。。
    }

# StructTag 字段重名 #

在定义结构的时候，只有使用大写字母开头的字段才会被导出。而通常json世界中，更盛行小写字母的方式。看起来就成了一个矛盾。其实不然，golang提供了struct tag的方式可以重命名结构字段的输出形式。

package main
    
    import (
    	"fmt"
    	"gopkg.in/gin-gonic/gin.v1/json"
    	"log"
    )
    
    type Account struct {
        
    	Email string `json:"email"`
    	Password  string `json:"pass_word"`
    	Money     float64 `json:"money"`
    }
    func main() {
        
    	account := Account{
        
    		Email:    "rsj217@gmail.com",
    		Password: "123456",
    		Money:    100.5,
    	}
    	
    	rs, err := json.Marshal(account)
    	if err != nil{
        
    		log.Fatalln(err)
    	}
    	
    	fmt.Println(string(rs))
    
    }

我们使用struct tag，重新给Aaccount结构的字段进行了重命名。其中email小写了，并且password字段还使用了下划线，输出的结果如下：

{
        "email":"rsj217@gmail.com","pass_word":"123456","money":100.5}

# \-忽略字段 #

有问题

# omitempty可选字段 #

对于另外一种字段，当其有值的时候就输出，而没有值(零值)的时候就不输出，则可以使用另外一种选项omitempty。

package main
    
    import (
    	"fmt"
    	"gopkg.in/gin-gonic/gin.v1/json"
    	"log"
    )
    
    type Account struct {
        
    	Email    string  `json:"email"`
    	Password string  `json:"password,omitempty"`
    	Money    float64 `json:"money"`
    }
    
    func main() {
        
    	account := Account{
        
    		Email:    "rsj217@gmail.com",
    		Password: "",
    		Money:    100.5,
    	}
    
    	rs, err := json.Marshal(account)
    	if err != nil{
        
    		log.Fatalln(err)
    	}
    
    	fmt.Println(string(rs))
    
    }

此时password不会被编码到json输出中。

# string选项 #

gplang是静态类型语言，对于类型定义的是不能动态修改。在json处理当中，struct tag的string可以起到部分动态类型的效果。有时候输出的json希望是数字的字符串，而定义的字段是数字类型，那么就可以使用string选项。

package main
    
    import (
    	"fmt"
    	"gopkg.in/gin-gonic/gin.v1/json"
    	"log"
    )
    
    type Account struct {
        
    	Email    string  `json:"email"`
    	Password string  `json:"password,omitempty"`
    	Money    float64 `json:"money,string"`
    }
    
    func main() {
        
    	account := Account{
        
    		Email:    "rsj217@gmail.com",
    		Password: "",
    		Money:    100.5,   //{"email":"rsj217@gmail.com","money":"100.5"}
    	}
    
    	rs, err := json.Marshal(account)
    	if err != nil{
        
    		log.Fatalln(err)
    	}
    
    	fmt.Println(string(rs))
    
    }

[原文地址][Link 1] —》原文博主的博客值得研究

[Link 1]: https://www.jianshu.com/p/f3c2105bd06b