Browse Source

12.7-12.12

Unknwon 2 years ago
parent
commit
48d5b9db25
10 changed files with 33 additions and 28 deletions
  1. 1 1
      README.md
  2. 1 1
      README_gc.md
  3. 6 0
      TOC.md
  4. 6 3
      eBook/12.10.md
  5. 2 7
      eBook/12.11.md
  6. 5 5
      eBook/12.12.md
  7. 1 2
      eBook/12.7.md
  8. 7 4
      eBook/12.8.md
  9. 3 4
      eBook/12.9.md
  10. 1 1
      eBook/directory.md

+ 1 - 1
README.md

@@ -9,7 +9,7 @@
9 9
 
10 10
 ## 翻译进度
11 11
 
12
-12.6 [用切片读写文件](eBook/12.6.md)
12
+12.12 [Go 中的密码学](eBook/12.12.md)
13 13
 
14 14
 ## 支持本书
15 15
 

+ 1 - 1
README_gc.md

@@ -30,4 +30,4 @@ Golang 编程:245386165
30 30
 
31 31
 |更新日期    |更新内容
32 32
 |----------|------------------
33
-|2015-11-13|12.6 用切片读写文件
33
+|2015-11-18|12.12 Go 中的密码学

+ 6 - 0
TOC.md

@@ -111,3 +111,9 @@
111 111
         - 12.4 [从命令行读取参数](12.4.md)
112 112
         - 12.5 [用 buffer 读取文件](12.5.md)
113 113
         - 12.6 [用切片读写文件](12.6.md)
114
+        - 12.7 [用 defer 关闭文件](12.7.md)
115
+        - 12.8 [使用接口的实际例子:fmt.Fprintf](12.8.md)
116
+        - 12.9 [格式化 JSON 数据](12.9.md)
117
+        - 12.10 [XML 数据格式](12.10.md)
118
+        - 12.11 [用 Gob 传输数据](12.11.md)
119
+        - 12.12 [Go 中的密码学](12.12.md)

+ 6 - 3
eBook/12.10.md

@@ -1,6 +1,7 @@
1 1
 # 12.10 XML 数据格式
2 2
 
3 3
 下面是与 12.9 节 JSON 例子等价的 XML 版本:
4
+
4 5
 ```xml
5 6
 <Person>
6 7
     <FirstName>Laura</FirstName>
@@ -56,8 +57,11 @@ func main() {
56 57
 		}
57 58
 	}
58 59
 }
60
+```
61
+
62
+输出:
59 63
 
60
-/* Output:
64
+```
61 65
 Token name: Person
62 66
 Token name: FirstName
63 67
 This is the content: Laura
@@ -66,9 +70,8 @@ Token name: LastName
66 70
 This is the content: Lynn
67 71
 End of token
68 72
 End of token
69
-*/
70
-
71 73
 ```
74
+
72 75
 包中定义了若干 XML 标签类型:StartElement,Chardata(这是从开始标签到结束标签之间的实际文本),EndElement,Comment,Directive 或 ProcInst。
73 76
 
74 77
 包中同样定义了一个结构解析器:`NewParser` 方法持有一个 io.Reader(这里具体类型是 strings.NewReader)并生成一个解析器类型的对象。还有一个 `Token()` 方法返回输入流里的下一个 XML token。在输入流的结尾处,会返回(nil,io.EOF)

+ 2 - 7
eBook/12.11.md

@@ -16,7 +16,6 @@ Gob 文件或流是完全自描述的:里面包含的所有类型都有一个
16 16
 ```go
17 17
 type T struct { X, Y, Z int }
18 18
 var t = T{X: 7, Y: 0, Z: 8}
19
-
20 19
 ```
21 20
 
22 21
 而在接收者这边可以用一个结构体 U 类型的变量 u 来接收这个值:
@@ -24,7 +23,6 @@ var t = T{X: 7, Y: 0, Z: 8}
24 23
 ```go
25 24
 type U struct { X, Y *int8 }
26 25
 var u U
27
-
28 26
 ```
29 27
 
30 28
 在接收者中,X 的值是7,Y 的值是0(Y的值并没有从 t 中传递过来,因为它是零值)
@@ -81,7 +79,6 @@ func main() {
81 79
 	fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y)
82 80
 }
83 81
 // Output:   "Pythagoras": {3,4}
84
-
85 82
 ```
86 83
 
87 84
 示例 12.19 [gob2.go](examples/chapter_12/gob2.go) 编码到文件:
