Browse Source

Format and remove 07.2.md spaces

vCaesar 1 year ago
parent
commit
f250d5b806
1 changed files with 112 additions and 112 deletions
  1. 112 112
      zh/07.2.md

+ 112 - 112
zh/07.2.md

@@ -4,7 +4,7 @@ JSON(Javascript Object Notation)是一种轻量级的数据交换语言,
4 4
 前一小节的运维的例子用json来表示,结果描述如下:
5 5
 ```json
6 6
 
7
-	{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}
7
+{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}
8 8
 ```
9 9
 本小节余下的内容将以此JSON数据为基础,来介绍go语言的json包对JSON数据的编、解码。
10 10
 ## 解析JSON
@@ -13,33 +13,33 @@ JSON(Javascript Object Notation)是一种轻量级的数据交换语言,
13 13
 假如有了上面的JSON串,那么我们如何来解析这个JSON串呢?Go的JSON包中有如下函数
14 14
 ```Go
15 15
 
16
-	func Unmarshal(data []byte, v interface{}) error
16
+func Unmarshal(data []byte, v interface{}) error
17 17
 ```
18 18
 通过这个函数我们就可以实现解析的目的,详细的解析例子请看如下代码:
19 19
 ```Go
20 20
 
21
-	package main
21
+package main
22 22
 
23
-	import (
24
-		"encoding/json"
25
-		"fmt"
26
-	)
23
+import (
24
+	"encoding/json"
25
+	"fmt"
26
+)
27 27
 
28
-	type Server struct {
29
-		ServerName string
30
-		ServerIP   string
31
-	}
28
+type Server struct {
29
+	ServerName string
30
+	ServerIP   string
31
+}
32 32
 
33
-	type Serverslice struct {
34
-		Servers []Server
35
-	}
33
+type Serverslice struct {
34
+	Servers []Server
35
+}
36 36
 
37
-	func main() {
38
-		var s Serverslice
39
-		str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`
40
-		json.Unmarshal([]byte(str), &s)
41
-		fmt.Println(s)
42
-	}
37
+func main() {
38
+	var s Serverslice
39
+	str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`
40
+	json.Unmarshal([]byte(str), &s)
41
+	fmt.Println(s)
42
+}
43 43
 ```
44 44
 在上面的示例代码中,我们首先定义了与json数据对应的结构体,数组对应slice,字段名对应JSON里面的KEY,在解析的时候,如何将json数据与struct字段相匹配呢?例如JSON的key是`Foo`,那么怎么找对应的字段呢?
45 45
 
@@ -62,71 +62,71 @@ JSON(Javascript Object Notation)是一种轻量级的数据交换语言,
62 62
 现在我们假设有如下的JSON数据
63 63
 ```Go
64 64
 
65
-	b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
65
+b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
66 66
 ```
67 67
 如果在我们不知道他的结构的情况下,我们把他解析到interface{}里面
68 68
 ```Go
69 69
 
70
-	var f interface{}
71
-	err := json.Unmarshal(b, &f)
70
+var f interface{}
71
+err := json.Unmarshal(b, &f)
72 72
 ```
73 73
 这个时候f里面存储了一个map类型,他们的key是string,值存储在空的interface{}里
74 74
 ```Go
75 75
 
76
-	f = map[string]interface{}{
77
-		"Name": "Wednesday",
78
-		"Age":  6,
79
-		"Parents": []interface{}{
80
-			"Gomez",
81
-			"Morticia",
82
-		},
83
-	}
76
+f = map[string]interface{}{
77
+	"Name": "Wednesday",
78
+	"Age":  6,
79
+	"Parents": []interface{}{
80
+		"Gomez",
81
+		"Morticia",
82
+	},
83
+}
84 84
 ```
85 85
 那么如何来访问这些数据呢?通过断言的方式:
86 86
 ```Go
87 87
 
88
-	m := f.(map[string]interface{})
88
+m := f.(map[string]interface{})
89 89
 ```
90 90
 通过断言之后,你就可以通过如下方式来访问里面的数据了
91 91
 ```Go
92 92
 
93
-	for k, v := range m {
94
-		switch vv := v.(type) {
95
-		case string:
96
-			fmt.Println(k, "is string", vv)
97
-		case int:
98
-			fmt.Println(k, "is int", vv)
99
-		case float64:
100
-			fmt.Println(k,"is float64",vv)
101
-		case []interface{}:
102
-			fmt.Println(k, "is an array:")
103
-			for i, u := range vv {
104
-				fmt.Println(i, u)
105
-			}
106
-		default:
107
-			fmt.Println(k, "is of a type I don't know how to handle")
93
+for k, v := range m {
94
+	switch vv := v.(type) {
95
+	case string:
96
+		fmt.Println(k, "is string", vv)
97
+	case int:
98
+		fmt.Println(k, "is int", vv)
99
+	case float64:
100
+		fmt.Println(k,"is float64",vv)
101
+	case []interface{}:
102
+		fmt.Println(k, "is an array:")
103
+		for i, u := range vv {
104
+			fmt.Println(i, u)
108 105
 		}
106
+	default:
107
+		fmt.Println(k, "is of a type I don't know how to handle")
109 108
 	}
109
+}
110 110
 ```	
111 111
 通过上面的示例可以看到,通过interface{}与type assert的配合,我们就可以解析未知结构的JSON数了。
112 112
 
113 113
 上面这个是官方提供的解决方案,其实很多时候我们通过类型断言,操作起来不是很方便,目前bitly公司开源了一个叫做`simplejson`的包,在处理未知结构体的JSON时相当方便,详细例子如下所示:
114 114
 ```Go
115 115
 
116
-	js, err := NewJson([]byte(`{
117
-		"test": {
118
-			"array": [1, "2", 3],
119
-			"int": 10,
120
-			"float": 5.150,
121
-			"bignum": 9223372036854775807,
122
-			"string": "simplejson",
123
-			"bool": true
124
-		}
125
-	}`))
116
+js, err := NewJson([]byte(`{
117
+	"test": {
118
+		"array": [1, "2", 3],
119
+		"int": 10,
120
+		"float": 5.150,
121
+		"bignum": 9223372036854775807,
122
+		"string": "simplejson",
123
+		"bool": true
124
+	}
125
+}`))
126 126
 
127
-	arr, _ := js.Get("test").Get("array").Array()
128
-	i, _ := js.Get("test").Get("int").Int()
129
-	ms := js.Get("test").Get("string").MustString()
127
+arr, _ := js.Get("test").Get("array").Array()
128
+i, _ := js.Get("test").Get("int").Int()
129
+ms := js.Get("test").Get("string").MustString()
130 130
 
131 131
 ```
132 132
 可以看到,使用这个库操作JSON比起官方包来说,简单的多,详细的请参考如下地址:https://github.com/bitly/go-simplejson
@@ -135,55 +135,55 @@ JSON(Javascript Object Notation)是一种轻量级的数据交换语言,
135 135
 我们开发很多应用的时候,最后都是要输出JSON数据串,那么如何来处理呢?JSON包里面通过`Marshal`函数来处理,函数定义如下:
136 136
 ```Go
137 137
 
138
-	func Marshal(v interface{}) ([]byte, error)
138
+func Marshal(v interface{}) ([]byte, error)
139 139
 ```
140 140
 假设我们还是需要生成上面的服务器列表信息,那么如何来处理呢?请看下面的例子:
141 141
 ```Go
142 142
 
143
-	package main
144
-
145
-	import (
146
-		"encoding/json"
147
-		"fmt"
148
-	)
149
-
150
-	type Server struct {
151
-		ServerName string
152
-		ServerIP   string
153
-	}
154
-
155
-	type Serverslice struct {
156
-		Servers []Server
157
-	}
158
-
159
-	func main() {
160
-		var s Serverslice
161
-		s.Servers = append(s.Servers, Server{ServerName: "Shanghai_VPN", ServerIP: "127.0.0.1"})
162
-		s.Servers = append(s.Servers, Server{ServerName: "Beijing_VPN", ServerIP: "127.0.0.2"})
163
-		b, err := json.Marshal(s)
164
-		if err != nil {
165
-			fmt.Println("json err:", err)
166
-		}
167
-		fmt.Println(string(b))
143
+package main
144
+
145
+import (
146
+	"encoding/json"
147
+	"fmt"
148
+)
149
+
150
+type Server struct {
151
+	ServerName string
152
+	ServerIP   string
153
+}
154
+
155
+type Serverslice struct {
156
+	Servers []Server
157
+}
158
+
159
+func main() {
160
+	var s Serverslice
161
+	s.Servers = append(s.Servers, Server{ServerName: "Shanghai_VPN", ServerIP: "127.0.0.1"})
162
+	s.Servers = append(s.Servers, Server{ServerName: "Beijing_VPN", ServerIP: "127.0.0.2"})
163
+	b, err := json.Marshal(s)
164
+	if err != nil {
165
+		fmt.Println("json err:", err)
168 166
 	}
167
+	fmt.Println(string(b))
168
+}
169 169
 
170 170
 ```
171 171
 输出如下内容:
172 172
 ```json
173 173
 
174
-	{"Servers":[{"ServerName":"Shanghai_VPN","ServerIP":"127.0.0.1"},{"ServerName":"Beijing_VPN","ServerIP":"127.0.0.2"}]}
174
+{"Servers":[{"ServerName":"Shanghai_VPN","ServerIP":"127.0.0.1"},{"ServerName":"Beijing_VPN","ServerIP":"127.0.0.2"}]}
175 175
 ```
176 176
 我们看到上面的输出字段名的首字母都是大写的,如果你想用小写的首字母怎么办呢?把结构体的字段名改成首字母小写的?JSON输出的时候必须注意,只有导出的字段才会被输出,如果修改字段名,那么就会发现什么都不会输出,所以必须通过struct tag定义来实现:
177 177
 ```Go
178 178
 
179
-	type Server struct {
180
-		ServerName string `json:"serverName"`
181
-		ServerIP   string `json:"serverIP"`
182
-	}
179
+type Server struct {
180
+	ServerName string `json:"serverName"`
181
+	ServerIP   string `json:"serverIP"`
182
+}
183 183
 
184
-	type Serverslice struct {
185
-		Servers []Server `json:"servers"`
186
-	}
184
+type Serverslice struct {
185
+	Servers []Server `json:"servers"`
186
+}
187 187
 ```
188 188
 通过修改上面的结构体定义,输出的JSON串就和我们最开始定义的JSON串保持一致了。
189 189
 
@@ -198,32 +198,32 @@ JSON(Javascript Object Notation)是一种轻量级的数据交换语言,
198 198
 举例来说:
199 199
 ```Go
200 200
 
201
-	type Server struct {
202
-		// ID 不会导出到JSON中
203
-		ID int `json:"-"`
201
+type Server struct {
202
+	// ID 不会导出到JSON中
203
+	ID int `json:"-"`
204 204
 
205
-		// ServerName2 的值会进行二次JSON编码
206
-		ServerName  string `json:"serverName"`
207
-		ServerName2 string `json:"serverName2,string"`
205
+	// ServerName2 的值会进行二次JSON编码
206
+	ServerName  string `json:"serverName"`
207
+	ServerName2 string `json:"serverName2,string"`
208 208
 
209
-		// 如果 ServerIP 为空,则不输出到JSON串中
210
-		ServerIP   string `json:"serverIP,omitempty"`
211
-	}
209
+	// 如果 ServerIP 为空,则不输出到JSON串中
210
+	ServerIP   string `json:"serverIP,omitempty"`
211
+}
212 212
 
213
-	s := Server {
214
-		ID:         3,
215
-		ServerName:  `Go "1.0" `,
216
-		ServerName2: `Go "1.0" `,
217
-		ServerIP:   ``,
218
-	}
219
-	b, _ := json.Marshal(s)
220
-	os.Stdout.Write(b)
213
+s := Server {
214
+	ID:         3,
215
+	ServerName:  `Go "1.0" `,
216
+	ServerName2: `Go "1.0" `,
217
+	ServerIP:   ``,
218
+}
219
+b, _ := json.Marshal(s)
220
+os.Stdout.Write(b)
221 221
 
222 222
 ```
223 223
 会输出以下内容:
224 224
 ```json
225 225
 
226
-	{"serverName":"Go \"1.0\" ","serverName2":"\"Go \\\"1.0\\\" \""}
226
+{"serverName":"Go \"1.0\" ","serverName2":"\"Go \\\"1.0\\\" \""}
227 227
 
228 228
 ```
229 229
 Marshal函数只有在转换成功的时候才会返回数据,在转换的过程中我们需要注意几点: