Add syntax highlighting

zh/02.1.md

@@ -8,6 +8,7 @@
 
 准备好了吗？Let's Go!
 ```Go
+
 	package main
 
 	import "fmt"

zh/02.5.md

@@ -3,6 +3,7 @@
 
 ## method
 现在假设有这么一个场景，你定义了一个struct叫做长方形，你现在想要计算他的面积，那么按照我们一般的思路应该会用下面的方式来实现
+```Go
 
 	package main
 	import "fmt"
@@ -21,7 +22,7 @@
 		fmt.Println("Area of r1 is: ", area(r1))
 		fmt.Println("Area of r2 is: ", area(r2))
 	}
-
+```
 这段代码可以计算出来长方形的面积，但是area()不是作为Rectangle的方法实现的（类似面向对象里面的方法），而是将Rectangle的对象（如r1,r2）作为参数传入函数计算面积的。
 
 这样实现当然没有问题咯，但是当需要增加圆形、正方形、五边形甚至其它多边形的时候，你想计算他们的面积的时候怎么办啊？那就只能增加新的函数咯，但是函数名你就必须要跟着换了，变成`area_rectangle, area_circle, area_triangle...`
@@ -49,6 +50,7 @@ method的语法如下：
 	func (r ReceiverType) funcName(parameters) (results)
 
 下面我们用最开始的例子用method来实现：
+```Go
 
 	package main
 	import (
@@ -85,7 +87,7 @@ method的语法如下：
 		fmt.Println("Area of c2 is: ", c2.area())
 	}
 
-
+```
 
 在使用method的时候重要注意几点
 
@@ -104,10 +106,12 @@ method的语法如下：
 >值得说明的一点是，图示中method用虚线标出，意思是此处方法的Receiver是以值传递，而非引用传递，是的，Receiver还可以是指针, 两者的差别在于, 指针作为Receiver会对实例对象的内容发生操作,而普通类型作为Receiver仅仅是以副本作为操作对象,并不对原实例对象发生操作。后文对此会有详细论述。
 
 那是不是method只能作用在struct上面呢？当然不是咯，他可以定义在任何你自定义的类型、内置类型、struct等各种类型上面。这里你是不是有点迷糊了，什么叫自定义类型，自定义类型不就是struct嘛，不是这样的哦，struct只是自定义类型里面一种比较特殊的类型而已，还有其他自定义类型申明，可以通过如下这样的申明来实现。
+```Go
 
 	type typeName typeLiteral
-
+```
 请看下面这个申明自定义类型的代码
+```Go
 
 	type ages int
 
@@ -121,12 +125,13 @@ method的语法如下：
 		...
 		"December":31,
 	}
-
+```
 看到了吗？简单的很吧，这样你就可以在自己的代码里面定义有意义的类型了，实际上只是一个定义了一个别名,有点类似于c中的typedef，例如上面ages替代了int
 
 好了，让我们回到`method`
 
 你可以在任何的自定义类型中定义任意多的`method`，接下来让我们看一个复杂一点的例子
+```Go
 
 	package main
 	import "fmt"
@@ -200,7 +205,7 @@ method的语法如下：
 
 		fmt.Println("Obviously, now, the biggest one is", boxes.BiggestColor().String())
 	}
-
+```
 上面的代码通过const定义了一些常量，然后定义了一些自定义类型
 
 - Color作为byte的别名
@@ -242,6 +247,7 @@ method的语法如下：
 
 ### method继承
 前面一章我们学习了字段的继承，那么你也会发现Go的一个神奇之处，method也是可以继承的。如果匿名字段实现了一个method，那么包含这个匿名字段的struct也能调用该method。让我们来看下面这个例子
+```Go
 
 	package main
 	import "fmt"
@@ -274,9 +280,10 @@ method的语法如下：
 		mark.SayHi()
 		sam.SayHi()
 	}
-
+```
 ### method重写
 上面的例子中，如果Employee想要实现自己的SayHi,怎么办？简单，和匿名字段冲突一样的道理，我们可以在Employee上面定义一个method，重写了匿名字段的方法。请看下面的例子
+```Go
 
 	package main
 	import "fmt"
@@ -315,7 +322,7 @@ method的语法如下：
 		mark.SayHi()
 		sam.SayHi()
 	}
