Add syntax highlighting

zh/02.2.md

@@ -8,21 +8,25 @@ Go语言里面定义变量有多种方式。
 
 使用`var`关键字是Go最基本的定义变量方式，与C语言不同的是Go把变量类型放在变量名后面：
 ```Go
+
 	//定义一个名称为“variableName”，类型为"type"的变量
 	var variableName type
 ```
 定义多个变量
 ```Go
+
 	//定义三个类型都是“type”的变量
 	var vname1, vname2, vname3 type
 ```
 定义变量并初始化值
 ```Go
+
 	//初始化“variableName”的变量为“value”值，类型是“type”
 	var variableName type = value
 ```
 同时初始化多个变量
 ```Go
+
 	/*
 		定义三个类型都是"type"的变量,并且分别初始化为相应的值
 		vname1为v1，vname2为v2，vname3为v3
@@ -31,6 +35,7 @@ Go语言里面定义变量有多种方式。
 ```
 你是不是觉得上面这样的定义有点繁琐？没关系，因为Go语言的设计者也发现了，有一种写法可以让它变得简单一点。我们可以直接忽略类型声明，那么上面的代码变成这样了：
 ```Go
+
 	/*
 		定义三个变量，它们分别初始化为相应的值
 		vname1为v1，vname2为v2，vname3为v3
@@ -40,6 +45,7 @@ Go语言里面定义变量有多种方式。
 ```
 你觉得上面的还是有些繁琐？好吧，我也觉得。让我们继续简化：
 ```Go
+
 	/*
 		定义三个变量，它们分别初始化为相应的值
 		vname1为v1，vname2为v2，vname3为v3
@@ -55,6 +61,7 @@ Go语言里面定义变量有多种方式。
 
 Go对于已声明但未使用的变量会在编译阶段报错，比如下面的代码就会产生一个错误：声明了`i`但未使用。
 ```Go
