mirror of
https://github.com/unknwon/the-way-to-go_ZH_CN.git
synced 2025-08-11 23:08:34 +08:00
无闻
@@ -1,5 +1,5 @@
|
||||
# XML数据格式
|
||||
下面是与12.9节json例子等价的XML版本：
|
||||
# XML 数据格式
|
||||
下面是与 12.9 节 JSON 例子等价的 XML 版本：
|
||||
```xml
|
||||
<Person>
|
||||
<FirstName>Laura</FirstName>
|
||||
@@ -7,11 +7,11 @@
|
||||
</Person>
|
||||
```
|
||||
|
||||
如同json包中`Marshal()`和`UnMarshal()`函数一样，从XML中编码和解码数据；但这个更通用，可以从文件中读取和写入(或者任何实现了io.Reader和io.Writer接口的类型)
|
||||
如同 json 包一样，也有 `Marshal()` 和 `UnMarshal()` 从 XML 中编码和解码数据；但这个更通用，可以从文件中读取和写入（或者任何实现了 io.Reader 和 io.Writer 接口的类型）
|
||||
|
||||
和json的方式一样，xml数据可以序列化为结构，或者从结构反序列化为xml数据；这些可以在例子15.8(twitter_status.go)中看到。
|
||||
和 JSON 的方式一样，XML 数据可以序列化为结构，或者从结构反序列化为 XML 数据；这些可以在例子 15.8（twitter_status.go）中看到。
|
||||
|
||||
encoding/xml包实现了一个简单的xml解析器(SAX)，用来解析XML数据内容。下面的例子说明如何使用解析器：
|
||||
encoding/xml 包实现了一个简单的 XML 解析器（SAX），用来解析 XML 数据内容。下面的例子说明如何使用解析器：
|
||||
|
||||
示例 12.17 [xml.go](examples/chapter_12/xml.go)：
|
||||
|
||||
@@ -68,14 +68,14 @@ End of token
|
||||
*/
|
||||
|
||||
```
|
||||
包中定义了若干XML标签类型：StartElement,Chardata(这是从开始标签到结束标签之间的实际文本)，EndElement，Comment，Directive 或 ProcInst.
|
||||
包中定义了若干 XML 标签类型：StartElement，Chardata（这是从开始标签到结束标签之间的实际文本），EndElement，Comment，Directive 或 ProcInst。
|
||||
|
||||
包中同样定义了一个结构解析器：`NewParser`方法持有一个io.Reader(这里具体类型是strings.NewReader)并生成一个解析器类型的对象。还有一个`Token()`方法返回输入流里的下一个XML token。在输入流的结尾处，会返回(nil, io.EOF)
|
||||
包中同样定义了一个结构解析器：`NewParser` 方法持有一个 io.Reader（这里具体类型是 strings.NewReader）并生成一个解析器类型的对象。还有一个 `Token()` 方法返回输入流里的下一个 XML token。在输入流的结尾处，会返回（nil，io.EOF）
|
||||
|
||||
XML文本被循环处理直到`Token()`返回一个错误，因为已经到达文件尾部，再没有内容可供处理了。通过一个type-switch可以根据一些XML标签进一步处理。Chardata中的内容只是一个[]byte，通过字符串转换让其变得可读性强一些。
|
||||
XML 文本被循环处理直到 `Token()` 返回一个错误，因为已经到达文件尾部，再没有内容可供处理了。通过一个 type-switch 可以根据一些 XML 标签进一步处理。Chardata 中的内容只是一个 []byte，通过字符串转换让其变得可读性强一些。
|
||||
|
||||
## 链接
|
||||
|
||||
- [目录](directory.md)
|
||||
- 上一节：[Json数据格式](12.9.md)
|
||||
- 下一节：[XML数据格式](12.11.md)
|
||||
- 上一节：[Json 数据格式](12.9.md)
|
||||
- 下一节：[用 gob 传输数据](12.11.md)
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# 一个使用接口的实际例子:fmt.Fprintf
|
||||
# 一个使用接口的实际例子：fmt.Fprintf
|
||||
|
||||
例子程序`io_interfaces.go`很好的阐述了io包中的接口概念。
|
||||
例子程序 `io_interfaces.go` 很好的阐述了 io 包中的接口概念。
|
||||
|
||||
示例 12.15 [io_interfaces.go](examples/chapter_12/io_interfaces.go)：
|
||||
```go
|
||||
@@ -31,40 +31,40 @@ func main() {
|
||||
hello world! - unbuffered
|
||||
hello world! - buffered
|
||||
```
|
||||
下面是`fmt.Fprintf()`函数的实际签名
|
||||
下面是 `fmt.Fprintf()` 函数的实际签名
|
||||
|
||||
```go
|
||||
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
|
||||
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
|
||||
```
|
||||
其不是写入一个文件，而是写入一个`io.Writer`接口类型的变量，下面是`Writer`接口在io包中的定义：
|
||||
其不是写入一个文件，而是写入一个 `io.Writer` 接口类型的变量，下面是 `Writer` 接口在 io 包中的定义：
|
||||
|
||||
```go
|
||||
type Writer interface {
|
||||
Write(p []byte) (n int, err error)
|
||||
}
|
||||
type Writer interface {
|
||||
Write(p []byte) (n int, err error)
|
||||
}
|
||||
```
|
||||
`fmt.Fprintf()`依据指定的格式向第一个参数内写入字符串，第一参数必须实现了`io.Writer`接口。`Fprintf()`能够写入任何类型，只要其实现了`Write`方法，包括`os.Stdout`,文件（例如os.File）,管道，网络连接，通道等等，同样的也可以使用bufio包中缓冲写入。bufio包中定义了`type Writer struct{...}`
|
||||
`fmt.Fprintf()` 依据指定的格式向第一个参数内写入字符串，第一参数必须实现了 `io.Writer` 接口。`Fprintf()` 能够写入任何类型，只要其实现了 `Write` 方法，包括 `os.Stdout`,文件（例如 os.File），管道，网络连接，通道等等，同样的也可以使用 bufio 包中缓冲写入。bufio 包中定义了 `type Writer struct{...}`
|
||||
|
||||
bufio.Writer实现了Write方法：
|
||||
bufio.Writer 实现了 Write 方法：
|
||||
|
||||
```go
|
||||
func (b *Writer) Write(p []byte) (nn int, err error)
|
||||
func (b *Writer) Write(p []byte) (nn int, err error)
|
||||
```
|
||||
|
||||
它还有一个工厂函数：传给它一个`io.Writer`类型的参数，它会返回一个缓冲的`bufio.Writer`类型的`io.Writer`:
|
||||
它还有一个工厂函数：传给它一个 `io.Writer` 类型的参数，它会返回一个缓冲的 `bufio.Writer` 类型的 `io.Writer`:
|
||||
|
||||
```go
|
||||
func NewWriter(wr io.Writer) (b *Writer)
|
||||
func NewWriter(wr io.Writer) (b *Writer)
|
||||
```
|
||||
其适合任何形式的缓冲写入。
|
||||
|
||||
在缓冲写入的最后千万不要忘了使用`Flush()`，否则最后的输出不会被写入。
|
||||
在缓冲写入的最后千万不要忘了使用 `Flush()`，否则最后的输出不会被写入。
|
||||
|
||||
在15.2-15.8章节，我们将使用`fmt.Fprint`函数向`http.ResponseWriter`写入，其同样实现了io.Writer接口。
|
||||
在 15.2-15.8 章节，我们将使用 `fmt.Fprint` 函数向 `http.ResponseWriter` 写入，其同样实现了 io.Writer 接口。
|
||||
|
||||
|
||||
**练习 12.7**：[remove_3till5char.go](exercises/chapter_12/remove_3till5char.go)
|
||||
下面的代码有一个输入文件`goprogram.go`，然后以每一行为单位读取，从读取的当前行中截取第3到第5的字节写入另一个文件。然而当你运行这个程序，输出的文件却是个空文件。找出程序逻辑中的bug，修正它并测试。
|
||||
下面的代码有一个输入文件 `goprogram.go`，然后以每一行为单位读取，从读取的当前行中截取第 3 到第 5 的字节写入另一个文件。然而当你运行这个程序，输出的文件却是个空文件。找出程序逻辑中的 bug，修正它并测试。
|
||||
|
||||
```go
|
||||
package main
|
||||
@@ -102,5 +102,5 @@ func main() {
|
||||
## 链接
|
||||
|
||||
- [目录](directory.md)
|
||||
- 上一节：[用defer关闭文件](12.7.md)
|
||||
- 下一节：[格式化Json数据](12.9.md)
|
||||
- 上一节：[用 defer 关闭文件](12.7.md)
|
||||
- 下一节：[格式化 Json 数据](12.9.md)
|
||||
|
||||
132
eBook/12.9.md
132
eBook/12.9.md
@@ -1,23 +1,23 @@
|
||||
# Json数据格式
|
||||
# Json 数据格式
|
||||
|
||||
数据结构要在网络中传输或保存到文件，就必须对其编码和解码；目前存在很多编码格式：JSON，XML，gob，Google缓冲协议等等。Go语言支持所有这些编码格式；在后面的章节，我们将讨论前三种格式。
|
||||
数据结构要在网络中传输或保存到文件，就必须对其编码和解码；目前存在很多编码格式：JSON，XML，gob，Google 缓冲协议等等。Go 语言支持所有这些编码格式；在后面的章节，我们将讨论前三种格式。
|
||||
|
||||
结构能够包含二进制数据，如果作为文本打印，那么可读性是很差的。另外结构内部包含命名字段，所以不清楚数据的用意。
|
||||
结构可能包含二进制数据，如果将其作为文本打印，那么可读性是很差的。另外结构内部可能包含匿名字段，而不清楚数据的用意。
|
||||
|
||||
通过把数据转换成纯文本，使用命名的字段来标注，让其具有可读性。这样的数据格式可以通过网络传输，而且是与平台无关的，任何类型的应用都能够读取和输出，不用关系操作系统和编程语言的类型。
|
||||
通过把数据转换成纯文本，使用命名的字段来标注，让其具有可读性。这样的数据格式可以通过网络传输，而且是与平台无关的，任何类型的应用都能够读取和输出，不与操作系统和编程语言的类型相关。
|
||||
|
||||
下面是一些术语说明：
|
||||
|
||||
- 数据结构 --> 指定格式 = `序列化`或`编码`(传输之前)
|
||||
- 指定格式 --> 数据格式 = `反序列化`或`解码`(传输之后)
|
||||
- 数据结构 --> 指定格式 = `序列化` 或 `编码`（传输之前）
|
||||
- 指定格式 --> 数据格式 = `反序列化` 或 `解码`（传输之后）
|
||||
|
||||
序列化是在内存中把数据转换成指定格式(data -> string),反之亦然(string -> data structure)
|
||||
序列化是在内存中把数据转换成指定格式（data -> string），反之亦然（string -> data structure）
|
||||
|
||||
编码也是一样的，只是输出一个数据流（实现了io.Writer接口）；解码是从一个数据流（实现了io.Reader）输出到一个数据结构。
|
||||
编码也是一样的，只是输出一个数据流（实现了 io.Writer 接口）；解码是从一个数据流（实现了 io.Reader）输出到一个数据结构。
|
||||
|
||||
我们都比较熟悉XML格式(参阅12.10)；但有些时候JSON(JavaScript Object Notation,参阅 [http://json.org](http://json.org))被作为首选，主要是由于其格式上非常简洁。通常json被用在web后端和浏览器之间通讯，但是在其它场景也同样的有用。
|
||||
我们都比较熟悉 XML 格式(参阅 [12.10](12.9.md))；但有些时候 JSON（JavaScript Object Notation，参阅 [http://json.org](http://json.org)）被作为首选，主要是由于其格式上非常简洁。通常 JSON 被用于 web 后端和浏览器之间的通讯，但是在其它场景也同样的有用。
|
||||
|
||||
这是一个简短的JSON片段：
|
||||
这是一个简短的 JSON 片段：
|
||||
|
||||
```javascript
|
||||
{
|
||||
@@ -28,11 +28,11 @@
|
||||
}
|
||||
```
|
||||
|
||||
尽管XML被广泛的应用，但是JSON更加简洁、轻量(其占用更少的内存、磁盘及网络带宽)和更好的可读性，这也说明他越来越受欢迎。
|
||||
尽管 XML 被广泛的应用，但是 JSON 更加简洁、轻量（占用更少的内存、磁盘及网络带宽）和更好的可读性，这也说明它越来越受欢迎。
|
||||
|
||||
go语言的json包可以让你在程序中方便的读取和写入JSON数据。
|
||||
Go 语言的 json 包可以让你在程序中方便的读取和写入 JSON 数据。
|
||||
|
||||
我们将在下面的例子里使用json包，并使用练习10.1 vcard.go中一个简化版本的Address和VCard结构(为了简单起见，我们忽略了很多错误处理，不过在实际应用中你必须要合理的处理这些错误，参阅13章)
|
||||
我们将在下面的例子里使用 json 包，并使用练习 10.1 vcard.go 中一个简化版本的 Address 和 VCard 结构（为了简单起见，我们忽略了很多错误处理，不过在实际应用中你必须要合理的处理这些错误，参阅 13 章）
|
||||
|
||||
|
||||
示例 12.16 [json.go](examples/chapter_12/json.go)：
|
||||
@@ -81,7 +81,7 @@ func main() {
|
||||
|
||||
```
|
||||
|
||||
`json.Marshal()`的函数签名是 `func Marshal(v interface{}) ([]byte, error)`,下面是数据编码后的json文本(实际上是一个[]bytes):
|
||||
`json.Marshal()` 的函数签名是 `func Marshal(v interface{}) ([]byte, error)`，下面是数据编码后的 JSON 文本（实际上是一个 []bytes）：
|
||||
|
||||
```javascript
|
||||
{
|
||||
@@ -100,94 +100,94 @@ func main() {
|
||||
}
|
||||
```
|
||||
|
||||
处于安全考虑，在web应用中最好使用`json.MarshalforHTML()`函数，其对数据执行HTML转码，所以文本会被安全的嵌在HTML`<script>`标签中。
|
||||
出于安全考虑，在 web 应用中最好使用 `json.MarshalforHTML()` 函数，其对数据执行HTML转码，所以文本可以被安全地嵌在 HTML `<script>` 标签中。
|
||||
|
||||
JSON与go类型对应如下：
|
||||
JSON 与 Go 类型对应如下：
|
||||
|
||||
- bool对应JSON的booleans
|
||||
- float64对应JSON的numbers
|
||||
- string对应JSON的strings
|
||||
- nil对应JSON的null
|
||||
- bool 对应 JSON 的 booleans
|
||||
- float64 对应 JSON 的 numbers
|
||||
- string 对应 JSON 的 strings
|
||||
- nil 对应 JSON 的 null
|
||||
|
||||
不是所有的数据都可以编码为json类型：只有验证通过的数据结构才能被编码：
|
||||
不是所有的数据都可以编码为 JSON 类型：只有验证通过的数据结构才能被编码：
|
||||
|
||||
- JSON对象只支持字符串类型的key;要编码一个go map类型，map必须是map[string]T(T是json包中支持的任何类型)
|
||||
- JSON 对象只支持字符串类型的 key；要编码一个 Go map 类型，map 必须是 map[string]T（T是 `json` 包中支持的任何类型）
|
||||
- Channel，复杂类型和函数类型不能被编码
|
||||
- 不支持循环数据结构；它将引起序列化进入一个无线循环
|
||||
- 指针可以被编码，实际上是对指针指向的值进行编码(或者指针是nil)
|
||||
- 不支持循环数据结构；它将引起序列化进入一个无限循环
|
||||
- 指针可以被编码，实际上是对指针指向的值进行编码（或者指针是 nil）
|
||||
|
||||
### 反序列化：
|
||||
|
||||
`UnMarshal()`的函数签名是 `func Unmarshal(data []byte, v interface{}) error` 把json解码为数据结构。
|
||||
`UnMarshal()` 的函数签名是 `func Unmarshal(data []byte, v interface{}) error` 把 JSON 解码为数据结构。
|
||||
|
||||
我们首先创建一个结构Message用来保存解码的数据：`var m Message` 并调用`Unmarshal()`，解析[]byte中的json数据并将结果存入指针m指向的值
|
||||
我们首先创建一个结构 Message 用来保存解码的数据：`var m Message` 并调用 `Unmarshal()`，解析 []byte 中的 JSON 数据并将结果存入指针 m 指向的值
|
||||
|
||||
虽然反射能够让json字段去尝试匹配目标结构字段；但是只有真正匹配上的字段才会填充数据。字段没有匹配不会报错，而是直接忽略掉。
|
||||
虽然反射能够让 JSON 字段去尝试匹配目标结构字段；但是只有真正匹配上的字段才会填充数据。字段没有匹配不会报错，而是直接忽略掉。
|
||||
|
||||
(练习15.2b twitter_status_json.go中用到了UnMarshal)
|
||||
（练习 15.2b twitter_status_json.go 中用到了 UnMarshal）
|
||||
|
||||
### 解码任意的数据：
|
||||
|
||||
json包使用map[string]interface{}和[]interface{}储存任意的JSON对象和数组；其可以被反序列化为任何的JSON blob存储到接口值中。
|
||||
json 包使用 `map[string]interface{}` 和 `[]interface{}` 储存任意的 JSON 对象和数组；其可以被反序列化为任何的 JSON blob 存储到接口值中。
|
||||
|
||||
来看这个JSON数据，被存储在变量b中：
|
||||
来看这个 JSON 数据，被存储在变量 b 中：
|
||||
|
||||
```go
|
||||
b == []byte({"Name": "Wednesday", "Age": 6, "Parents": ["Gomez", "Morticia"]})
|
||||
```
|
||||
|
||||
不用理解这个数据的结构，我们可以直接使用Unmarshal把这个数据编码并保存在接口值中：
|
||||
不用理解这个数据的结构，我们可以直接使用 Unmarshal 把这个数据编码并保存在接口值中：
|
||||
|
||||
```go
|
||||
var f interface{}
|
||||
err := json.Unmarshal(b, &f)
|
||||
var f interface{}
|
||||
err := json.Unmarshal(b, &f)
|
||||
```
|
||||
|
||||
f指向的值是一个map,key是一个字符串，value是自身存储作为空接口类型的值：
|
||||
f 指向的值是一个 map，key 是一个字符串，value 是自身存储作为空接口类型的值：
|
||||
|
||||
```go
|
||||
map[string]interface{}{
|
||||
"Name": "Wednesday",
|
||||
"Age": 6,
|
||||
"Parents": []interface{}{
|
||||
"Gomez",
|
||||
"Morticia",
|
||||
},
|
||||
}
|
||||
map[string]interface{} {
|
||||
"Name": "Wednesday",
|
||||
"Age": 6,
|
||||
"Parents": []interface{} {
|
||||
"Gomez",
|
||||
"Morticia",
|
||||
},
|
||||
}
|
||||
```
|
||||
|
||||
要访问这个数据，我们可以使用类型断言
|
||||
|
||||
```go
|
||||
m := f.(map[string]interface{})
|
||||
m := f.(map[string]interface{})
|
||||
```
|
||||
|
||||
我们可以通过for range语法和type switch来访问其实际类型：
|
||||
我们可以通过 for range 语法和 type switch 来访问其实际类型：
|
||||
|
||||
```go
|
||||
for k, v := range m {
|
||||
switch vv := v.(type) {
|
||||
case string:
|
||||
fmt.Println(k, "is string", vv)
|
||||
case int:
|
||||
fmt.Println(k, "is int", vv)
|
||||
for k, v := range m {
|
||||
switch vv := v.(type) {
|
||||
case string:
|
||||
fmt.Println(k, "is string", vv)
|
||||
case int:
|
||||
fmt.Println(k, "is int", vv)
|
||||
|
||||
case []interface{}:
|
||||
fmt.Println(k, "is an array:")
|
||||
for i, u := range vv {
|
||||
fmt.Println(i, u)
|
||||
}
|
||||
default:
|
||||
fmt.Println(k, "is of a type I don’t know how to handle")
|
||||
case []interface{}:
|
||||
fmt.Println(k, "is an array:")
|
||||
for i, u := range vv {
|
||||
fmt.Println(i, u)
|
||||
}
|
||||
default:
|
||||
fmt.Println(k, "is of a type I don’t know how to handle")
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
通过这种方式，你可以处理未知的JSON数据，同时可以确保类型安全。
|
||||
通过这种方式，你可以处理未知的 JSON 数据，同时可以确保类型安全。
|
||||
|
||||
### 解码数据到结构：
|
||||
|
||||
如果我们事先知道json数据，我们可以定义一个适当的结构并对json数据反序列化。下面的例子中，我们将定义：
|
||||
如果我们事先知道 JSON 数据，我们可以定义一个适当的结构并对 JSON 数据反序列化。下面的例子中，我们将定义：
|
||||
|
||||
```go
|
||||
type FamilyMember struct {
|
||||
@@ -201,31 +201,31 @@ type FamilyMember struct {
|
||||
并对其反序列化：
|
||||
|
||||
```go
|
||||
var m FamilyMember
|
||||
err := json.Unmarshal(b, &m)
|
||||
var m FamilyMember
|
||||
err := json.Unmarshal(b, &m)
|
||||
```
|
||||
|
||||
程序实际上是分配了一个新的切片。这是一个典型的反序列化引用类型(指针、切片和映射)的例子。
|
||||
程序实际上是分配了一个新的切片。这是一个典型的反序列化引用类型（指针、切片和 map）的例子。
|
||||
|
||||
### 编码和解码流
|
||||
json包提供Decoder和Encoder类型来支持常用的读写JSON数据流。NewDecoder和NewEncoder函数分别封装了io.Reader和io.Writer接口。
|
||||
json 包提供 Decoder 和 Encoder 类型来支持常用 JSON 数据流读写。NewDecoder 和 NewEncoder 函数分别封装了 io.Reader 和 io.Writer 接口。
|
||||
|
||||
```go
|
||||
func NewDecoder(r io.Reader) *Decoder
|
||||
func NewEncoder(w io.Writer) *Encoder
|
||||
```
|
||||
|
||||
要想把json直接写入文件，可以使用json.NewEncoder初始化文件(或者任何实现io.Writer的类型)，并调用Encode()；反过来与其对应的是使用json.Decoder和Decode()函数：
|
||||
要想把 JSON 直接写入文件，可以使用 json.NewEncoder 初始化文件（或者任何实现 io.Writer 的类型），并调用 Encode()；反过来与其对应的是使用 json.Decoder 和 Decode() 函数：
|
||||
|
||||
```go
|
||||
func NewDecoder(r io.Reader) *Decoder
|
||||
func (dec *Decoder) Decode(v interface{}) error
|
||||
```
|
||||
|
||||
来看下接口是如何对实现进行抽象的：数据结构可以是任何类型，只要其实现了某种接口，目标或来源数据要能够被编码就必须实现io.Writer或io.Reader接口。由于go语言中到处都实现了Reader和Writer，因此Encoder和Decoder可被应用的场景非常广泛，例如读取或写入HTTP连接、websockets或文件。
|
||||
来看下接口是如何对实现进行抽象的：数据结构可以是任何类型，只要其实现了某种接口，目标或源数据要能够被编码就必须实现 io.Writer 或 io.Reader 接口。由于 Go 语言中到处都实现了 Reader 和 Writer，因此 Encoder 和 Decoder 可被应用的场景非常广泛，例如读取或写入 HTTP 连接、websockets 或文件。
|
||||
|
||||
## 链接
|
||||
|
||||
- [目录](directory.md)
|
||||
- 上一节：[一个使用接口的实际例子:fmt.Fprintf](12.8.md)
|
||||
- 下一节：[XML数据格式](12.10.md)
|
||||
- 下一节：[XML 数据格式](12.10.md)
|
||||
|
||||
@@ -117,6 +117,8 @@
|
||||
- 12.6 [用切片读写文件](12.6.md)
|
||||
- 12.7 [用 defer 关闭文件](12.7.md)
|
||||
- 12.8 [一个使用接口的实际例子：fmt.Fprintf](12.8.md)
|
||||
- 12.9 [格式化 Json 数据](12.9.md)
|
||||
- 12.10 [XML 数据格式](12.10.md)
|
||||
- 第13章：错误处理与测试
|
||||
- 第14章：goroutine 与 channel
|
||||
- 第15章：网络、模版与网页应用
|
||||
|
||||
Reference in New Issue
Block a user