review 2.x

Author: hongruiqi

2.4.md

@@ -79,7 +79,7 @@ Go语言中，也和C或者其他语言一样，我们可以声明新的类型
 	}
 
 ###strcut的匿名字段
-我们上面介绍了如何定义一个strcut，定义的时候是字段名与其类型一一对应，实际上Go支持只提供类型，而不写字段名的方式，也就是匿名字段。
+我们上面介绍了如何定义一个strcut，定义的时候是字段名与其类型一一对应，实际上Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段。
 
 当匿名字段是一个strcut的时候，那么这个strcut所拥有的全部字段都被隐式地引入了当前定义的这个strcut。
 

2.5.md

@@ -183,7 +183,7 @@ method的语法如下：
 
 - Color作为byte的别名
 - 定义了一个struct:Box，含有三个长宽高字段和一个颜色属性
-- 定义了一个slice:BoxList，含有box
+- 定义了一个slice:BoxList，含有Box
 
 然后我们定义了一些method在这些类型上面
 
@@ -208,7 +208,7 @@ method的语法如下：
 
 也许细心的读者会问这样的问题，PaintItBlack里面调用SetColor的时候是不是应该写成`(&bl[i]).SetColor(BLACK)`，因为SetColor的receiver是*Box，而不是Box。
 
-你又说对的，这两种方式都可以，因为Go知道receiver是指针，他自动被你转了。
+你又说对的，这两种方式都可以，因为Go知道receiver是指针，他自动帮你转了。
 
 也就是说：
 >如果一个method的receiver是*T,你可以在一个T类型的变量V上面调用这个method，而不需要&V去调用这个method

2.6.md

@@ -1,7 +1,7 @@
 #2.6interface
 
 ##interface
-Go语言里面设计最精妙的应该算interface，它让面向对象，内容组织实现非常的方便，当你看完这一章，你就会被interface的巧妙设计所折服。
+Go语言里面设计最精妙的应该算interface，它让面向对象，内容组织实现非常的方便，当你看完这一章，你就会被interface的巧妙设计所折服。
 ###什么是interface
 简单的说，interface是一组method的组合，我们通过interface来定义对象的一组行为。
 
@@ -11,7 +11,7 @@ Go语言里面设计最精妙的应该算interface，它让面向对象，内容
 
 这样Student实现了三个方法：Sayhi、Sing、BorrowMoney；而Employee实现了Sayhi、Sing、SpendSalary。
 
-上面这些方法的组合称为interface(被对象Student和Employee实现)。例如Student和Employee都实现了interface：Sayhi和Sing，也就是这两个对象是该interface类型。而Employee没有实现这个interface：Sayhi、Sing和BorrowMoney，因为Employee没有实现BorrowMoney这个方法。
+上面这些方法的组合称为interface(被对象Student和Employee实现)。例如Student和Employee都实现了interface：Sayhi和Sing，也就是这两个对象是该interface类型。而Employee没有实现这个interface：Sayhi、Sing和BorrowMoney，因为Employee没有实现BorrowMoney这个方法。
 ###interface类型
 interface类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。详细的语法参考下面这个例子
 
@@ -86,11 +86,11 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 通过上面的代码我们可以知道，interface可以被任意的对象实现。我们看到上面的Men interface被Human、Student和Employee实现。同理，一个对象可以实现任意多个interface，例如上面的Student实现了Men和YonggChap两个interface。
 
 最后，任意的类型都实现了空interface(我们这样定义：interface{})，也就是包含0个method的interface。
-
+
 ###interface值
 那么interface里面到底能存什么值呢？如果我们定义了一个interface的变量，那么这个变量里面可以存实现这个interface的任意类型的对象。例如上面例子中，我们定义了一个Men interface类型的变量m，那么m里面可以存Human、Student或者Employee值。
 
-因为m能够持有这三种类型的对象，所以我们可以定义一个Men类型元素的slice，这个slice可以被赋予实现了Men接口的任意结构的对象，这个和我们传统意义上面的slice有所不同。
+因为m能够持有这三种类型的对象，所以我们可以定义一个包含Men类型元素的slice，这个slice可以被赋予实现了Men接口的任意结构的对象，这个和我们传统意义上面的slice有所不同。
 
 让我们来看一下下面这个例子
 
@@ -173,7 +173,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 通过上面的代码，你会发现interface就是一组抽象方法的集合，它必须由其他非interface类型实现，而不能自我实现， go 通过interface实现了duck-typing:即"当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子"。
 
 ###空interface
