Fixed something wrong.

2.3.md

@@ -1,9 +1,9 @@
 #2.3 流程和函数
 这小节我们要介绍Go里面的流程控制以及函数操作
 ##流程控制
-流程控制是最伟大的发明了，因为有了它，你可以通过很简单的描述来表达很复杂的事情
+流程控制在编程语言中是最伟大的发明了，因为有了它，你可以通过很简单的描述来表达很复杂的事情。
 ###if
-if语法也许是所有语言里面最常见的一种语法了，它的语法概括起来就是:`如果满足条件就做某事，否则做另一件事`
+`if`也许是所有语言中最常见的了，它的语法概括起来就是:`如果满足条件就做某事，否则做另一件事`
 
 Go里面`if`条件语法中不需要括号，如下代码所示
 
@@ -15,7 +15,7 @@ Go里面`if`条件语法中不需要括号，如下代码所示
 
 Go的`if`还有一个强大的地方就是条件里面允许声明一个变量，这个变量的作用域只能在该条件中，出了这个条件就不起作用了，如下所示
 
-	// 计算获取值x,然后根据x返回的大小，判断是否大于10.
+	// 计算获取值x,然后根据x返回的大小，判断是否大于10。
 	if x := computedValue(); x > 10 {
 		fmt.Println("x is greater than 10")
 	} else {
@@ -25,7 +25,7 @@ Go的`if`还有一个强大的地方就是条件里面允许声明一个变量
 	//这个地方如果这样调用就编译出错了，因为x是条件里面的变量
 	fmt.Println(x)
 
-多个条件的时候如下所示
+多个条件的时候如下所示：
 
 	if integer == 3 {
 		fmt.Println("The integer is equal to 3")
@@ -50,15 +50,15 @@ Go有`goto`语句——请明智地使用它。用`goto`跳转到一定是当前
 标签名是大小写敏感的。
 
 ###for
-Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读取数据，又可以当作`while`来控制逻辑，还能迭代操作。它的语法如下
+Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读取数据，又可以当作`while`来控制逻辑，还能迭代操作。它的语法如下：
 
 	for expression1; expression2; expression3 {
-		...
+		//...
 	}
 
 `expression1`、`expression2`和`expression3`都是表达式，其中`expression1`和`expression3`是变量声明或者函数调用返回值之类的，`expression2`是条件判断，`expression1`在循环开始之前调用，`expression3`在每轮循环结束之时调用。
 
-一个例子比上面讲那么多更有用，那么我们看看下面的例子吧
+一个例子比上面讲那么多更有用，那么我们看看下面的例子吧：
 
 	package main
 	import "fmt"
@@ -70,9 +70,9 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 		}
 		fmt.Println("sum is equal to ", sum)
 	}
-	//输出：sum is equal to 45
+	// 输出：sum is equal to 45
 
-有些时候有多个需要操作的赋值操作，由于Go里面没有`,`操作，那么可以使用平行赋值`i, j = i+1, j-1`
+有些时候需要进行多个赋值操作，由于Go里面没有`,`操作，那么可以使用平行赋值`i, j = i+1, j-1`
 
 
 有些时候如果我们忽略`expression1`和`expression3`：
@@ -82,23 +82,23 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 		sum += sum
 	}
 
-其中`;`也可以省略，那么就变成如下的代码了，是不是似曾相识，对，这就是`while`的功能
+其中`;`也可以省略，那么就变成如下的代码了，是不是似曾相识？对，这就是`while`的功能。
 
 	sum := 1
 	for sum < 1000 {
 		sum += sum
 	}
 
-在循环里面有两个关键操作`break`和`continue`	,`break`操作是跳出当前循环，`continue`是跳出本次循环，当嵌套过深的时候，`break`可以配合标签使用，即跳出标签所指定的循环，详细参考如下例子
+在循环里面有两个关键操作`break`和`continue`	,`break`操作是跳出当前循环，`continue`是跳过本次循环。当嵌套过深的时候，`break`可以配合标签使用，即跳转至标签所指定的位置，详细参考如下例子：
 
 	for index := 10; index>0; index-- {
 		if index == 5{
-			break或者continue
+			break // 或者continue
 		}
 		fmt.Println(index)
 	}
-	//break打印出来10、9、8、7、6
-	//continue打印出来10、9、8、7、6、4、3、2、1
+	// break打印出来10、9、8、7、6
+	// continue打印出来10、9、8、7、6、4、3、2、1
 
 `break`和`continue`还可以跟着标号，用来跳到多重循环中的外层循环
 
@@ -109,11 +109,11 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 		fmt.Println("map's val:",v)
 	}
 
-其中还可以使用`_`来扔掉不需要的返回值
+其中还可以使用`_`来丢弃不需要的返回值
 
 
 ###switch
-有些时候你需要写很多的`if/else`来实现一些逻辑处理，这个时候代码看上去就很丑很冗长，而且也不易于以后的维护，这个时候`switch`就能很好的解决这个问题，它的语法如下
+有些时候你需要写很多的`if-else`来实现一些逻辑处理，这个时候代码看上去就很丑很冗长，而且也不易于以后的维护，这个时候`switch`就能很好的解决这个问题。它的语法如下
 
 	switch sExpr {
 	case expr1:
@@ -126,7 +126,7 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 		other code
 	}
 
-`sExpr`和`expr1`、`expr2`、`expr3`的类型必须一致。Go的`switch`非常灵活。表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项，而如果`switch`没有表达式，它会匹配`true`。
+`sExpr`和`expr1`、`expr2`、`expr3`的类型必须一致。Go的`switch`非常灵活，表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项；而如果`switch`没有表达式，它会匹配`true`。
 
 	i := 10
 	switch i {
@@ -144,23 +144,23 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 
 	integer := 6
 	switch integer {
-	case 4:
-	fmt.Println("The integer was <= 4")
-	fallthrough
-	case 5:
-	fmt.Println("The integer was <= 5")
-	fallthrough
-	case 6:
-	fmt.Println("The integer was <= 6")
-	fallthrough
-	case 7:
-	fmt.Println("The integer was <= 7")
-	fallthrough
-	case 8:
-	fmt.Println("The integer was <= 8")
-	fallthrough
-	default:
-	fmt.Println("default case")
+		case 4:
+		fmt.Println("The integer was <= 4")
+		fallthrough
+		case 5:
+		fmt.Println("The integer was <= 5")
+		fallthrough
+		case 6:
+		fmt.Println("The integer was <= 6")
+		fallthrough
+		case 7:
+		fmt.Println("The integer was <= 7")
+		fallthrough
+		case 8:
+		fmt.Println("The integer was <= 8")
+		fallthrough
+		default:
+		fmt.Println("default case")
 	}
 
 上面的程序将输出
@@ -172,7 +172,7 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 
 
 ##函数
-函数是Go里面的核心设计，它通过关键字`func`来声明，它的格式如下
+函数是Go里面的核心设计，它通过关键字`func`来声明，它的格式如下：
 
 	func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
 		//这里是处理逻辑代码
@@ -194,7 +194,7 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 	package main
 	import "fmt"
 
-	//返回a、b中最大值.
+	// 返回a、b中最大值.
 	func max(a, b int) int {
 		if a > b {
 			return a
@@ -212,7 +212,7 @@ Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读
 
 		fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
 		fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
-		fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) //just call it here
+		fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // 也可在这直接调用它
 	}
 
 上面这个里面我们可以看到`max`函数有两个参数，它们的类型都是`int`，那么第一个变量的类型可以省略，默认为离它最近的类型，同理多于2个同类型的变量或者返回值。同时我们注意到它的返回值就是一个类型，这个就是省略写法。
@@ -240,7 +240,7 @@ Go语言和C相比，更先进的地方，其中一点就是能够返回多个
 		fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
 	}
 
