Golang 处理 Json（一）：编码

标签：script   情况   对象   python   序列化   复合   浮点   bsp   编码   

JSON 是一种数据格式描述语言。以 key 和 value 构成的哈系结构，类似 Javascript 中的对象，python 中的字典。通常 json 格式的 key 是字符串，其值可以是任意类型，字串，数字，数组或者对象结构。更多关于 Json 的可以访问 JSON 了解。

数据结构 map

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

JSON 编码

基本结构编码

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

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

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

type Account struct {
    Email string
    password string
    Money float64
}

func main() {
    account := Account{
        Email: "phpgo@163.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":"phpgo@163.com","Money":100.5}

复合结构编码

相比字串，数字等基本数据结构，slice 切片，map 字典则是复合结构。这些结构编码也类似。不过 map 的 key 必须是字符串，而 value 必须是同一类型的数据。

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
    }
}

嵌套编码

slice 和 map 可以匹配 json 的数组和对象，当然，前提是对象的 value 是同类型的情况。更通用的做法，对象的 key 可以是 string，但是其值可以是多种结构。golang 可以通过定义结构体来实现这种构造：

type User struct {
	Name    string
	Age     int
	Roles   []string
	Skill   map[string]float64
	Account Account
}

type Account struct {
	Email string
	Money float64
}

func main() {
	skill := map[string]float64{
		"elixir":90,
        "python":99.5,
        "ruby":80,
	}
	account := Account{
		Email: "phpgo@163.com",
		Money: 102.3,
	}

	user := User{
		Name:    "wenjianbao",
		Age:     30,
		Roles:   []string{"Owner", "Master"},
		Skill:   skill,
		Account: account,
	}

	js, err := json.Marshal(user)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(js))
}

输出：

{
    "Name":"wenjianbao",
    "Age":30,
    "Roles":[
        "Owner",
        "Master"
    ],
    "Skill":{
        "elixir":90,
        "python":99.5,
        "ruby":80
    },
    "Account":{
        "Email":"phpgo@163.com",
        "Money":102.3
    }
}

通过定义嵌套的结构体 Account，实现了 key 与 value 不一样的结构。golang 的数组或切片，其类型也是一样的，如果遇到不同数据类型的数组，则需要借助空结构来实现：

type User struct {
	Name    string
	Age     int
	Roles   []string
	Skill   map[string]float64
	Account Account
	Extra   []interface{}
}

type Account struct {
	Email string
	Money float64
}

func main() {
	skill := map[string]float64{
		"elixir": 90,
		"python": 99.5,
		"ruby":   80,
	}
	account := Account{
		Email: "phpgo@163.com",
		Money: 102.3,
	}
	extra := []interface{}{123, "Hello World"}

	user := User{
		Name:    "wenjianbao",
		Age:     30,
		Roles:   []string{"Owner", "Master"},
		Skill:   skill,
		Account: account,
		Extra:   extra,
	}

	js, err := json.Marshal(user)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(js))
}

输出：

{
    "Name":"wenjianbao",
    "Age":30,
    "Roles":[
        "Owner",
        "Master"
    ],
    "Skill":{
        "elixir":90,
        "python":99.5,
        "ruby":80
    },
    "Account":{
        "Email":"phpgo@163.com",
        "Money":102.3
    },
    "Extra":[
        123,
        "Hello World"
    ]
}

使用空接口，也可以定义像结构体实现那种不同 value 类型的字典结构。当空接口没有初始化其值的时候，零值是 nil。编码成 json 就是 null

type User struct {
	Name    string
	Age     int
	Roles   []string
	Skill   map[string]float64
	Account Account

	Extra []interface{}
	Level map[string]interface{}
}

type Account struct {
	Email string
	Money float64
}

func main() {
	skill := map[string]float64{
		"elixir": 90,
		"python": 99.5,
		"ruby":   80,
	}
	account := Account{
		Email: "phpgo@163.com",
		Money: 102.3,
	}

	level := make(map[string]interface{})
	level["web"] = "Good"
	level["server"] = 90
	level["tool"] = nil

	user := User{
		Name:    "wenjianbao",
		Age:     30,
		Roles:   []string{"Owner", "Master"},
		Skill:   skill,
		Account: account,
		Level:   level,
	}

	js, err := json.Marshal(user)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(js))
}

输出：

{
    "Name":"wenjianbao",
    "Age":30,
    "Roles":[
        "Owner",
        "Master"
    ],
    "Skill":{
        "elixir":90,
        "python":99.5,
        "ruby":80
    },
    "Account":{
        "Email":"phpgo@163.com",
        "Money":102.3
    },
    "Extra":null,
    "Level":{
        "server":90,
        "tool":null,
        "web":"Good"
    }
}

可以看到 Extra返回的并不是一个空的切片，而是null。同时Level字段实现了向字典的嵌套结构。

Golang 处理 Json（一）：编码

标签：script   情况   对象   python   序列化   复合   浮点   bsp   编码   

原文地址：http://www.cnblogs.com/phpgo/p/6512581.html