+
 	package main
 
 	func main() {
@@ -67,12 +74,14 @@ Go对于已声明但未使用的变量会在编译阶段报错，比如下面的
 
 它的语法如下：
 ```Go
+
 	const constantName = value
 	//如果需要，也可以明确指定常量的类型：
 	const Pi float32 = 3.1415926
 ```
 下面是一些常量声明的例子：
 ```Go
+
 	const Pi = 3.1415926
 	const i = 10000
 	const MaxThread = 10
@@ -87,6 +96,7 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位
 
 在Go中，布尔值的类型为`bool`，值是`true`或`false`，默认为`false`。
 ```Go
+
 	//示例代码
 	var isActive bool  // 全局变量声明
 	var enabled, disabled = true, false  // 忽略类型的声明
@@ -117,6 +127,7 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位
 
 这就是全部吗？No！Go还支持复数。它的默认类型是`complex128`（64位实数+64位虚数）。如果需要小一些的，也有`complex64`(32位实数+32位虚数)。复数的形式为`RE + IMi`，其中`RE`是实数部分，`IM`是虚数部分，而最后的`i`是虚数单位。下面是一个使用复数的例子：
 ```Go
+
 	var c complex64 = 5+5i
 	//output: (5+5i)
 	fmt.Printf("Value is: %v", c)
@@ -126,6 +137,7 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位
 
 我们在上一节中讲过，Go中的字符串都是采用`UTF-8`字符集编码。字符串是用一对双引号（`""`）或反引号（`` ` `` `` ` ``）括起来定义，它的类型是`string`。
 ```Go
+
 	//示例代码
 	var frenchHello string  // 声明变量为字符串的一般方法
 	var emptyString string = ""  // 声明了一个字符串变量，初始化为空字符串
@@ -137,12 +149,14 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位
 ```
 在Go中字符串是不可变的，例如下面的代码编译时会报错：cannot assign to s[0]
 ```Go
+
 	var s string = "hello"
 	s[0] = 'c'
 
 ```
 但如果真的想要修改怎么办呢？下面的代码可以实现：
 ```Go
+
 	s := "hello"
 	c := []byte(s)  // 将字符串 s 转换为 []byte 类型
 	c[0] = 'c'
@@ -152,6 +166,7 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位
 
 Go中可以使用`+`操作符来连接两个字符串：
 ```Go
+
 	s := "hello,"
 	m := " world"
 	a := s + m
@@ -159,6 +174,7 @@ Go中可以使用`+`操作符来连接两个字符串：
 ```
 修改字符串也可写为：
 ```Go
+
 	s := "hello"
 	s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作
 	fmt.Printf("%s\n", s)
@@ -176,6 +192,7 @@ Go中可以使用`+`操作符来连接两个字符串：
 ### 错误类型
 Go内置有一个`error`类型，专门用来处理错误信息，Go的`package`里面还专门有一个包`errors`来处理错误：
 ```Go
+
 	err := errors.New("emit macho dwarf: elf header corrupted")
 	if err != nil {
 		fmt.Print(err)
@@ -197,6 +214,7 @@ Go内置有一个`error`类型，专门用来处理错误信息，Go的`package`
 
 例如下面的代码：
 ```Go
+
 	import "fmt"
 	import "os"
 
@@ -210,6 +228,7 @@ Go内置有一个`error`类型，专门用来处理错误信息，Go的`package`
 ```
 可以分组写成如下形式：
 ```Go
+
 	import(
 		"fmt"
 		"os"
@@ -265,10 +284,12 @@ Go之所以会那么简洁，是因为它有一些默认的行为：
 ### array
 `array`就是数组，它的定义方式如下：
 ```Go
+
 	var arr [n]type
 ```
 在`[n]type`中，`n`表示数组的长度，`type`表示存储元素的类型。对数组的操作和其它语言类似，都是通过`[]`来进行读取或赋值：
 ```Go
+
 	var arr [10]int  // 声明了一个int类型的数组
 	arr[0] = 42      // 数组下标是从0开始的
 	arr[1] = 13      // 赋值操作
@@ -319,6 +340,7 @@ Go之所以会那么简洁，是因为它有一些默认的行为：
 ```
 `slice`可以从一个数组或一个已经存在的`slice`中再次声明。`slice`通过`array[i:j]`来获取，其中`i`是数组的开始位置，`j`是结束位置，但不包含`array[j]`，它的长度是`j-i`。
 ```Go
+
 	// 声明一个含有10个元素元素类型为byte的数组
 	var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
 
@@ -425,6 +447,7 @@ slice有一些简便的操作
 
 	fmt.Println("第三个数字是: ", numbers["three"]) // 读取数据
 	// 打印出来如:第三个数字是: 3
+```
 
 这个`map`就像我们平常看到的表格一样，左边列是`key`，右边列是值
 
@@ -438,6 +461,7 @@ slice有一些简便的操作
 `map`的初始化可以通过`key:val`的方式初始化值，同时`map`内置有判断是否存在`key`的方式
 
 通过`delete`删除`map`的元素：
+
 ```Go
 
 	// 初始化一个字典

zh/02.3.md

@@ -6,6 +6,7 @@
 `if`也许是各种编程语言中最常见的了，它的语法概括起来就是：如果满足条件就做某事，否则做另一件事。
 
 Go里面`if`条件判断语句中不需要括号，如下代码所示
+```Go
 
 	if x > 10 {
 		fmt.Println("x is greater than 10")
@@ -14,6 +15,7 @@ Go里面`if`条件判断语句中不需要括号，如下代码所示
 	}
 
 Go的`if`还有一个强大的地方就是条件判断语句里面允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了，如下所示
+```Go
 
 	// 计算获取值x,然后根据x返回的大小，判断是否大于10。
 	if x := computedValue(); x > 10 {
@@ -24,8 +26,9 @@ Go的`if`还有一个强大的地方就是条件判断语句里面允许声明
 
 	//这个地方如果这样调用就编译出错了，因为x是条件里面的变量
 	fmt.Println(x)
-
+```
 多个条件的时候如下所示：
+```Go
 
 	if integer == 3 {
 		fmt.Println("The integer is equal to 3")
@@ -34,10 +37,11 @@ Go的`if`还有一个强大的地方就是条件判断语句里面允许声明
 	} else {
 		fmt.Println("The integer is greater than 3")
 	}
-
+```
 ### goto
 
 Go有`goto`语句——请明智地使用它。用`goto`跳转到必须在当前函数内定义的标签。例如假设这样一个循环：
+```Go
 
 	func myFunc() {
 		i := 0
@@ -46,19 +50,21 @@ Go有`goto`语句——请明智地使用它。用`goto`跳转到必须在当前
 		i++
 		goto Here   //跳转到Here去
 	}
-
+```
 >标签名是大小写敏感的。
 
 ### for
 Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读取数据，又可以当作`while`来控制逻辑，还能迭代操作。它的语法如下：
+```Go
 
 	for expression1; expression2; expression3 {
 		//...
 	}
-
+```
 `expression1`、`expression2`和`expression3`都是表达式，其中`expression1`和`expression3`是变量声明或者函数调用返回值之类的，`expression2`是用来条件判断，`expression1`在循环开始之前调用，`expression3`在每轮循环结束之时调用。
 
 一个例子比上面讲那么多更有用，那么我们看看下面的例子吧：
+```Go
 
 	package main
 	import "fmt"
@@ -71,25 +77,28 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 		fmt.Println("sum is equal to ", sum)
 	}
 	// 输出：sum is equal to 45
-
+```
 有些时候需要进行多个赋值操作，由于Go里面没有`,`操作符，那么可以使用平行赋值`i, j = i+1, j-1`
 
 
 有些时候如果我们忽略`expression1`和`expression3`：
+```Go
 
 	sum := 1
 	for ; sum < 1000;  {
 		sum += sum
 	}
-
+```
 其中`;`也可以省略，那么就变成如下的代码了，是不是似曾相识？对，这就是`while`的功能。
+```Go
 
 	sum := 1
 	for sum < 1000 {
 		sum += sum
 	}
-
+```
 在循环里面有两个关键操作`break`和`continue`	,`break`操作是跳出当前循环，`continue`是跳过本次循环。当嵌套过深的时候，`break`可以配合标签使用，即跳转至标签所指定的位置，详细参考如下例子：
+```Go
 
 	for index := 10; index>0; index-- {
 		if index == 5{
@@ -99,26 +108,29 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 	}
 	// break打印出来10、9、8、7、6
 	// continue打印出来10、9、8、7、6、4、3、2、1
-
+```
 `break`和`continue`还可以跟着标号，用来跳到多重循环中的外层循环
 
 `for`配合`range`可以用于读取`slice`和`map`的数据：
+```Go
 
 	for k,v:=range map {
 		fmt.Println("map's key:",k)
 		fmt.Println("map's val:",v)
 	}
-
+```
 由于 Go 支持 “多值返回”, 而对于“声明而未被调用”的变量, 编译器会报错, 在这种情况下, 可以使用`_`来丢弃不需要的返回值
 例如
+```Go
 
 	for _, v := range map{
 		fmt.Println("map's val:", v)
 	}
 
-
+```
 ### switch
 有些时候你需要写很多的`if-else`来实现一些逻辑处理，这个时候代码看上去就很丑很冗长，而且也不易于以后的维护，这个时候`switch`就能很好的解决这个问题。它的语法如下
+```Go
 
 	switch sExpr {
 	case expr1:
@@ -130,8 +142,9 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 	default:
 		other code
 	}
-
+```
 `sExpr`和`expr1`、`expr2`、`expr3`的类型必须一致。Go的`switch`非常灵活，表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项；而如果`switch`没有表达式，它会匹配`true`。
+```Go
 
 	i := 10
 	switch i {
@@ -144,8 +157,9 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 	default:
 		fmt.Println("All I know is that i is an integer")
 	}
-
+```
 在第5行中，我们把很多值聚合在了一个`case`里面，同时，Go里面`switch`默认相当于每个`case`最后带有`break`，匹配成功后不会自动向下执行其他case，而是跳出整个`switch`, 但是可以使用`fallthrough`强制执行后面的case代码。
+```Go
 
 	integer := 6
 	switch integer {
@@ -167,24 +181,26 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 	default:
 		fmt.Println("default case")
 	}
-
+```
 上面的程序将输出
+```Go
 
 	The integer was <= 6
 	The integer was <= 7
 	The integer was <= 8
 	default case
 
-
+```
 ## 函数
 函数是Go里面的核心设计，它通过关键字`func`来声明，它的格式如下：
+```Go
 
 	func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
 		//这里是处理逻辑代码
 		//返回多个值
 		return value1, value2
 	}
-
+```
 上面的代码我们看出
 
 - 关键字`func`用来声明一个函数`funcName`
@@ -196,6 +212,7 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 - 如果有返回值， 那么必须在函数的外层添加return语句
 
 下面我们来看一个实际应用函数的例子（用来计算Max值）
+```Go
 
 	package main
 	import "fmt"
@@ -220,13 +237,14 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 		fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
 		fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // 也可在这直接调用它
 	}
-
+```
 上面这个里面我们可以看到`max`函数有两个参数，它们的类型都是`int`，那么第一个变量的类型可以省略（即 a,b int,而非 a int, b int)，默认为离它最近的类型，同理多于2个同类型的变量或者返回值。同时我们注意到它的返回值就是一个类型，这个就是省略写法。
 
 ### 多个返回值
 Go语言比C更先进的特性，其中一点就是函数能够返回多个值。
 
 我们直接上代码看例子
+```Go
 
 	package main
 	import "fmt"
@@ -245,29 +263,34 @@ Go语言比C更先进的特性，其中一点就是函数能够返回多个值
 		fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
 		fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
 	}
