Add syntax highlighting

Author: vcaesar

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,13 +166,15 @@ Go 常量和一般程序语言不同的是，可以指定相当多的小数位
 
 Go中可以使用`+`操作符来连接两个字符串：
 ```Go
+
 	s := "hello,"
 	m := " world"
 	a := s + m
 	fmt.Printf("%s\n", a)
 ```
 修改字符串也可写为：
 ```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
 
 	// 初始化一个字典