@@ -115,7 +112,7 @@ func main() {
115 112
 	pa := &Address{"private", "Aartselaar","Belgium"}
116 113
 	wa := &Address{"work", "Boom", "Belgium"}
117 114
 	vc := VCard{"Jan", "Kersschot", []*Address{pa,wa}, "none"}
118
-	// fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}: 
115
+	// fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}:
119 116
 	// using an encoder:
120 117
 	file, _ := os.OpenFile("vcard.gob", os.O_CREATE|os.O_WRONLY, 0)
121 118
 	defer file.Close()
@@ -125,16 +122,14 @@ func main() {
125 122
 		log.Println("Error in encoding gob")
126 123
 	}
127 124
 }
128
-
129 125
 ```
130 126
 
131 127
 **练习 12.8**:[degob.go](exercises/chapter_12/degob.go):
132 128
 
133 129
 写一个程序读取 vcard.gob 文件,解码并打印它的内容。
134 130
 
135
-
136 131
 ## 链接
137 132
 
138 133
 - [目录](directory.md)
139 134
 - 上一节:[XML 数据格式](12.10.md)
140
-- 下一节:[Go 中的密码学](12.12.md)
135
+- 下一节:[Go 中的密码学](12.12.md)

+ 5 - 5
eBook/12.12.md

@@ -37,12 +37,14 @@ func main() {
37 37
 	checksum := hasher.Sum(b)
38 38
 	fmt.Printf("Result: %x\n", checksum)
39 39
 }
40
-/* Output: 
40
+```
41
+
42
+输出:
43
+
44
+```
41 45
 Result: a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
42 46
 Result: [169 74 143 229 204 177 155 166 28 76 8 115 211 145 233 135 152 47 187 211]
43 47
 Result: e2222bfc59850bbb00a722e764a555603bb59b2a
44
-*/
45
-
46 48
 ```
47 49
 
48 50
 通过调用 `sha1.New()` 创建了一个新的 `hash.Hash` 对象,用来计算 SHA1 校验值。`Hash` 类型实际上是一个接口,它实现了 `io.Writer` 接口:
@@ -69,7 +71,6 @@ type Hash interface {
69 71
 	// are a multiple of the block size.
70 72
 	BlockSize() int
71 73
 }
72
-
73 74
 ```
74 75
 
75 76
 通过 io.WriteString 或 hasher.Write 计算给定字符串的校验值。
@@ -78,7 +79,6 @@ type Hash interface {
78 79
 
79 80
 在示例 12.20 中检验 md5 算法。
80 81
 
81
-
82 82
 ## 链接
83 83
 
84 84
 - [目录](directory.md)

+ 1 - 2
eBook/12.7.md

@@ -9,10 +9,9 @@ func data(name string) string {
9 9
 	contents := io.ReadAll(f)
10 10
 	return contents
11 11
 }
12
-
13 12
 ```
14
-在函数 return 后执行了 `f.Close()`
15 13
 
14
+在函数 return 后执行了 `f.Close()`
16 15
 
17 16
 ## 链接
18 17
 

+ 7 - 4
eBook/12.8.md

@@ -3,6 +3,7 @@
3 3
 例子程序 `io_interfaces.go` 很好的阐述了 io 包中的接口概念。
4 4
 
5 5
 示例 12.15 [io_interfaces.go](examples/chapter_12/io_interfaces.go):
6
+
6 7
 ```go
7 8
 // interfaces being used in the GO-package fmt
8 9
 package main
@@ -22,7 +23,6 @@ func main() {
22 23
 	fmt.Fprintf(buf, "%s\n", "hello world! - buffered")
23 24
 	buf.Flush()
24 25
 }
25
-
26 26
 ```
27 27
 
28 28
 输出:
@@ -31,10 +31,11 @@ func main() {
31 31
 hello world! - unbuffered
32 32
 hello world! - buffered
33 33
 ```
34
+
34 35
 下面是 `fmt.Fprintf()` 函数的实际签名
35 36
 
36 37
 ```go
37
-func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) 
38
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
38 39
 ```
39 40
 其不是写入一个文件,而是写入一个 `io.Writer` 接口类型的变量,下面是 `Writer` 接口在 io 包中的定义:
40 41
 
@@ -43,7 +44,8 @@ type Writer interface {
43 44
 	Write(p []byte) (n int, err error)
44 45
 }
45 46
 ```