-
+```
 上面的例子我们可以看到直接返回了两个参数，当然我们也可以命名返回参数的变量，这个例子里面只是用了两个类型，我们也可以改成如下这样的定义，然后返回的时候不用带上变量名，因为直接在函数里面初始化了。但如果你的函数是导出的(首字母大写)，官方建议：最好命名返回值，因为不命名返回值，虽然使得代码更加简洁了，但是会造成生成的文档可读性差。
+```Go
 
 	func SumAndProduct(A, B int) (add int, Multiplied int) {
 		add = A+B
 		Multiplied = A*B
 		return
 	}
-
+```
 ### 变参
 Go函数支持变参。接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义函数使其接受变参：
+```Go
 
 	func myfunc(arg ...int) {}
+```
 `arg ...int`告诉Go这个函数接受不定数量的参数。注意，这些参数的类型全部是`int`。在函数体中，变量`arg`是一个`int`的`slice`：
+```Go
 
 	for _, n := range arg {
 		fmt.Printf("And the number is: %d\n", n)
 	}
-
+```
 ### 传值与传指针
 当我们传一个参数值到被调用函数里面时，实际上是传了这个值的一份copy，当在被调用函数中修改参数值的时候，调用函数中相应实参不会发生任何变化，因为数值变化只作用在copy上。
 
 为了验证我们上面的说法，我们来看一个例子
+```Go
 
 	package main
 	import "fmt"