-上面的例子我们可以看到直接返回了两个参数，当然我们也可以命名返回参数的变量，这个例子里面只是用了两个类型，我们也可以改成如下这样的定义，然后返回的时候不用带上变量名，因为直接在函数里面初始化了。但是当你的函数如果是导出的(首字母大写)，官方建议，不要命名返回值名称，因为这样会造成生成的文档不易读。
+上面的例子我们可以看到直接返回了两个参数，当然我们也可以命名返回参数的变量，这个例子里面只是用了两个类型，我们也可以改成如下这样的定义，然后返回的时候不用带上变量名，因为直接在函数里面初始化了。但如果你的函数是导出的(首字母大写)，官方建议，不要命名返回值，因为这样会造成生成的文档不易读。
 
 	func SumAndProduct(A, B int) (add int, Multiplied int) {
 		add = A+B
@@ -275,17 +275,17 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。
 	func main() {
 		x := 3
 
-		fmt.Println("x = ", x) // 应该输出 "x = 3"
+		fmt.Println("x = ", x)  // 应该输出 "x = 3"
 
-		x1 := add1(x) //调用add1(x)
+		x1 := add1(x)  //调用add1(x)
 
 		fmt.Println("x+1 = ", x1) // 应该输出"x+1 = 4"
-		fmt.Println("x = ", x) // 应该输出"x = 3"
+		fmt.Println("x = ", x)    // 应该输出"x = 3"
 	}
 
 看到了吗？虽然我们调用了`add1`函数，并且在`add1`中执行`a=a+1`操作，但是上面例子中`x`变量的值没有发生变化
 
-理由很简单：因为当我们调用`add1`的时候，`add1`接收的参数其实是`x`的copy，而不是`x`本身
+理由很简单：因为当我们调用`add1`的时候，`add1`接收的参数其实是`x`的copy，而不是`x`本身。
 
 那你也许会问了，如果真的需要传这个`x`本身,该怎么办呢？
 
@@ -303,12 +303,12 @@ Go函数支持变参。接受变参的函数是有着不定数量的参数的。
 	func main() {
 		x := 3
 
-		fmt.Println("x = ", x) // 应该输出 "x = 3"
+		fmt.Println("x = ", x)  // 应该输出 "x = 3"
 
-		x1 := add1(&x) // 调用 add1(&x) 传x的地址
+		x1 := add1(&x)  // 调用 add1(&x) 传x的地址
 
 		fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
-		fmt.Println("x = ", x) // 应该输出 "x = 4"
+		fmt.Println("x = ", x)    // 应该输出 "x = 4"
 	}
 
 这样，我们就达到了修改`x`的目的。那么到底传指针有什么好处呢？
@@ -368,7 +368,7 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象
 	package main
 	import "fmt"
 
-	type testInt func(int) bool //声明了一个函数类型
+	type testInt func(int) bool // 声明了一个函数类型
 
 	func isOdd(integer int) bool {
 		if integer%2 == 0 {
@@ -384,8 +384,8 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象
 		return false
 	}
 
-	//声明的函数类型在这个地方当做了一个参数
-	func filter(slice []int, f test_int) []int {
+	// 声明的函数类型在这个地方当做了一个参数
+	func filter(slice []int, f testInt) []int {
 		var result []int
 		for _, value := range slice {
 			if f(value) {
@@ -398,9 +398,9 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象
 	func main(){
 		slice := []int {1, 2, 3, 4, 5, 7}
 		fmt.Println("slice = ", slice)
-		odd := filter(slice, isOdd) //函数当做值来传递了
+		odd := filter(slice, isOdd)    // 函数当做值来传递了
 		fmt.Println("Odd elements of slice are: ", odd)
-		even := filter(slice, isEven)//函数当做值来传递了
+		even := filter(slice, isEven)  // 函数当做值来传递了
 		fmt.Println("Even elements of slice are: ", even)
 	}