-
+```
 上面的代码设计的是如此的美妙，让人不自觉的为Go的设计惊叹！
 
 通过这些内容，我们可以设计出基本的面向对象的程序了，但是Go里面的面向对象是如此的简单，没有任何的私有、公有关键字，通过大小写来实现(大写开头的为公有，小写开头的为私有)，方法也同样适用这个原则。

zh/02.6.md

@@ -14,6 +14,7 @@ Go语言里面设计最精妙的应该算interface，它让面向对象，内容
 上面这些方法的组合称为interface(被对象Student和Employee实现)。例如Student和Employee都实现了interface：SayHi和Sing，也就是这两个对象是该interface类型。而Employee没有实现这个interface：SayHi、Sing和BorrowMoney，因为Employee没有实现BorrowMoney这个方法。
 ### interface类型
 interface类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。详细的语法参考下面这个例子
+```Go
 
 	type Human struct {
 		name string
@@ -82,7 +83,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 		Sing(song string)
 		SpendSalary(amount float32)
 	}
-
+```
 通过上面的代码我们可以知道，interface可以被任意的对象实现。我们看到上面的Men interface被Human、Student和Employee实现。同理，一个对象可以实现任意多个interface，例如上面的Student实现了Men和YoungChap两个interface。
 
 最后，任意的类型都实现了空interface(我们这样定义：interface{})，也就是包含0个method的interface。
@@ -93,6 +94,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 因为m能够持有这三种类型的对象，所以我们可以定义一个包含Men类型元素的slice，这个slice可以被赋予实现了Men接口的任意结构的对象，这个和我们传统意义上面的slice有所不同。
 
 让我们来看一下下面这个例子:
+```Go
 
 	package main
 	import "fmt"
@@ -169,11 +171,12 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 			value.SayHi()
 		}
 	}
-
+```
 通过上面的代码，你会发现interface就是一组抽象方法的集合，它必须由其他非interface类型实现，而不能自我实现， Go通过interface实现了duck-typing:即"当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子"。
 
 ### 空interface
 空interface(interface{})不包含任何的method，正因为如此，所有的类型都实现了空interface。空interface对于描述起不到任何的作用(因为它不包含任何的method），但是空interface在我们需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。它有点类似于C语言的void*类型。
+```Go
 
 	// 定义a为空接口
 	var a interface{}
@@ -182,17 +185,20 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 	// a可以存储任意类型的数值
 	a = i
 	a = s
-
+```
 一个函数把interface{}作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的值。是不是很有用啊！
 ### interface函数参数
 interface的变量可以持有任意实现该interface类型的对象，这给我们编写函数(包括method)提供了一些额外的思考，我们是不是可以通过定义interface参数，让函数接受各种类型的参数。
 
 举个例子：fmt.Println是我们常用的一个函数，但是你是否注意到它可以接受任意类型的数据。打开fmt的源码文件，你会看到这样一个定义:
+```Go
 
 	type Stringer interface {
 		 String() string
 	}
+```	
 也就是说，任何实现了String方法的类型都能作为参数被fmt.Println调用,让我们来试一试
+```Go
 
 	package main
 	import (
@@ -215,12 +221,14 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 		Bob := Human{"Bob", 39, "000-7777-XXX"}
 		fmt.Println("This Human is : ", Bob)
 	}
+```	
 现在我们再回顾一下前面的Box示例，你会发现Color结构也定义了一个method：String。其实这也是实现了fmt.Stringer这个interface，即如果需要某个类型能被fmt包以特殊的格式输出，你就必须实现Stringer这个接口。如果没有实现这个接口，fmt将以默认的方式输出。
+```Go
 
 	//实现同样的功能
 	fmt.Println("The biggest one is", boxes.BiggestsColor().String())
 	fmt.Println("The biggest one is", boxes.BiggestsColor())
-
+```
 注：实现了error接口的对象（即实现了Error() string的对象），使用fmt输出时，会调用Error()方法，因此不必再定义String()方法了。
 ### interface变量存储的类型
 
@@ -233,6 +241,7 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 	如果element里面确实存储了T类型的数值，那么ok返回true，否则返回false。
 
 	让我们通过一个例子来更加深入的理解。
+```Go
 
 		package main
 
@@ -272,13 +281,14 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 				}
 			}
 		}
-
+```
 	是不是很简单啊，同时你是否注意到了多个if里面，还记得我前面介绍流程时讲过，if里面允许初始化变量。
 
 	也许你注意到了，我们断言的类型越多，那么if else也就越多，所以才引出了下面要介绍的switch。
 - switch测试
 
 	最好的讲解就是代码例子，现在让我们重写上面的这个实现
+```Go
 
 		package main
 
@@ -319,21 +329,23 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 				}
 			}
 		}
-
+```
 	这里有一点需要强调的是：`element.(type)`语法不能在switch外的任何逻辑里面使用，如果你要在switch外面判断一个类型就使用`comma-ok`。
 
 ### 嵌入interface
 Go里面真正吸引人的是它内置的逻辑语法，就像我们在学习Struct时学习的匿名字段，多么的优雅啊，那么相同的逻辑引入到interface里面，那不是更加完美了。如果一个interface1作为interface2的一个嵌入字段，那么interface2隐式的包含了interface1里面的method。
 
 我们可以看到源码包container/heap里面有这样的一个定义
+```Go
 
 	type Interface interface {
 		sort.Interface //嵌入字段sort.Interface
 		Push(x interface{}) //a Push method to push elements into the heap
 		Pop() interface{} //a Pop elements that pops elements from the heap
 	}
