精校：4.8-5.1

Author: unknwon

eBook/04.7.md

@@ -273,7 +273,7 @@ func main() {
 	GO1 - The ABC of Go - 25 -
 	sl2 joined by ;: GO1;The ABC of Go;25
 
-其它有关字符串操作的文档请参阅官方文档 [http://golang.org/pkg/strings/](http://golang.org/pkg/strings/)（ **译者注：国内用户可访问 [该页面](http://docs.studygolang.com/pkg/strings/)** ）。
+其它有关字符串操作的文档请参阅 [官方文档](http://golang.org/pkg/strings/)（ **译者注：国内用户可访问 [该页面](http://docs.studygolang.com/pkg/strings/)** ）。
 
 ## 4.7.11 从字符串中读取内容
 
@@ -341,7 +341,7 @@ func main() {
 
 在第 5.1 节，我们将会利用 if 语句来对可能出现的错误进行分类处理。
 
-更多有关该包的讨论，请参阅官方文档 [http://golang.org/pkg/strconv/](http://golang.org/pkg/strconv/)（ **译者注：国内用户可访问 [该页面](http://docs.studygolang.com/pkg/strconv/)** ）。
+更多有关该包的讨论，请参阅 [官方文档](http://golang.org/pkg/strconv/)（ **译者注：国内用户可访问 [该页面](http://docs.studygolang.com/pkg/strconv/)** ）。
 
 ## 链接
 

eBook/04.8.md

@@ -9,44 +9,48 @@ Duration 类型表示两个连续时刻所相差的纳秒数，类型为 int64
 包中的一个预定义函数 `func (t Time) Format(layout string) string` 可以根据一个格式化字符串来将一个时间 t 转换为相应格式的字符串，你可以使用一些预定义的格式，如：`time.ANSIC` 或 `time.RFC822`。 
 
 一般的格式化设计是通过对于一个标准时间的格式化描述来展现的，这听起来很奇怪，但看下面这个例子你就会一目了然：
-
-	fmt.Println(t.Format("02 Jan 2006 15:04")) 
+
+```go
+fmt.Println(t.Format("02 Jan 2006 15:04")) 
+```
 
 输出：
 
 	21 Jul 2011 10:31
 
-其它有关时间操作的文档请参阅官方文档 [http://golang.org/pkg/time/](http://golang.org/pkg/time/)（ **译者注：国内用户可访问 [http://docs.studygolang.com/pkg/time/](http://docs.studygolang.com/pkg/time/)** ）。
-
-Example 4.20 [time.go](examples/chapter_4/time.go)
-
-	package main
-	import (
-		"fmt"
-		"time"
-	)
-
-	var week time.Duration
-	func main() {
-		t := time.Now()
-		fmt.Println(t) // e.g. Wed Dec 21 09:52:14 +0100 RST 2011
-		fmt.Printf("%02d.%02d.%4d\n", t.Day(), t.Month(), t.Year())
-		// 21.12.2011
-		t = time.Now().UTC()
-		fmt.Println(t) // Wed Dec 21 08:52:14 +0000 UTC 2011
-		fmt.Println(time.Now()) // Wed Dec 21 09:52:14 +0100 RST 2011
-		// calculating times:
-		week = 60 * 60 * 24 * 7 * 1e9 // must be in nanosec
-		week_from_now := t.Add(week)
-		fmt.Println(week_from_now) // Wed Dec 28 08:52:14 +0000 UTC 2011
-		// formatting times:
-		fmt.Println(t.Format(time.RFC822)) // 21 Dec 11 0852 UTC
-		fmt.Println(t.Format(time.ANSIC)) // Wed Dec 21 08:56:34 2011
-		fmt.Println(t.Format("02 Jan 2006 15:04")) // 21 Dec 2011 08:52
-		s := t.Format("20060102")
-		fmt.Println(t, "=>", s)
-		// Wed Dec 21 08:52:14 +0000 UTC 2011 => 20111221
-	}
+其它有关时间操作的文档请参阅 [官方文档](http://golang.org/pkg/time/)（ **译者注：国内用户可访问 [该页面](http://docs.studygolang.com/pkg/time/)** ）。
+
+示例 4.20 [time.go](examples/chapter_4/time.go)
+
+```go
+package main
+import (
+	"fmt"
+	"time"
+)
+
+var week time.Duration
+func main() {
+	t := time.Now()
+	fmt.Println(t) // e.g. Wed Dec 21 09:52:14 +0100 RST 2011
+	fmt.Printf("%02d.%02d.%4d\n", t.Day(), t.Month(), t.Year())
+	// 21.12.2011
+	t = time.Now().UTC()
+	fmt.Println(t) // Wed Dec 21 08:52:14 +0000 UTC 2011
+	fmt.Println(time.Now()) // Wed Dec 21 09:52:14 +0100 RST 2011
+	// calculating times:
+	week = 60 * 60 * 24 * 7 * 1e9 // must be in nanosec
+	week_from_now := t.Add(week)
+	fmt.Println(week_from_now) // Wed Dec 28 08:52:14 +0000 UTC 2011
+	// formatting times:
+	fmt.Println(t.Format(time.RFC822)) // 21 Dec 11 0852 UTC
+	fmt.Println(t.Format(time.ANSIC)) // Wed Dec 21 08:56:34 2011
+	fmt.Println(t.Format("02 Jan 2006 15:04")) // 21 Dec 2011 08:52
+	s := t.Format("20060102")
+	fmt.Println(t, "=>", s)
+	// Wed Dec 21 08:52:14 +0000 UTC 2011 => 20111221
+}
+```
 
 输出的结果已经写在每行 `//` 的后面。
 

eBook/04.9.md

@@ -8,14 +8,18 @@
 
 Go 语言的取地址符是 `&`，放到一个变量前使用就会返回相应变量的内存地址。
 
-下面的代码片段（Example 4.9 [pointer.go](examples/chapter_4/pointer.go)）可能输出 `An integer: 5, its location in memory: 0x6b0820`（这个值随着你每次运行程序而变化）。
-
-	var i1 = 5
-	fmt.Printf("An integer: %d, it's location in memory: %p\n", i1, &i1)
+下面的代码片段（示例 4.9 [pointer.go](examples/chapter_4/pointer.go)）可能输出 `An integer: 5, its location in memory: 0x6b0820`（这个值随着你每次运行程序而变化）。
+
+```go
+var i1 = 5
+fmt.Printf("An integer: %d, it's location in memory: %p\n", i1, &i1)
+```
 
 这个地址可以存储在一个叫做指针的特殊数据类型中，在本例中这是一个指向 int 的指针，即 `i1`：此处使用 *int 表示。如果我们想调用指针 intP，我们可以这样声明它：
-
-	var intP *int
+
+```go
+var intP *int
+```
 
 然后使用 `intP = &i1` 是合法的，此时 intP 指向 i1。
 
@@ -39,20 +43,22 @@ intP 存储了 i1 的内存地址；它指向了 i1 的位置，它引用了变
 
 现在，我们应当能理解 pointer.go 中的整个程序和他的输出：
 
-Example 4.21 [pointer.go](examples/chapter_4/pointer.go):
-
-	package main
-	import "fmt"
-	func main() {
-		var i1 = 5
-		fmt.Printf("An integer: %d, its location in memory: %p\n", i1, &i1)
-		var intP *int
-		intP = &i1
-		fmt.Printf("The value at memory location %p is %d\n", intP, *intP)
-	}
+示例 4.21 [pointer.go](examples/chapter_4/pointer.go):
+
+```go
+package main
+import "fmt"
+func main() {
+	var i1 = 5
+	fmt.Printf("An integer: %d, its location in memory: %p\n", i1, &i1)
+	var intP *int
+	intP = &i1
+	fmt.Printf("The value at memory location %p is %d\n", intP, *intP)
+}
+```
 
 输出：
- 
+
 	An integer: 5, its location in memory: 0x24f0820
 	The value at memory location 0x24f0820 is 5
 
@@ -64,18 +70,20 @@ Example 4.21 [pointer.go](examples/chapter_4/pointer.go):
 
 它展示了分配一个新的值给 *p 并且更改这个变量自己的值（这里是一个字符串）。
 
-Example 4.22 [string_pointer.go](examples/chapter_4/string_pointer.go)
-
-	package main
-	import "fmt"
-	func main() {
-		s := "good bye"
-		var p *string = &s
-		*p = "ciao"
-		fmt.Printf("Here is the pointer p: %p\n", p) // prints address
-		fmt.Printf("Here is the string *p: %s\n", *p) // prints string
-		fmt.Printf("Here is the string s: %s\n", s) // prints same string
-	}
+示例 4.22 [string_pointer.go](examples/chapter_4/string_pointer.go)
+
+```go
+package main
+import "fmt"
+func main() {
+	s := "good bye"
+	var p *string = &s
+	*p = "ciao"
+	fmt.Printf("Here is the pointer p: %p\n", p) // prints address
+	fmt.Printf("Here is the string *p: %s\n", *p) // prints string
+	fmt.Printf("Here is the string s: %s\n", s) // prints same string
+}
+```
 
 输出：
 
@@ -92,10 +100,12 @@ Example 4.22 [string_pointer.go](examples/chapter_4/string_pointer.go)
 **注意事项** 
 
 你不能得到一个文字或常量的地址，例如：
-
-	const i = 5
-	ptr := &i //error: cannot take the address of i
-	ptr2 := &10 //error: cannot take the address of 10
+
+```go
+const i = 5
+ptr := &i //error: cannot take the address of i
+ptr2 := &10 //error: cannot take the address of 10
+```
 
 所以说，Go 语言和 C、C++ 以及 D 语言这些低级（系统）语言一样，都有指针的概念。但是对于经常导致 C 语言内存泄漏继而程序崩溃的指针运算（所谓的指针算法，如：`pointer+2`，移动指针指向字符串的字节数或数组的某个位置）是不被允许的。Go 语言中的指针保证了内存安全，更像是 Java、C# 和 VB.NET 中的引用。
 
@@ -111,15 +121,17 @@ Example 4.22 [string_pointer.go](examples/chapter_4/string_pointer.go)
 
 对一个空指针的反向引用是不合法的，并且会使程序崩溃：
 
-Example 4.23 [testcrash.go](examples/chapter_4/testcrash.go):
-
-	package main
-	func main() {
-		var p *int = nil
-		*p = 0
-	}
-	// in Windows: stops only with: <exit code="-1073741819" msg="process crashed"/>
-	// runtime error: invalid memory address or nil pointer dereference
+示例 4.23 [testcrash.go](examples/chapter_4/testcrash.go):
+
+```go
+package main
+func main() {
+	var p *int = nil
+	*p = 0
+}
+// in Windows: stops only with: <exit code="-1073741819" msg="process crashed"/>
+// runtime error: invalid memory address or nil pointer dereference
+```
 
 **问题 4.2** 列举 Go 语言中 * 号的所有用法。
 

eBook/05.0.md

@@ -2,13 +2,13 @@
 
 到目前为止，我们看到的都是 Go 程序都是从 main() 函数开始执行，然后按顺序执行该函数体中的代码。但我们经常会需要只有在满足一些特定情况时才执行某些代码，也就是说在代码里进行条件判断。针对这种需求，Go 提供了下面这些条件结构和分支结构：
 
-	if-else 结构
-	switch 结构
-	select 结构，用于 channel 的选择(第 14.4 节)
+- if-else 结构
+- switch 结构
+- elect 结构，用于 channel 的选择（第 14.4 节）
 
 可以使用迭代或循环结构来重复执行一次或多次某段代码（任务）：
 
-	for (range) 结构
+- for (range) 结构
 
 一些如 `break` 和 `continue` 这样的关键字可以用于中途改变循环的状态。