-空interface(interface{})不包含任何的method，正因为如此，所有的类型都实现了空interface。空interface对于描述起不到任何的作用(因为它不包含任何的method），但是空interface在我们需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。它有点类似于C语言叫的void*类型。
+空interface(interface{})不包含任何的method，正因为如此，所有的类型都实现了空interface。空interface对于描述起不到任何的作用(因为它不包含任何的method），但是空interface在我们需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。它有点类似于C语言的void*类型。
 
 	// 定义a为空接口
 	var a interface{}
@@ -183,7 +183,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 	a = i
 	a = s
 
-一个函数把interface{}作为参数，那么他可以接受任意类型的数值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的数值。是不是很有用啊！	
+一个函数把interface{}作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的值。是不是很有用啊！	
 ###interface函数参数
 interface的变量可以持有任意实现该interface类型的对象，这给我们编写函数(包括method)提供了一些额外的思考，我们是不是可以通过定义interface参数，让函数接受各种类型的参数。
 
@@ -192,7 +192,7 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 	type Stringer interface {
     	 String() string
 	}
-任何实现了String方法的类型都能调用fmt.Println,让我们来试一试
+任何实现了String方法的类型都能作为参数去调用fmt.Println,让我们来试一试
 
 	package main
 	import (
@@ -206,7 +206,7 @@ interface的变量可以持有任意实现该interface类型的对象，这给
     	phone string
 	}
 
-	//通过这个方法 Human 实现了 fmt.Stringer
+	// 通过这个方法 Human 实现了 fmt.Stringer
 	func (h Human) String() string {
 	    return "❰"+h.name+" - "+strconv.Itoa(h.age)+" years -  ✆ " +h.phone+"❱"
 	}
@@ -215,13 +215,13 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 	    Bob := Human{"Bob", 39, "000-7777-XXX"}
 	    fmt.Println("This Human is : ", Bob)
 	}
-现在我们再回顾一下前面的Box示例，你会发现Color结构也定义了一个method：String。其实这也是实现了fmt.Stringer这个interface,即如果需要自定义的类型能被fmt包输出，你就必须实现interface Stringer这个接口
+现在我们再回顾一下前面的Box示例，你会发现Color结构也定义了一个method：String。其实这也是实现了fmt.Stringer这个interface，即如果需要某个类型能被fmt包以特殊的格式输出，你就必须实现Stringer这个接口。如果没有实现这个接口，fmt将以默认的方式输出。
 
 	//实现同样的功能
 	fmt.Println("The biggest one is", boxes.BiggestsColor().String())
 	fmt.Println("The biggest one is", boxes.BiggestsColor())
 
-
+注：实现了error接口的对象（即实现了Error() string的对象），使用fmt输出时，会调用Error()方法，因此不必再定义String()方法了。
 ###interface变量存储的类型
 
 我们知道interface的变量里面可以存储任意类型的数值(该类型实现了interface)。那么我们怎么反向知道这个变量里面实际保存了的是哪个类型的对象呢？目前常用的有两种方法：
@@ -322,18 +322,18 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 		
 	这里有一点需要强调的是：`element.(type)`语法不能在switch外的任何逻辑里面使用，如果你要在switch外面判断一个类型就使用`comma-ok`。	
 
-###匿名interface
-Go里面真正吸引人的是他内置的逻辑语法，就像我们在学习Struct时学习的匿名字段，多么的优雅啊，那么相同的逻辑引入到interface里面，那不是更加完美了。如果一个interface1作为interface2的一个匿名字段，那么interface2隐式的包含了interface1里面的method。
+###嵌入interface
+Go里面真正吸引人的是他内置的逻辑语法，就像我们在学习Struct时学习的匿名字段，多么的优雅啊，那么相同的逻辑引入到interface里面，那不是更加完美了。如果一个interface1作为interface2的一个嵌入字段，那么interface2隐式的包含了interface1里面的method。
 
 我们可以看到源码包container/heap里面有这样的一个定义
 
 	type Interface interface {
-    	sort.Interface //匿名字段sort.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给隐式的包含进来了。也就是下面三个方法
+我们看到sort.Interface其实就是嵌入字段，把sort.Interface的所有method给隐式的包含进来了。也就是下面三个方法
 
 	type Interface interface {
     	// Len is the number of elements in the collection.
@@ -358,11 +358,14 @@ Go语言实现了反射，所谓反射就是动态运行时的状态。我们一
 
 下面我简要的讲解一下一般的使用，我们使用reflect大概的分成三步，首先我们要去反射是一个类型的值(这些值都实现了空interface)，需要把它转化成reflect对象(reflect.Type或者reflect.Value，根据不同的情况调用不同的函数)。这两种获取方式如下：
 
-	t := reflect.TypeOf(i)    //得到类型的元数据,通过t我们能获取类型定义里面的所有元素	v := reflect.ValueOf(i)   //得到实际的值，通过v我们获取存储在里面的值，还可以去改变值
+	t := reflect.TypeOf(i)    //得到类型的元数据,通过t我们能获取类型定义里面的所有元素
+	v := reflect.ValueOf(i)   //得到实际的值，通过v我们获取存储在里面的值，还可以去改变值
 
 获取这个对象之后我们就可以进行一些操作了，也就是reflect对象转化成相应的值，例如
 
-	tag := t.Elem().Field(0).Tag  //获取定义在strcut里面的标签	name := v.Elem().Field(0).String()  //获取存储在第一个字段里面的值	
+	tag := t.Elem().Field(0).Tag  //获取定义在strcut里面的标签
+	name := v.Elem().Field(0).String()  //获取存储在第一个字段里面的值
+	
 获取反射值能返回相应的类型和数值
 
 	var x float64 = 3.4

2.7.md

@@ -46,7 +46,9 @@ Goroutines是通过Go的runtime管理的一个线程管理器。Goroutines通过
 ##channels
 Goroutines运行在相同的地址空间，因此访问共享内存必须做好同步。那么Goroutines之间如何进行数据的通信呢，Go提供了一个很好的通信机制channel。channel可以与Unix shell 中的双向管道做类比：可以通过它发送或者接收值。这些值只能是特定的类型：channel类型。定义一个channel 时，也需要定义发送到channel 的值的类型。注意，必须使用make 创建channel：
 
-	ci := make(chan int)	cs := make(chan string)	cf := make(chan interface{})
+	ci := make(chan int)
+	cs := make(chan string)
+	cf := make(chan interface{})
 
 channel通过操作符`<-`来接收和发送数据
 
@@ -81,9 +83,17 @@ channel通过操作符`<-`来接收和发送数据
 默认情况下，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 中读取一些元素，腾出空间。	ch := make(chan type, value)		value == 0 ! 无缓冲（阻塞）	value > 0 ! 缓冲（非阻塞，直到value 个元素）	
-我们看一下下面这个例子，你可以在自己本机测试一下，修改相应的value值
-	package main
+上面我们介绍了默认的非缓存类型的channel，不过Go也允许指定channel的缓冲大小，很简单，就是channel可以存储多少元素。ch:= make(chan bool, 4)，创建了可以存储4个元素的bool 型channel。在这个channel 中，前4个元素可以无阻塞的写入。当写入第5个元素时，代码将会阻塞，直到其他goroutine从channel 中读取一些元素，腾出空间。
+
+	ch := make(chan type, value)
+	
+	value == 0 ! 无缓冲（阻塞）
+	value > 0 ! 缓冲（非阻塞，直到value 个元素）	
+
+我们看一下下面这个例子，你可以在自己本机测试一下，修改相应的value值
+
+
+	package main
 
 	import "fmt"
 
@@ -128,9 +138,9 @@ channel通过操作符`<-`来接收和发送数据
 >另外记住一点的就是channel不像文件之类的，不需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显示的结束range循环之类的
 
 ##Select
-我们上面介绍的都是只有一个channel的情况，那么如果存在多个channel的时候，我们该如何操作呢，Go里面提供了一个关键字`select`，通过`select`可以监听channel上输入的数据。
+我们上面介绍的都是只有一个channel的情况，那么如果存在多个channel的时候，我们该如何操作呢，Go里面提供了一个关键字`select`，通过`select`可以监听channel上的数据流动。
 
-`select`默认都是阻塞的，只有当channel数据到达之后才会运行，当多个channel都准备好的时候，select是随机的读取一个执行的。
+`select`默认是阻塞的，只有当监听的channel中有发送或接收可以进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的。
 
 	package main
 
@@ -161,9 +171,9 @@ channel通过操作符`<-`来接收和发送数据
 		fibonacci(c, quit)
 	}
 
-虽然goroutine是并发执行的，但是它们并不是并行运行的。如果不告诉Go额外的东西，同一时刻只会有一个goroutine执行。利用runtime.GOMAXPROCS(n)可以设置goroutine并行执行的数量。GOMAXPROCS 设置了同时运行的CPU 的最大数量，并返回之前的设置。如果n < 1，不会改变当前设置。以后Go的新版本中调度得到改进后，这将被移除。
+虽然goroutine是并发执行的，但是它们并不是并行运行的。如果不告诉Go额外的东西，同一时刻只会有一个goroutine执行逻辑代码。利用runtime.GOMAXPROCS(n)可以设置goroutine并行执行的数量。GOMAXPROCS 设置了同时运行逻辑代码的系统线程 的最大数量，并返回之前的设置。如果n < 1，不会改变当前设置。以后Go的新版本中调度得到改进后，这将被移除。
 
-在`select`里面还有default语法，`select`其实就是类似switch的功能，default就是当其他channel都没有准备好的时候，默认执行的。
+在`select`里面还有default语法，`select`其实就是类似switch的功能，default就是当监听的channel都没有准备好的时候，默认执行的（select不再阻塞等待channel）。
 
 	select {
 	case i := <-c:
@@ -179,4 +189,4 @@ channel通过操作符`<-`来接收和发送数据
    * 下一节: [总结](<2.8.md>)
 
 ## LastModified 
-   * $Id$
+   * $Id$