-
+```
 我们看到sort.Interface其实就是嵌入字段，把sort.Interface的所有method给隐式的包含进来了。也就是下面三个方法：
+```Go
 
 	type Interface interface {
 		// Len is the number of elements in the collection.
@@ -344,49 +356,55 @@ Go里面真正吸引人的是它内置的逻辑语法，就像我们在学习Str
 		// Swap swaps the elements with indexes i and j.
 		Swap(i, j int)
 	}
-
+```
 另一个例子就是io包下面的 io.ReadWriter ，它包含了io包下面的Reader和Writer两个interface：
+```Go
 
 	// io.ReadWriter
 	type ReadWriter interface {
 		Reader
 		Writer
 	}
-
+```
 ### 反射
 Go语言实现了反射，所谓反射就是能检查程序在运行时的状态。我们一般用到的包是reflect包。如何运用reflect包，官方的这篇文章详细的讲解了reflect包的实现原理，[laws of reflection](http://golang.org/doc/articles/laws_of_reflection.html)
 
 使用reflect一般分成三步，下面简要的讲解一下：要去反射是一个类型的值(这些值都实现了空interface)，首先需要把它转化成reflect对象(reflect.Type或者reflect.Value，根据不同的情况调用不同的函数)。这两种获取方式如下：
+```Go
 
 	t := reflect.TypeOf(i)    //得到类型的元数据,通过t我们能获取类型定义里面的所有元素
 	v := reflect.ValueOf(i)   //得到实际的值，通过v我们获取存储在里面的值，还可以去改变值
-
+```
 转化为reflect对象之后我们就可以进行一些操作了，也就是将reflect对象转化成相应的值，例如
+```Go
 
 	tag := t.Elem().Field(0).Tag  //获取定义在struct里面的标签
 	name := v.Elem().Field(0).String()  //获取存储在第一个字段里面的值
-
+```
 获取反射值能返回相应的类型和数值
+```Go
 
 	var x float64 = 3.4
 	v := reflect.ValueOf(x)
 	fmt.Println("type:", v.Type())
 	fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
 	fmt.Println("value:", v.Float())
-
+```
 最后，反射的话，那么反射的字段必须是可修改的，我们前面学习过传值和传引用，这个里面也是一样的道理。反射的字段必须是可读写的意思是，如果下面这样写，那么会发生错误
+```Go
 
 	var x float64 = 3.4
 	v := reflect.ValueOf(x)
 	v.SetFloat(7.1)
-
+```
 如果要修改相应的值，必须这样写
+```Go
 
 	var x float64 = 3.4
 	p := reflect.ValueOf(&x)
 	v := p.Elem()
 	v.SetFloat(7.1)
-
+```
 上面只是对反射的简单介绍，更深入的理解还需要自己在编程中不断的实践。
 
 ## links

zh/02.7.md

@@ -7,10 +7,12 @@
 goroutine是Go并行设计的核心。goroutine说到底其实就是线程，但是它比线程更小，十几个goroutine可能体现在底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大概是4~5KB)，当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。
 
 goroutine是通过Go的runtime管理的一个线程管理器。goroutine通过`go`关键字实现了，其实就是一个普通的函数。
+```Go
 
 	go hello(a, b, c)
-
+```
 通过关键字go就启动了一个goroutine。我们来看一个例子
+```Go
 
 	package main
 
@@ -41,7 +43,7 @@ goroutine是通过Go的runtime管理的一个线程管理器。goroutine通过`g
 	// hello
 	// world
 	// hello
-
+```
 我们可以看到go关键字很方便的就实现了并发编程。
 上面的多个goroutine运行在同一个进程里面，共享内存数据，不过设计上我们要遵循：不要通过共享来通信，而要通过通信来共享。
 
@@ -51,17 +53,20 @@ goroutine是通过Go的runtime管理的一个线程管理器。goroutine通过`g
 
 ## channels
 goroutine运行在相同的地址空间，因此访问共享内存必须做好同步。那么goroutine之间如何进行数据的通信呢，Go提供了一个很好的通信机制channel。channel可以与Unix shell 中的双向管道做类比：可以通过它发送或者接收值。这些值只能是特定的类型：channel类型。定义一个channel时，也需要定义发送到channel的值的类型。注意，必须使用make 创建channel：
+```Go
 
 	ci := make(chan int)
 	cs := make(chan string)
 	cf := make(chan interface{})