@@ -288,7 +311,7 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。
 		fmt.Println("x+1 = ", x1) // 应该输出"x+1 = 4"
 		fmt.Println("x = ", x)    // 应该输出"x = 3"
 	}
-
+```
 看到了吗？虽然我们调用了`add1`函数，并且在`add1`中执行`a = a+1`操作，但是上面例子中`x`变量的值没有发生变化
 
 理由很简单：因为当我们调用`add1`的时候，`add1`接收的参数其实是`x`的copy，而不是`x`本身。
@@ -296,6 +319,7 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。
 那你也许会问了，如果真的需要传这个`x`本身,该怎么办呢？
 
 这就牵扯到了所谓的指针。我们知道，变量在内存中是存放于一定地址上的，修改变量实际是修改变量地址处的内存。只有`add1`函数知道`x`变量所在的地址，才能修改`x`变量的值。所以我们需要将`x`所在地址`&x`传入函数，并将函数的参数的类型由`int`改为`*int`，即改为指针类型，才能在函数中修改`x`变量的值。此时参数仍然是按copy传递的，只是copy的是一个指针。请看下面的例子
+```Go
 
 	package main
 	import "fmt"
@@ -316,7 +340,7 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。
 		fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
 		fmt.Println("x = ", x)    // 应该输出 "x = 4"
 	}
-
+```
 这样，我们就达到了修改`x`的目的。那么到底传指针有什么好处呢？
 
 - 传指针使得多个函数能操作同一个对象。
@@ -325,6 +349,7 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。
 
 ### defer
 Go语言中有种不错的设计，即延迟（defer）语句，你可以在函数中添加多个defer语句。当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回。特别是当你在进行一些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题。如下代码所示，我们一般写打开一个资源是这样操作的：
+```Go
 
 	func ReadWrite() bool {
 		file.Open("file")
@@ -342,8 +367,9 @@ Go语言中有种不错的设计，即延迟（defer）语句，你可以在函
 		file.Close()
 		return true
 	}