46
-`fmt.Fprintf()` 依据指定的格式向第一个参数内写入字符串,第一参数必须实现了 `io.Writer` 接口。`Fprintf()` 能够写入任何类型,只要其实现了 `Write` 方法,包括 `os.Stdout`,文件(例如 os.File),管道,网络连接,通道等等,同样的也可以使用 bufio 包中缓冲写入。bufio 包中定义了 `type Writer struct{...}`
47
+
48
+`fmt.Fprintf()` 依据指定的格式向第一个参数内写入字符串,第一参数必须实现了 `io.Writer` 接口。`Fprintf()` 能够写入任何类型,只要其实现了 `Write` 方法,包括 `os.Stdout`,文件(例如 os.File),管道,网络连接,通道等等,同样的也可以使用 bufio 包中缓冲写入。bufio 包中定义了 `type Writer struct{...}`。
47 49
 
48 50
 bufio.Writer 实现了 Write 方法:
49 51
 
@@ -56,14 +58,15 @@ func (b *Writer) Write(p []byte) (nn int, err error)
56 58
 ```go
57 59
 func NewWriter(wr io.Writer) (b *Writer)
58 60
 ```
61
+
59 62
 其适合任何形式的缓冲写入。
60 63
 
61 64
 在缓冲写入的最后千万不要忘了使用 `Flush()`,否则最后的输出不会被写入。
62 65
 
63 66
 在 15.2-15.8 章节,我们将使用 `fmt.Fprint` 函数向 `http.ResponseWriter` 写入,其同样实现了 io.Writer 接口。
64 67
 
65
-
66 68
 **练习 12.7**:[remove_3till5char.go](exercises/chapter_12/remove_3till5char.go)
69
+
67 70
 下面的代码有一个输入文件 `goprogram.go`,然后以每一行为单位读取,从读取的当前行中截取第 3 到第 5 的字节写入另一个文件。然而当你运行这个程序,输出的文件却是个空文件。找出程序逻辑中的 bug,修正它并测试。
68 71
 
69 72
 ```go

+ 3 - 4
eBook/12.9.md

@@ -1,4 +1,4 @@
1
-# 12.9 Json 数据格式
1
+# 12.9 JSON 数据格式
2 2
 
3 3
 数据结构要在网络中传输或保存到文件,就必须对其编码和解码;目前存在很多编码格式:JSON,XML,gob,Google 缓冲协议等等。Go 语言支持所有这些编码格式;在后面的章节,我们将讨论前三种格式。
4 4
 
@@ -34,7 +34,6 @@ Go 语言的 json 包可以让你在程序中方便的读取和写入 JSON 数
34 34
 
35 35
 我们将在下面的例子里使用 json 包,并使用练习 10.1 vcard.go 中一个简化版本的 Address 和 VCard 结构(为了简单起见,我们忽略了很多错误处理,不过在实际应用中你必须要合理的处理这些错误,参阅 13 章)
36 36
 
37
-
38 37
 示例 12.16 [json.go](examples/chapter_12/json.go):
39 38
 
40 39
 ```go
@@ -78,7 +77,6 @@ func main() {
78 77
 		log.Println("Error in encoding json")
79 78
 	}
80 79
 }
81
-
82 80
 ```
83 81
 
84 82
 `json.Marshal()` 的函数签名是 `func Marshal(v interface{}) ([]byte, error)`,下面是数据编码后的 JSON 文本(实际上是一个 []bytes):
@@ -185,7 +183,7 @@ for k, v := range m {
185 183
 
186 184
 通过这种方式,你可以处理未知的 JSON 数据,同时可以确保类型安全。
187 185
 
188
-### 解码数据到结构
186
+### 解码数据到结构
189 187
 
190 188
 如果我们事先知道 JSON 数据,我们可以定义一个适当的结构并对 JSON 数据反序列化。下面的例子中,我们将定义:
191 189
 
@@ -208,6 +206,7 @@ err := json.Unmarshal(b, &m)
208 206
 程序实际上是分配了一个新的切片。这是一个典型的反序列化引用类型(指针、切片和 map)的例子。
209 207
 
210 208
 ### 编码和解码流
209
+
211 210
 json 包提供 Decoder 和 Encoder 类型来支持常用 JSON 数据流读写。NewDecoder 和 NewEncoder 函数分别封装了 io.Reader 和 io.Writer 接口。
212 211
 
213 212
 ```go

+ 1 - 1
eBook/directory.md

@@ -120,7 +120,7 @@
120 120
     - 12.6 [用切片读写文件](12.6.md)
121 121
     - 12.7 [用 defer 关闭文件](12.7.md)
122 122
     - 12.8 [使用接口的实际例子:fmt.Fprintf](12.8.md)
123
-    - 12.9 [格式化 Json 数据](12.9.md)
123
+    - 12.9 [格式化 JSON 数据](12.9.md)
124 124
     - 12.10 [XML 数据格式](12.10.md)
125 125
     - 12.11 [用 Gob 传输数据](12.11.md)
126 126
     - 12.12 [Go 中的密码学](12.12.md)