-
+```
 channel通过操作符`<-`来接收和发送数据
+```Go
 
 	ch <- v    // 发送v到channel ch.
 	v := <-ch  // 从ch中接收数据，并赋值给v
-
+```
 我们把这些应用到我们的例子中来：
+```Go
 
 	package main
 
@@ -85,18 +90,19 @@ channel通过操作符`<-`来接收和发送数据
 
 		fmt.Println(x, y, x + y)
 	}
-
+```
 默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得Goroutines同步变的更加的简单，而不需要显式的lock。所谓阻塞，也就是如果读取（value := <-ch）它将会被阻塞，直到有数据接收。其次，任何发送（ch<-5）将会被阻塞，直到数据被读出。无缓冲channel是在多个goroutine之间同步很棒的工具。
 
 ## Buffered Channels
 上面我们介绍了默认的非缓存类型的channel，不过Go也允许指定channel的缓冲大小，很简单，就是channel可以存储多少元素。ch:= make(chan bool, 4)，创建了可以存储4个元素的bool 型channel。在这个channel 中，前4个元素可以无阻塞的写入。当写入第5个元素时，代码将会阻塞，直到其他goroutine从channel 中读取一些元素，腾出空间。
+```Go
 
 	ch := make(chan type, value)
-
+```
 当 value = 0 时，channel 是无缓冲阻塞读写的，当value > 0 时，channel 有缓冲、是非阻塞的，直到写满 value 个元素才阻塞写入。
 
 我们看一下下面这个例子，你可以在自己本机测试一下，修改相应的value值
-
+```Go
 
 	package main
 
@@ -111,9 +117,10 @@ channel通过操作符`<-`来接收和发送数据
 	}
         //修改为1报如下的错误:
         //fatal error: all goroutines are asleep - deadlock!
-
+```
 ## Range和Close
 上面这个例子中，我们需要读取两次c，这样不是很方便，Go考虑到了这一点，所以也可以通过range，像操作slice或者map一样操作缓存类型的channel，请看下面的例子
+```Go
 
 	package main
 
@@ -137,7 +144,7 @@ channel通过操作符`<-`来接收和发送数据
 			fmt.Println(i)
 		}
 	}
-
+```
 `for i := range c`能够不断的读取channel里面的数据，直到该channel被显式的关闭。上面代码我们看到可以显式的关闭channel，生产者通过内置函数`close`关闭channel。关闭channel之后就无法再发送任何数据了，在消费方可以通过语法`v, ok := <-ch`测试channel是否被关闭。如果ok返回false，那么说明channel已经没有任何数据并且已经被关闭。
 
 >记住应该在生产者的地方关闭channel，而不是消费的地方去关闭它，这样容易引起panic
@@ -148,6 +155,7 @@ channel通过操作符`<-`来接收和发送数据
 我们上面介绍的都是只有一个channel的情况，那么如果存在多个channel的时候，我们该如何操作呢，Go里面提供了一个关键字`select`，通过`select`可以监听channel上的数据流动。
 
 `select`默认是阻塞的，只有当监听的channel中有发送或接收可以进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的。
+```Go
 
 	package main
 
@@ -177,8 +185,9 @@ channel通过操作符`<-`来接收和发送数据
 		}()
 		fibonacci(c, quit)
 	}
-
+```
 在`select`里面还有default语法，`select`其实就是类似switch的功能，default就是当监听的channel都没有准备好的时候，默认执行的（select不再阻塞等待channel）。
+```Go
 
 	select {
 	case i := <-c:
@@ -186,9 +195,10 @@ channel通过操作符`<-`来接收和发送数据
 	default:
 		// 当c阻塞的时候执行这里
 	}
-
+```
 ## 超时
 有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下的方式实现：
+```Go
 
 	func main() {
 		c := make(chan int)
@@ -207,7 +217,7 @@ channel通过操作符`<-`来接收和发送数据
 		}()
 		<- o
 	}
-
+```
 
 ## runtime goroutine
 runtime包中有几个处理goroutine的函数：

zh/02.8.md

@@ -1,13 +1,14 @@
 # 2.8 总结
 
 这一章我们主要介绍了Go语言的一些语法，通过语法我们可以发现Go是多么的简单，只有二十五个关键字。让我们再来回顾一下这些关键字都是用来干什么的。
+```Go
 
 	break    default      func    interface    select
 	case     defer        go      map          struct
 	chan     else         goto    package      switch
 	const    fallthrough  if      range        type
 	continue for          import  return       var
-
+```
 - var和const参考2.2Go语言基础里面的变量和常量申明
 - package和import已经有过短暂的接触
 - func 用于定义函数和方法