-
+```
 我们看到上面有很多重复的代码，Go的`defer`有效解决了这个问题。使用它后，不但代码量减少了很多，而且程序变得更优雅。在`defer`后指定的函数会在函数退出前调用。
+```Go
 
 	func ReadWrite() bool {
 		file.Open("file")
@@ -356,13 +382,14 @@ Go语言中有种不错的设计，即延迟（defer）语句，你可以在函
 		}
 		return true
 	}
-
+```
 如果有很多调用`defer`，那么`defer`是采用后进先出模式，所以如下代码会输出`4 3 2 1 0`
+```Go
 
 	for i := 0; i < 5; i++ {
 		defer fmt.Printf("%d ", i)
 	}
-
+```
 ### 函数作为值、类型
 
 在Go中函数也是一种变量，我们可以通过`type`来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型
@@ -370,6 +397,7 @@ Go语言中有种不错的设计，即延迟（defer）语句，你可以在函
 	type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...])
 
 函数作为类型到底有什么好处呢？那就是可以把这个类型的函数当做值来传递，请看下面的例子
+```Go
 
 	package main
 	import "fmt"
@@ -410,7 +438,7 @@ Go语言中有种不错的设计，即延迟（defer）语句，你可以在函
 		even := filter(slice, isEven)  // 函数当做值来传递了
 		fmt.Println("Even elements of slice are: ", even)
 	}
-
+```
 函数当做值和类型在我们写一些通用接口的时候非常有用，通过上面例子我们看到`testInt`这个类型是一个函数类型，然后两个`filter`函数的参数和返回值与`testInt`类型是一样的，但是我们可以实现很多种的逻辑，这样使得我们的程序变得非常的灵活。
 
 ### Panic和Recover
@@ -424,6 +452,7 @@ Recover
 >是一个内建的函数，可以让进入令人恐慌的流程中的`goroutine`恢复过来。`recover`仅在延迟函数中有效。在正常的执行过程中，调用`recover`会返回`nil`，并且没有其它任何效果。如果当前的`goroutine`陷入恐慌，调用`recover`可以捕获到`panic`的输入值，并且恢复正常的执行。
 
 下面这个函数演示了如何在过程中使用`panic`
+```Go
 
 	var user = os.Getenv("USER")
 
@@ -432,8 +461,9 @@ Recover
 			panic("no value for $USER")
 		}
 	}
-
+```
 下面这个函数检查作为其参数的函数在执行时是否会产生`panic`：
+```Go
 
 	func throwsPanic(f func()) (b bool) {
 		defer func() {
@@ -444,7 +474,7 @@ Recover
 		f() //执行函数f，如果f中出现了panic，那么就可以恢复回来
 		return
 	}
-
+```
 ### `main`函数和`init`函数
 
 Go里面有两个保留的函数：`init`函数（能够应用于所有的`package`）和`main`函数（只能应用于`package main`）。这两个函数在定义时不能有任何的参数和返回值。虽然一个`package`里面可以写任意多个`init`函数，但这无论是对于可读性还是以后的可维护性来说，我们都强烈建议用户在一个`package`中每个文件只写一个`init`函数。
@@ -459,15 +489,17 @@ Go程序会自动调用`init()`和`main()`，所以你不需要在任何地方
 
 ### import
 我们在写Go代码的时候经常用到import这个命令用来导入包文件，而我们经常看到的方式参考如下：
+```Go
 
 	import(
 	    "fmt"
 	)
-
+```
 然后我们代码里面可以通过如下的方式调用
+```Go
 
 	fmt.Println("hello world")
-
+```
 上面这个fmt是Go语言的标准库，其实是去`GOROOT`环境变量指定目录下去加载该模块，当然Go的import还支持如下两种方式来加载自己写的模块：
 
 1. 相对路径
@@ -505,12 +537,13 @@ Go程序会自动调用`init()`和`main()`，所以你不需要在任何地方
 3. _操作
 
 	这个操作经常是让很多人费解的一个操作符，请看下面这个import
-	
+```Go
+
 		import (
 		    "database/sql"
 		    _ "github.com/ziutek/mymysql/godrv"
 		)
-		
+```	
 	_操作其实是引入该包，而不直接使用包里面的函数，而是调用了该包里面的init函数。