Merge pull request #34 from OlingCat/master

修改了一些句子。
2012-09-20 02:19:17 -07:00
parent 0a4fb93e0a 9e4612acd5
commit 4eac596f98
5 changed files with 289 additions and 290 deletions
--- a/2.1.md
+++ b/2.1.md
@@ -1,6 +1,6 @@
-#2.1 你好,Go
+#2.1 你好，Go

-在我们开始用Go写应用之前，我们先从最基本的程序开始。就像你造房子之前你不知道什么是地基一样，因此，在本小节中，我们要学习用最基本的语法让GO程序运行起来。
+在我们开始用Go写应用之前，我们先从最基本的程序开始。就像你造房子之前你不知道什么是地基一样，因此，在本小节中，我们要学习用最基本的语法让Go程序运行起来。

 ##程序

@@ -13,43 +13,43 @@
 	import "fmt"

 	func main() {
-    	fmt.Printf("Hello, world; καλημ ́ρα κóσμ or こんにちは世界\n")
+		fmt.Printf("Hello, world; καλημ ́ρα κóσμ or こんにちは世界\n")
 	}
-	
+
 输出如下：
-	
-	Hello, world; καλημ ́ρα κóσμ or こんにちは世界	
+
+	Hello, world; καλημ ́ρα κóσμ or こんにちは世界

 ##详解
 首先我们要了解一个概念，Go程序是通过`package`来组织的

-`package <plaplapla>`（在我们的例子里面，plaplapla是main）这一句话是告诉我们当前这个文件属于那个包，而main包是告诉我们当前这个包是一个独立可运行的包，编译之后是可执行文件，除了main之外，其他的包最后生成的都是放在"$GOPATH/pkg/系统_架构“（以mac为例：darwin_amd64)下面的.a文件(也就是包文件)。
+`package <pkgname>`（在我们的例子里面，`<pkgname>`是`main`）这一句话是告诉我们当前这个文件属于哪个包，而`main`包是告诉我们当前这个包是一个可独立运行的包，编译之后是可执行文件。除了`main`之外，其它的包最后生成的都是放在`$GOPATH/pkg/$GOOS_$GOARCH`（以Mac为例：darwin_amd64）下面的.a文件（也就是包文件）。

->每一个Go的独立可运行的应用程序，必定包含有一个`package main`，这个main包里面必定包含有一个入口函数main函数，这个函数没有任何的参数，也没有的返回值
+>每一个可独立运行的Go程序，必定包含一个`package main`，这个`main`包里面必定包含一个入口函数`main`函数，而这个函数没有任何参数，也没有返回值。

-为了打印"Hello,world..."，我们调用了一个函数Printf，这个函数来自于fmt这个包，所以我们在第三行里面导入了系统级别的fmt包，`import "fmt"`
+为了打印“Hello, world...”，我们调用了一个函数`Printf`，这个函数来自于`fmt`这个包，所以我们在第三行里面导入了系统级别的`fmt`包，`import "fmt"`。

-包的概念和python的modules是同一个理念，都是有一些特有的好处：模块化(能够把你的程序分成多个模块)和重用性(每个模块都能被其他应用程序反复使用)，这里我们只要先了解一下包的概念，后面我们将会开始编写自己的包
+包的概念和Python的module相同，它们都有一些特别的好处：模块化（能够把你的程序分成多个模块)和可重用性（每个模块都能被其它应用程序反复使用）。这里我们只是先了解一下包的概念，后面我们将会开始编写自己的包。

-第五行，我们定义了一个main函数,我们通过func这个关键字，他的内容通过`{`和`}`组织，就和我们平常写的c、c++、Java一样
+在第五行中，我们通过关键字`func`定义了一个`main`函数，函数体被放在`{}`（大括号）中，就像我们平时写的C、C++或Java一样。

-大家可以看到main函数是没有任何的参数的，但是我们接下来学习如何编写函数里面，函数是可以带参数的，而且可以不返回数据，返回一个或者多个数据
+大家可以看到`main`函数是没有任何的参数的，我们接下来就学习如何编写带参数的、返回0个或多个值的函数。

-第六行，我们调用了fmt包里面定义的函数Printf，大家可以看到，这个函数的调用是通过`<package name>.function`的方式调用的，这个和python是十分相似的
+第六行，我们调用了`fmt`包里面定义的函数`Printf`。大家可以看到，这个函数是通过`<package name>.<function>`的方式调用的，这个和Python十分相似。

->前面提到过，包名和包所在文件夹名可以是不同的，此处的package name即为通过`package <plaplapla>`声明的包名，而非文件夹名。
+>前面提到过，包名和包所在文件夹名可以是不同的，此处的package name即为通过`package <pkgname>`声明的包名，而非文件夹名。

-最后大家可以看到我们输出的内容里面包含了很多非ASCII码的字符，实际上，Go是天生支持UTF-8的，任何字符都可以直接输出
+最后大家可以看到我们输出的内容里面包含了很多非ASCII码的字符。实际上，Go是天生支持UTF-8的，任何字符都可以直接输出，你甚至可以用UTF-8中的任何字符作为标识符。


 ##结论

-Go使用package（和Python的模块类似）来组织代码。main.main函数(这个函数主要位于主包）是每一个独立的可运行程序的入口点。Go使用UTF-8字符串和标识符(因为UTF-8的发明者也就是GO的发明者)，所以它天生就具有多语言的支持。
+Go使用package（和Python的模块类似）来组织代码。`main.main()`函数(这个函数主要位于主包）是每一个独立的可运行程序的入口点。Go使用UTF-8字符串和标识符(因为UTF-8的发明者也就是Go的发明者)，所以它天生就具有多语言的支持。

 ## links
   * [目录](<preface.md>)
   * 上一节: [Go语言基础](<2.md>)
   * 下一节: [Go基础](<2.2.md>)

-## LastModified 
+## LastModified
   * $Id$
--- a/2.2.md
+++ b/2.2.md
@@ -1,59 +1,59 @@
 #2.2 Go基础

-这小节我们将要介绍如何定义变量、常量；Go内置类型以及一些Go设计中的技巧
+这小节我们将要介绍如何定义变量、常量、Go内置类型以及一些Go设计中的技巧。

 ##定义变量

 Go语言里面定义变量有好几种方式。

-最基本的定义变量如下，Go变量定义，它的类型是跟在变量后面的，而不是像C一样放前面
+最基本的定义变量如下，Go变量定义，它的类型是跟在变量后面的，而不是像C一样放前面：

-	//定义一个名称为“variable_name”、类型为"type"的变量
-	var variable_name type	
+	//定义一个名称为“variableName”，类型为"type"的变量
+	var variableName type

 定义多个变量

-	//定义三个类型都是"type"的三个变量
-	var vname1,vname2,vname3 type
-	
+	//定义三个类型都是“type”的三个变量
+	var vname1, vname2, vname3 type
+
 定义变量并且带有初始化的值

-	//初始化“variable_name”的变量为“value”值，类型是"type"
-	var variable_name type = value
+	//初始化“variableName”的变量为“value”值，类型是“type”
+	var variableName type = value

 同时初始化多个变量

 	/*
-	    定义三个类型都是"type"的三个变量,并且他们分别初始化相应的值
+	    定义三个类型都是"type"的三个变量,并且它们分别初始化相应的值
 	    vname1为v1，vname2为v2，vname3为v3
 	*/
-	var vname1,vname2,vname3 type= v1, v2, v3
+	var vname1, vname2, vname3 type= v1, v2, v3

-你是不是觉得上面这样的定义有点复杂，没关系，因为Go语言的设计者也发现这样复杂了，我们来让它变得简单一点，我们可以直接忽略类型这个申明，那么上面的什么变成了如下
+你是不是觉得上面这样的定义有点复杂，没关系，因为Go语言的设计者也发现这样复杂了，我们来让它变得简单一点。我们可以直接忽略类型声明，那么上面的东西变成了如下

 	/*
-	    定义三个变量，他们分别初始化相应的值
+	    定义三个变量，它们分别初始化相应的值
 	    vname1为v1，vname2为v2，vname3为v3
-	    然后他们的类型自动根据初始化的值来确定相应的类型，Go会帮你做这件事
+	    然后它们的类型自动根据初始化的值来确定相应的类型，Go会帮你做这件事
 	*/
-	var vname1,vname2,vname3= v1, v2, v3
+	var vname1, vname2, vname3 = v1, v2, v3

 你还是觉得上面的复杂？好吧，我也觉得是，让我们继续简化

 	/*
-	    定义三个变量，他们分别初始化相应的值
+	    定义三个变量，它们分别初始化相应的值
 	    vname1为v1，vname2为v2，vname3为v3
 	    编译器会根据初始化的值自动推导出相应的类型
 	*/
-	vname1,vname2,vname3 := v1, v2, v3
-	
-现在是不是看上去非常的简单了，`:=`这个定义直接替代了`var`和`type`,这样的代码是不是很简洁，但是:=有一个限制，那就是它只能用在函数内部，在函数外部使用则不能编译通过。比如用以定义全局变量。
+	vname1, vname2, vname3 := v1, v2, v3

-一个特殊的变量名是`_`（下划线）。任何赋给它的值都被丢弃。在这个例子中，将赋值35赋值给b，同时丢弃34。
+现在是不是看上去非常的简单了？`:=`这个定义直接替代了`var`和`type`，这样的代码是不是很简洁？但是`:=`有一个限制，那就是它只能用在函数内部，在函数外部使用则不能编译通过，比如用以定义全局变量。
+
+一个特殊的变量名是`_`（下划线），任何赋给它的值都会被丢弃。在这个例子中，将值`35`赋予`b`，同时丢弃`34`。

 	_, b := 34, 35

-Go的编译器对申明却未使用的变量会在编译阶段报错。下面的代码会产生一个错误：申明了i却未使用
+Go的编译器对声明却未使用的变量会在编译阶段报错。下面的代码会产生一个错误：声明了i却未使用

 	package main

@@ -63,57 +63,55 @@ Go的编译器对申明却未使用的变量会在编译阶段报错。下面的

 ##常量

-所谓常量，也就是在编译阶段就确定下来的值，程序运行时无法改变该值，GO程序里面，常量定义可以是数字类型、Bool、字符串
+所谓常量，也就是在编译阶段就确定下来的值，程序运行时无法改变该值，Go程序里面，常量定义可以是数值、布尔或字符串等类型。

 它的语法如下

-	const constant_name = value
-	
-下面是一些申明的例子
+	const constantName = value

-	const PI = 3.1415927
+下面是一些声明的例子
+
+	const Pi = 3.1415927
 	const i = 10000
-	const Max_Thread = 10
+	const MaxThread = 10
 	const prefix = 'astaxie_'

-当然如果需要，可以明确指定常量的类型：
+当然如果需要，也可以明确指定常量的类型：

-	const PI float32 = 3.1415927
+	const PI float32 = 3.1415926


 ##内置基础类型

 ###Boolean

-对于布尔值，在GO中, 它的类型是:`bool` 可以有的值是:`true`或`false`。默认为`false`
+对于布尔值，在Go中，它的类型是`bool`，可用的值是`true`或`false`，默认为`false`。

 	//示例代码
-	var isactive bool 
-	var enabled, disabled = true, false //忽略类型的申明
+	var isactive bool
+	var enabled, disabled = true, false //忽略类型的声明
 	func test(){
-    	var available bool //一般的申明
-    	valid := false //忽略var和type的申明
+    	var available bool //一般的声明
+    	valid := false //忽略var和type的声明
    	available = true //赋值操作
 	}


 ###数字类型

-对于整数类型，有无符号和有符号两种，GO同时支持`int`和`uint`，这两种类型的长度相同，但具体长度取决于编译器的实现。当前的gc和gccgo编译器在32位和64位平台上都使用32位来表示`int`和`uint`，但未来在64位平台上可能增加到64位。GO里面也有直接定义好位数的类型`rune`, `int8`, `int16`, `int32`, `int64`和`byte`, `uint8`, `uint16`, `uint32`, `uint64`。目前`rune`是`int`的别称,将来会改为`int32`的别称。`byte`是`uint8`的别称。
+对于整数类型，有无符号和带符号两种。Go同时支持`int`和`uint`，这两种类型的长度相同，但具体长度取决于编译器的实现。当前的gc和gccgo编译器在32位和64位平台上都使用32位来表示`int`和`uint`，但未来在64位平台上可能增加到64位。Go里面也有直接定义好位数的类型`rune`, `int8`, `int16`, `int32`, `int64`和`byte`, `uint8`, `uint16`, `uint32`, `uint64`。`rune`是`int32`的别称，`byte`是`uint8`的别称。

 >注意一点就是这些类型之间的变量不允许相互之间赋值、操作，不然会引起编译器的错误。
 >
 >如下的代码会出现错误
->	
+>
 >	var a int8
->	
 >	var b int32
->	
 >	c:=a + b

-浮点类型的值有`float32`和`float64`(没有`float`类型)。
+浮点类型的值有`float32`和`float64`（没有`float`类型）。

-这就是全部吗？NO！Go支持复数。它的变量类型是`complex128`（64位实数，64位虚数）。如果需要小一些的，还有`complex64`(32位实数，32位虚数)。复数写为`re + imi`，`re`是实数部分，`im`是虚数部分，而`i`是标记。使用复数的一个例子：
+这就是全部吗？No！Go支持复数。它的变量类型是`complex128`（64位实数，64位虚数）。如果需要小一些的，还有`complex64`(32位实数，32位虚数)。复数写为`re + imi`，`re`是实数部分，`im`是虚数部分，而`i`是标记。使用复数的一个例子：

 	var c complex64 = 5+5i;

@@ -123,71 +121,71 @@ Go的编译器对申明却未使用的变量会在编译阶段报错。下面的

 ###字符串

-前面一节里面说过，字符串都是UTF-8类型的，字符串通过一对双引号(")或反引号（`）来定义，它的类型是string
+前面一节里面说过，字符串都是UTF-8类型的。字符串通过一对双引号（""）或反引号（` `` `）来定义，它的类型是`string`。

 	//示例代码
-	var french_hello string //声明变量为字符串的一般方法
-	var empty_string string = "" // 申明了一个字符串变量，初始化为空值
+	var frenchHello string  //声明变量为字符串的一般方法
+	var emptyString string = ""  // 声明了一个字符串变量，初始化为空值
 	func test(){
-	    no, yes, maybe := "no", "yes", "maybe" //忽略var和type的申明，同时申明多个变量
-	    japanese_hello := "Ohaiou"  //同上
-	    french_hello = "Bonjour" //常规赋值
+	    no, yes, maybe := "no", "yes", "maybe"  //忽略var和type的声明，同时声明多个变量
+	    japaneseHello := "Ohaiou"  //同上
+	    frenchHello = "Bonjour"  //常规赋值
 	}
-	
-在Go中字符串是不可变的，例如如下的代码编译时会报错
+
+在Go中字符串是不可变的，例如如下的代码编译时会报错：

 	var s string = "hello"
 	s[0] = 'c'


-那么如果真的想要修改怎么办呢？如下的代码可以实现
+那么如果真的想要修改怎么办呢？如下的代码可以实现：

 	s := "hello"
-	c := []byte(s)
-	c[0] = 'c' 
-	s2 := string(c)
+	c := []byte(s)  // 将字符串 s 转换为 []byte 类型
+	c[0] = 'c'
+	s2 := string(c)  // 再转换回 string 类型
 	fmt.Printf("%s\n", s2)


-GO中可以使用`+`来链接两个字符串
+Go中可以使用`+`来链接两个字符串：

-	s := "hello"
-	m := "world"
+	s := "hello,"
+	m := " world"
 	a := s + m
-    fmt.Printf("%s\n", a)
+	fmt.Printf("%s\n", a)

 修改字符串也可写为

 	s := "hello"
 	s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作
 	fmt.Println("%s\n", s)
- 
-如果要申明一个多行的字符串怎么办？可以通过`` ` ``来申明

-	m:=`hello
-		world`		
-	     
+如果要声明一个多行的字符串怎么办？可以通过`` ` ``来声明：
+
+	m := `hello
+		world`
+
 `` ` `` 括起的字符串为Raw字符串，即字符串在代码中的形式就是打印时的形式，没有字符转义，换行也将原样输出。

 ###错误类型
-Go内置有一个`error`类型，专门用来处理错误信息，GO的package里面还专门有一个包errors来处理错误
+Go内置有一个`error`类型，专门用来处理错误信息，Go的`package`里面还专门有一个包`errors`来处理错误：

 	err := errors.New("emit macho dwarf: elf header corrupted")
 	if err != nil {
 	    fmt.Print(err)
 	}

-###GO数据底层的存储
+###Go数据底层的存储

-下面这张图来源于 Russ Cox blog中的一篇介绍GO数据结构的文章，大家可以看到这些基础类型底层都是开辟了一块内存，然后存了相应的值
+下面这张图来源于 Russ Cox blog中的一篇介绍Go数据结构的文章，大家可以看到这些基础类型底层都是开辟了一块内存，然后存了相应的值。

-![](images/2.2.basic.png?raw=true)	
+![](images/2.2.basic.png?raw=true)

 ##一些技巧

 ###分组定义

-Go语言里面针对多个同时申明变量、常量或者import多个包的时候可以采用分组的方式来申明
+Go语言里面针对多个同时声明变量、常量或者`import`多个包的时候可以采用分组的方式来声明

 如下的代码

@@ -196,7 +194,7 @@ Go语言里面针对多个同时申明变量、常量或者import多个包的时

 	const i = 100
 	const pi = 3.1415
-	const prefix = "go_"
+	const prefix = "Go_"

 	var i int
 	var pi float32
@@ -212,89 +210,89 @@ Go语言里面针对多个同时申明变量、常量或者import多个包的时
 	const(
 	    i = 100
 	    pi = 3.1415
-	    prefix = "go_"
+	    prefix = "Go_"
 	)
-	
+
 	var(
 	    i int
 	    pi float32
 	    prefix string
-	)	
-	
->除非被显式设置为其他值或iota, 每个const分组的第一个常量被默认设置为它的0值,第2及后续的常量被默认设置为他前面那个常量的值，如果前面那个常量的值是iota，则它也被设置为iota
+	)
+
+>除非被显式设置为其它值或`iota`，每个`const`分组的第一个常量被默认设置为它的0值,第二及后续的常量被默认设置为它前面那个常量的值，如果前面那个常量的值是`iota`，则它也被设置为`iota`

 ###iota枚举

-GO里面有一个关键字`iota`，这个关键字用来申明enum的时候采用，它默认开始值是0，每调用一次加1
+Go里面有一个关键字`iota`，这个关键字用来声明`enum`的时候采用，它默认开始值是0，每调用一次加1

 	const(
    	x = iota //x == 0
    	y = iota //y == 1
    	z = iota //z == 2
-    	w // 常量申明省略值时，默认和之前一个值的字面相同。这里隐示的说w = iota,因此w==3, 其实上面y和z可以同样不用=iota
+    	w // 常量声明省略值时，默认和之前一个值的字面相同。这里隐式地说w = iota,因此w == 3。其实上面y和z可以同样不用"= iota"
 	)
-	
+
 	const v = iota // 每遇到一个const关键字，iota被重置，此时 v==0

 ###Go设计的一些规则
-Go之所以会那么简洁，是因为他有一些默认的行为
- 大写字母开头的变量是导出的，也就是其他包可以读取的，类似类中的public的概念
+Go之所以会那么简洁，是因为它有一些默认的行为
+- 大写字母开头的变量是导出的，也就是其它包可以读取的，类似类中的public的概念
 - 大写字母开头的函数也是一样，相当于public的函数，小写的就是类似private

 ##array、slice、map

 ###array
-array就是数组，它的定义如下`[n]type`,n表示数组的长度，type表示存储内容的类型
+`array`就是数组，它的定义方式如下。在`[n]type`中，`n`表示数组的长度，`type`表示存储内容的类型

-对数组的操作和其他语言类似，都是通过`[]`来进行读取和赋值
+对数组的操作和其它语言类似，都是通过`[]`来进行读取和赋值

-	var arr [10]int  //申明了一个int类型的数组
+	var arr [10]int  //声明了一个int类型的数组
 	arr[0] = 42   //数组下标是从0开始的
 	arr[1] = 13   //赋值操作
 	fmt.Printf("The first element is %d\n", arr[0]) //获取数据

-由于数组的长度也是类型的一部分,比如`[3]int`与`[4]int`是不同的类型，所以数组是不能改变长度的，而且数组之间的赋值是值赋值，当把一个数组作为一个参数传入函数的时候，是这个数组的副本，而不是该数组的指针，如果要使用指针，那么就需要用到下面介绍的`slice`。
+由于数组的长度也是类型的一部分,比如`[3]int`与`[4]int`是不同的类型，所以数组是不能改变长度的，而且数组之间的赋值是值赋值，即当把一个数组作为一个参数传入函数的时候，是这个数组的副本，而不是该数组的指针。如果要使用指针，那么就需要用到下面介绍的`slice`。

-数组申明可以使用另一种`:=`来申明
+数组声明可以使用另一种`:=`来声明

-	a := [3]int{1,2,3}  //申明一个长度为3的数组
+	a := [3]int{1,2,3}  //声明一个长度为3的数组

-	b := [10]int{1,2,3} //申明了一个长度为10的数组，其中前面三个元素初始化为1、2、3，其他默认为0
+	b := [10]int{1,2,3} //声明了一个长度为10的数组，其中前面三个元素初始化为1、2、3，其它默认为0

-	c := […]int{4,5,6} //可以省略长度，采用…，go会自动计算长度
-	
-也许你会说，我想数组里面还是数组，能实现吗？当然咯，GO支持嵌套数组，即多维数组，如下代码申明了一个二维数组
+	c := [...]int{4,5,6} //可以省略长度，采用“...”，Go会自动计算长度

-	//申明了一个二维数组，该数组是一个两个元素的数组，然后每个元素里面是4个int的元素
-	double_array := [2][4]int {[4]int{1,2,3,4}, [4]int{5,6,7,8}}
-	
-	//如果内部的元素和外部的一样，那么上面的申明可以简化，直接忽略内部的类型
-	easy_array :=[2][4]int{{1,2,3,4},{5,6,7,8}}
+也许你会说，我想数组里面还是数组，能实现吗？当然咯，Go支持嵌套数组，即多维数组，如下代码声明了一个二维数组
+
+	//声明了一个二维数组，该数组是一个两个元素的数组，然后每个元素里面是4个int的元素
+	doubleArray := [2][4]int {[4]int{1,2,3,4}, [4]int{5,6,7,8}}
+
+	//如果内部的元素和外部的一样，那么上面的声明可以简化，直接忽略内部的类型
+	easyArray :=[2][4]int{{1,2,3,4}, {5,6,7,8}}

 数组的分配如下所示：

-![](images/2.2.array.png?raw=true)	
+![](images/2.2.array.png?raw=true)


 ###slice

-在很多的应用场景里面，数组不能满足我们的需求，因为在刚开始的时候，我们不知道到底需要多大的数组合适,所以我们需要动态数组,在go里面这种数据结构叫`slice`
+在很多的应用场景里面，数组不能满足我们的需求。因为在刚开始的时候，我们不知道到底需要多大的数组合适，所以我们需要动态数组。在Go里面这种数据结构叫`slice`

-`slice`并不是真正意义上面的动态数组，而是一个引用类型，`slice`总是指向底层的一个`array`。`slice`的申明也可以像`array`一样，只要省略size
+`slice`并不是真正意义上的动态数组，而是一个引用类型，`slice`总是指向底层的一个`array`。`slice`的声明也可以像`array`一样，只要省略size。

-	//和申明array一样，只是少了长度
+	//和声明array一样，只是少了长度
 	var fslice []int

-接下来我们可以申明一个slice，并初始化数据，如下所示
+接下来我们可以声明一个`slice`，并初始化数据，如下所示：

 	slice := []byte {'a', 'b', 'c', 'd'}
-	
-slice可以从一个数组或者一个已经存在的slice里面再次申明，`slice`通过array[i:j]来获取，i是数组的开始位置，j是结束位置，但不包含array[j]，他的长度是j-i

-	//申明一个含有十个字符元素的数组
+`slice`可以从一个数组或者一个已经存在的`slice`里面再次声明，`slice`通过`array[i:j]`来获取，`i`是数组的开始位置，`j`是结束位置，但不包含`array[j]`，它的长度是`j-i`。
+
+	//声明一个含有十个字符元素的数组
 	var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

-	//申明两个含有byte的slice
+	//声明两个含有byte的slice
 	var a,b[]byte

 	//a指向数组的第3个元素开始，并到第五个元素结束，
@@ -305,43 +303,43 @@ slice可以从一个数组或者一个已经存在的slice里面再次申明，`
 	b = ar[3:5]
 	// b的元素是: ar[3], ar[4]

-注意slice和数组申明时的区别：申明数组时，方括号内写明了数组的长度或使用`...`自动计算长度，而申明slice时，方括号内没有任何字符
+注意`slice`和数组声明时的区别：声明数组时，方括号内写明了数组的长度或使用`...`自动计算长度，而声明``slice``时，方括号内没有任何字符

-他们的数据结构如下所示
+它们的数据结构如下所示

 ![](images/2.2.slice.png?raw=true)

 slice有一些简便的操作

- - slice的默认开始位置是0，ar[:n]等价于ar[0:n] 
- - slice的第二个序列默认是数组的长度，ar[n:]等价于ar[n:len(ar)]
- - slice如果从一个数组里面直接获取，可以这样ar[:]，因为默认第一个序列是0，第二个是数组的长度，即等价于ar[0,len(ar)] 
+ - `slice`的默认开始位置是0，`ar[:n]`等价于`ar[0:n]`
+ - `slice`的第二个序列默认是数组的长度，`ar[n:]`等价于`ar[n:len(ar)]`
+ - `slice`如果从一个数组里面直接获取，可以这样`ar[:]`，因为默认第一个序列是0，第二个是数组的长度，即等价于`ar[0,len(ar)]`

-下面这个例子展示更多关于slice的操作
+下面这个例子展示更多关于`slice`的操作

-	//申明一个数组
+	// 声明一个数组
 	var array = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
-	//申明两个slice
-	var a_slice,b_slice
-	
+	//声明两个slice
+	var aSlice,bSlice
+
 	// 演示一些简便操作
-	a_slice = array[:3] // 等价于a_slice = array[0:3] a_slice包含元素: a,b,c
-	a_slice = array[5:] // 等价于a_slice = array[5:9] a_slice包含元素: f,g,h,i,j
-	a_slice = array[:] // 等价于a_slice = array[0:9] 这样a_slice包含了全部的元素
+	aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
+	aSlice = array[5:] // 等价于aSlice = array[5:9] aSlice包含元素: f,g,h,i,j
+	aSlice = array[:] // 等价于aSlice = array[0:9] 这样aSlice包含了全部的元素

-	//从slice获取slice
-	a_slice = array[3:7] // a_slice包含元素: d,e,f,g，len=4，cap=8
-	b_slice = a_slice[1:3] // b_slice 包含a_slice[1], a_slice[2] 也就是含有: e,f
-	b_slice = a_slice[:3] // b_slice 包含 a_slice[0], a_slice[1], a_slice[2] 也就是含有: d,e,f
-	b_slice = a_slice[0:5] // 对slice的slice可以在cap范围内扩展，此时b_slice包含：c,d,e,f,g
-	b_slice : a_slice[:] // b_slice包含所有a_slice的元素: d,e,f,g
+	// 从slice获取slice
+	aSlice = array[3:7] // aSlice包含元素: d,e,f,g，len=4，cap=8
+	bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
+	bSlice = aSlice[:3] // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f
+	bSlice = aSlice[0:5] // 对slice的slice可以在cap范围内扩展，此时bSlice包含：c,d,e,f,g
+	bSlice : aSlice[:] // bSlice包含所有aSlice的元素: d,e,f,g

-slice是引用类型，所以当引用改变其中项目的值的时候，那么其他的所有引用都会改变该值，例如上面的a_slice和b_slice，如果修改了a_slice中项目的值，那么b_slice相对应的值也会改变。
+`slice`是引用类型，所以当引用改变其中项目的值的时候，那么其它的所有引用都会改变该值，例如上面的`aSlice`和`bSlice`，如果修改了`aSlice`中项目的值，那么`bSlice`相对应的值也会改变。

-从概念上面来说slice像一个结构体，这个结构体包含了三个元素：
- 一个指针，指向数组中slice指定的开始位置
- 长度，slice的长度
- 最大长度，也就是slice开始位置到数组的最后位置的长度
+从概念上面来说`slice`像一个结构体，这个结构体包含了三个元素：
+- 一个指针，指向数组中`slice`指定的开始位置
+- 长度，`slice`的长度
+- 最大长度，也就是`slice`开始位置到数组的最后位置的长度

 	array := [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
 	slice := A[4:8]
@@ -350,25 +348,25 @@ slice是引用类型，所以当引用改变其中项目的值的时候，那么

 ![](images/2.2.slice2.png?raw=true)

-slice下面有几个有用的内置函数
+`slice`下面有几个有用的内置函数

- len   获取slice的长度
- cap   获取slice的最大容量
- append 向slice里面追加一个或者多个元素，然后返回一个和slice一样类型的slice
- copy  函数copy 从源slice src 复制元素到目标dst，并且返回复制的元素的个数
+- `len`   获取`slice`的长度
+- `cap`   获取`slice`的最大容量
+- `append` 向`slice`里面追加一个或者多个元素，然后返回一个和`slice`一样类型的`slice`
+- ``copy`  函数`copy`从源`slice`的`src`中复制元素到目标`dst`，并且返回复制的元素的个数

-注：append函数会改变slice所引用的数组的内容，从而影响到引用同一数组的其它slice。
-但当slice中没有剩余空间（(cap-len) == 0)时，此时将动态分配新的数组空间，返回的slice的数组指针将指向这个空间，而原数组的内容将保持不变，其它引用此数组的slice不受影响。
+注：`append`函数会改变`slice`所引用的数组的内容，从而影响到引用同一数组的其它`slice`。
+但当`slice`中没有剩余空间（即`(cap-len) == 0`）时，此时将动态分配新的数组空间。返回的`slice`数组指针将指向这个空间，而原数组的内容将保持不变，其它引用此数组的`slice`不受影响。

 ###map

-map也就是python中字典的概念，它的格式`map[keyType]valueType`
+`map`也就是Python中字典的概念，它的格式`map[keyType]valueType`

-我们看下面的代码，map的读取和设置也类似slice一样，通过key来操作，只是slice只有int的key，而map多了很多类型，可以是int，可以是string及所有完全定义了"=="与"!="操作的类型
-	
-	// 申明一个key是字符串，值为int的字典
-	var numbers map[string] int 
-	//另一种map的申明方式
+我们看下面的代码，`map`的读取和设置也类似`slice`一样，通过`key`来操作，只是`slice`只有`int`的`key`，而`map`多了很多类型，可以是`int`，可以是`string`及所有完全定义了`==`与`!=`操作的类型。
+
+	// 声明一个key是字符串，值为int的字典
+	var numbers map[string] int
+	//另一种map的声明方式
 	numbers := make(map[string]int)
 	numbers["one"] = 1 //赋值
 	numbers["ten"] = 10 //赋值
@@ -378,17 +376,17 @@ map也就是python中字典的概念，它的格式`map[keyType]valueType`
 	// 打印出来如下:
 	//第三个数字是: 3

-这个map就像我们平常看到的表格一样，左边列是key，右边列是值
+这个`map`就像我们平常看到的表格一样，左边列是`key`，右边列是值

-使用map过程中需要注意的几点
- map是无序的，每次打印出来的map都会不一样,他不能通过index获取，而必须通过key获取
- map的长度是不固定的，也就是和slice一样，也是一种引用类型
- 内置的len函数同样试用于map，返回map拥有的key的数量
- map的值可以很方便的修改，通过`numbers["one"]=11`可以很容易的把key为`one`的字典值改为11
+使用map过程中需要注意的几点：
+- map是无序的，每次打印出来的`map`都会不一样，它不能通过`index`获取，而必须通过`key`获取
+- map的长度是不固定的，也就是和`slice`一样，也是一种引用类型
+- 内置的len函数同样适用于`map`，返回`map`拥有的`key`的数量
+- map的值可以很方便的修改，通过`numbers["one"]=11`可以很容易的把key为`one`的字典值改为`11`

-map的初始化可以通过key:val的方式初始化值，同时map内置有判断是否存在key的方式
+`map`的初始化可以通过`key:val`的方式初始化值，同时`map`内置有判断是否存在`key`的方式

-删除map的元素通过delete
+通过`delete`删除`map`的元素：

    //初始化一个字典
 	rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
@@ -399,27 +397,27 @@ map的初始化可以通过key:val的方式初始化值，同时map内置有判
 	} else {
 	    fmt.Println("We have no rating associated with C# in the map")
 	}
-	
-	delete( rating， "C")  //删除key为C的元素
-	

-上面说过了，map也是一种引用类型，如果两个map同时指向一个底层，那么一个改变，另一个也相应的改变
+	delete(rating, "C")  //删除key为C的元素
+
+
+上面说过了，`map`也是一种引用类型，如果两个`map`同时指向一个底层，那么一个改变，另一个也相应的改变：

 	m = make(map[string]string)
 	m["Hello"] = "Bonjour"
 	m1 = m
 	m1["Hello"] = "Salut" //现在m["hello"]的值已经是Salut了
-	
+

 ###make、new操作

 `make`用于内建类型（`map`、`slice` 和`channel`）的内存分配。`new`用于各种类型的内存分配。

-内建函数new 本质上说跟其他语言中的同名函数功能一样：new(T) 分配了零值填充的T 类型的内存空间，并且返回其地址，一个*T类型的值。用Go的术语说，它返回了一个指针，指向新分配的类型T的零值。有一点非常重要：new返回指针。
+内建函数`new`本质上说跟其它语言中的同名函数功能一样：`new(T)`分配了零值填充的`T`类型的内存空间，并且返回其地址，即一个`*T`类型的值。用Go的术语说，它返回了一个指针，指向新分配的类型`T`的零值。有一点非常重要：`new`返回指针。

-内建函数make(T, args)与new(T)有着不同的功能。它只能创建slice，map和channel，并且返回一个有初始值(非零)的T类型，而不是*T。本质来讲，导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。例如，一个slice，是一个包含指向数据（内部array）的指针，长度和容量的三项描述符；在这些项目被初始化之前，slice 为nil。对于slice，map 和channel，make 初始化了内部的数据结构，填充适当的值。make返回初始化后的（非零）值。
+内建函数`make(T, args)`与`new(T)`有着不同的功能，它只能创建`slice`、`map`和`channel`，并且返回一个有初始值(非零)的`T`类型，而不是`*T`。本质来讲，导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。例如，一个`slice`，是一个包含指向数据（内部`array`）的指针、长度和容量的三项描述符；在这些项目被初始化之前，`slice`为`nil`。对于`slice`、`map`和`channel`来说，`make`初始化了内部的数据结构，填充适当的值。`make`返回初始化后的（非零）值。

-下面这个图详细的解释了new和make之间的区别
+下面这个图详细的解释了`new`和`make`之间的区别

 ![](images/2.2.makenew.png?raw=true)

@@ -430,5 +428,5 @@ map的初始化可以通过key:val的方式初始化值，同时map内置有判
   * 上一章: [你好,Go](<2.1.md>)
   * 下一节: [流程和函数](<2.3.md>)

-## LastModified 
+## LastModified
   * $Id$
--- a/2.3.md
+++ b/2.3.md
@@ -1,30 +1,30 @@
 #2.3 流程和函数
 这小节我们要介绍Go里面的流程控制以及函数操作
 ##流程控制
-流程控制是最伟大的发明了，因为有了他，你可以通过很简单的描述来表达很复杂的事情
+流程控制是最伟大的发明了，因为有了它，你可以通过很简单的描述来表达很复杂的事情
 ###if
-if语法也许是所有语言里面最常见的一种语法了，他的语法概括起来就是:`如果满足条件就做某事，否则做另一件事`
+if语法也许是所有语言里面最常见的一种语法了，它的语法概括起来就是:`如果满足条件就做某事，否则做另一件事`
+
+Go里面`if`条件语法中不需要括号，如下代码所示

-Go里面if条件语法中不需要括号，如下代码所示
-	
 	if x > 10 {
 	    fmt.Println("x is greater than 10")
 	} else {
 	    fmt.Println("x is less than 10")
 	}

-Go的if还有一个强大的地方就是条件里面允许申明一个变量，这个变量的作用域只能在该条件中，出了这个条件就不起作用了，如下所示
+Go的`if`还有一个强大的地方就是条件里面允许声明一个变量，这个变量的作用域只能在该条件中，出了这个条件就不起作用了，如下所示

 	// 计算获取值x,然后根据x返回的大小，判断是否大于10.
-	if x := computed_value(); x > 10 {
+	if x := computedValue(); x > 10 {
    	fmt.Println("x is greater than 10")
 	} else {
    	fmt.Println("x is less than 10")
 	}
-	
+
 	//这个地方如果这样调用就编译出错了，因为x是条件里面的变量
 	fmt.Println(x)
-	
+
 多个条件的时候如下所示

 	if integer == 3 {
@@ -33,13 +33,13 @@ Go的if还有一个强大的地方就是条件里面允许申明一个变量，
    	fmt.Println("The integer is less than 3")
 	} else {
    	fmt.Println("The integer is greater than 3")
-	}	
+	}

 ###goto

-Go有goto语句——请明智的使用它。用goto跳转到一定是当前函数内定义的标签。例如假设这样一个循环：
+Go有`goto`语句——请明智地使用它。用`goto`跳转到一定是当前函数内定义的标签。例如假设这样一个循环：

-	func myfunc() {
+	func myFunc() {
 		i := 0
 	Here:   //这行的第一个词，以冒号结束作为标签
 		println(i)
@@ -50,19 +50,19 @@ Go有goto语句——请明智的使用它。用goto跳转到一定是当前函
 标签名是大小写敏感的。

 ###for
-go里面最强大的一个控制逻辑就是for，他即可以用来循环读取数据，又可以当作while来控制逻辑，还能迭代操作。它的语法如下
+Go里面最强大的一个控制逻辑就是`for`，它即可以用来循环读取数据，又可以当作`while`来控制逻辑，还能迭代操作。它的语法如下

-	for expression1; expression2; expression3{
+	for expression1; expression2; expression3 {
 	    ...
 	}
-	
-expression1、expression2、expression3都是表达式，其中expression1和expression3是变量申明或者函数调用返回值之类的，expression2是条件判断，expression1在循环开始之前调用，expression3在每轮循环结束之时调用
+
+`expression1`、`expression2`和`expression3`都是表达式，其中`expression1`和`expression3`是变量声明或者函数调用返回值之类的，`expression2`是条件判断，`expression1`在循环开始之前调用，`expression3`在每轮循环结束之时调用。

 一个例子比上面讲那么多更有用，那么我们看看下面的例子吧

 	package main
 	import "fmt"
-	
+
 	func main(){
 	    sum := 0;
 	    for index:=0; index < 10 ; index++ {
@@ -71,25 +71,25 @@ expression1、expression2、expression3都是表达式，其中expression1和exp
 	    fmt.Println("sum is equal to ", sum)
 	}
 	//输出：sum is equal to 45
-	
+
 有些时候有多个需要操作的赋值操作，由于Go里面没有`,`操作，那么可以使用平行赋值`i, j = i+1, j-1`

-	
-有些时候如果我们忽略expression1和expression3
+
+有些时候如果我们忽略`expression1`和`expression3`：

 	sum := 1
 	for ; sum < 1000;  {
 	    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{
@@ -99,21 +99,21 @@ expression1、expression2、expression3都是表达式，其中expression1和exp
 	}
 	//break打印出来10、9、8、7、6
 	//continue打印出来10、9、8、7、6、4、3、2、1
-		
-break 和 continue 还可以跟着标号，用来跳到多重循环中的外层循环

-for可以用于读取slice和map的数据，配合range
+`break`和`continue`还可以跟着标号，用来跳到多重循环中的外层循环
+
+`for`配合`range`可以用于读取`slice`和`map`的数据：

 	for k,v:=range map {
 		fmt.Println("map's key:",k)
 		fmt.Println("map's val:",v)
 	}
-	
-其中还可以使用`_`来扔掉不需要的返回值	
+
+其中还可以使用`_`来扔掉不需要的返回值


 ###switch
-有些时候你需要写很多的`if/else`来实现一些逻辑处理，这个时候代码看上去就很丑很冗长，而且也不易于以后的维护，这个时候switch就能很好的解决这个问题，他的语法如下
+有些时候你需要写很多的`if/else`来实现一些逻辑处理，这个时候代码看上去就很丑很冗长，而且也不易于以后的维护，这个时候`switch`就能很好的解决这个问题，它的语法如下

 	switch sExpr {
    case expr1:
@@ -126,7 +126,7 @@ for可以用于读取slice和map的数据，配合range
        other code
 	}

-sExpr和expr1、expr2、expr3的类型必须一致。Go的switch非常灵活。表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项，而如果switch没有表达式，它会匹配true。
+`sExpr`和`expr1`、`expr2`、`expr3`的类型必须一致。Go的`switch`非常灵活。表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项，而如果`switch`没有表达式，它会匹配`true`。

 	i := 10
 	switch i {
@@ -140,7 +140,7 @@ sExpr和expr1、expr2、expr3的类型必须一致。Go的switch非常灵活。
        fmt.Println("All I know is that i is an integer")
 	}

-我们看第六行，我们把很多值聚合在了一个case里面，同时，Go里面switch默认相当于每个case后面带有break，匹配成功后不会自动向下尝试，而是跳出整个switch了，但是可以使用fallthrough使其这样做。
+我们看第六行，我们把很多值聚合在了一个`case`里面，同时，Go里面`switch`默认相当于每个`case`后面带有`break`，匹配成功后不会自动向下尝试，而是跳出整个`switch`了，但是可以使用`fallthrough`使其这样做。

 	integer := 6
 	switch integer {
@@ -162,19 +162,19 @@ sExpr和expr1、expr2、expr3的类型必须一致。Go的switch非常灵活。
 	default:
    fmt.Println("default case")
 	}
-	
+
 上面的程序将输出

 	The integer was <= 6
 	The integer was <= 7
 	The integer was <= 8
-	default case	
+	default case


 ##函数
-函数是Go里面的核心设计，它通过关键字`func`来申明，他的格式如下
+函数是Go里面的核心设计，它通过关键字`func`来声明，它的格式如下

-	func funcname(input1 type1, input2 type2) (output1 type1, output2 type2) {
+	func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
    	//这里是处理逻辑代码
    	//返回多个值
    	return value1, value2
@@ -182,14 +182,14 @@ sExpr和expr1、expr2、expr3的类型必须一致。Go的switch非常灵活。

 上面的代码我们看出

- 关键字`func`用来申明一个函数`funcname`
+- 关键字`func`用来声明一个函数`funcName`
 - 函数可以有一个或者多个参数，每个参数后面带有类型，通过`,`分隔
 - 函数可以返回多个值
- 上面返回值申明了两个变量output1和output2，如果你不想申明也可以，直接就两个类型
- 如果只有一个返回值且不申明返回值变量，那么你可以省略用以包括返回值的括号
+- 上面返回值声明了两个变量`output1`和`output2`，如果你不想声明也可以，直接就两个类型
+- 如果只有一个返回值且不声明返回值变量，那么你可以省略用以包括返回值的括号
 - 如果没有返回值，那么就直接省略最后的返回信息

-下面我们来看一个实际应用函数的例子(用来计算Max值)
+下面我们来看一个实际应用函数的例子（用来计算Max值）

 	package main
 	import "fmt"
@@ -201,59 +201,59 @@ sExpr和expr1、expr2、expr3的类型必须一致。Go的switch非常灵活。
 	    }
 	    return b
 	}
-	
+
 	func main() {
 	    x := 3
 	    y := 4
 	    z := 5
-	
+
 	    max_xy := max(x, y) //调用函数max(x, y)
 	    max_xz := max(x, z) //调用函数max(x, z)
-	
+
 	    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
 	}

-上面这个里面我们可以看到max函数有两个参数，他们的类型都是int，那么第一个变量的类型可以省略，默认为离它最近的类型，同理多于2个同类型的变量或者返回值。同时我们注意到它的返回值就是一个类型，这个就是省略写法。
+上面这个里面我们可以看到`max`函数有两个参数，它们的类型都是`int`，那么第一个变量的类型可以省略，默认为离它最近的类型，同理多于2个同类型的变量或者返回值。同时我们注意到它的返回值就是一个类型，这个就是省略写法。

 ###多个返回值
-Go语言和C相比，更先进的地方，其中一点就是能够返回多个值，也许这个思想来源于python。
+Go语言和C相比，更先进的地方，其中一点就是能够返回多个值，也许这个思想来源于Python。

 我们直接上代码看例子

 	package main
 	import "fmt"
-	
+
 	//返回 A+B 和 A*B
 	func SumAndProduct(A, B int) (int, int) {
 	    return A+B, A*B
 	}
-	
+
 	func main() {
 	    x := 3
 	    y := 4
-	
+
 	    xPLUSy, xTIMESy := SumAndProduct(x, y)
-	
+
 	    fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
 	    fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
 	}

 上面的例子我们可以看到直接返回了两个参数，当然我们也可以命名返回参数的变量，这个例子里面只是用了两个类型，我们也可以改成如下这样的定义，然后返回的时候不用带上变量名，因为直接在函数里面初始化了。但是当你的函数如果是导出的(首字母大写)，官方建议，不要命名返回值名称，因为这样会造成生成的文档不易读。
-	
+
 	func SumAndProduct(A, B int) (add int, Multiplied int) {
-	    add = A+B 
+	    add = A+B
 		Multiplied = A*B
 		return
-	}	
+	}

 ###变参
 Go函数支持变参。接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义函数使其接受变参：
-	
+
 	func myfunc(arg ...int) {}
-arg ... int 告诉Go这个函数接受不定数量的参数。注意，这些参数的类型全部是int。在函数体中，变量arg是一个int的slice：
-	
+`arg ...int`告诉Go这个函数接受不定数量的参数。注意，这些参数的类型全部是`int`。在函数体中，变量`arg`是一个`int`的`slice`：
+
 	for _, n := range arg {
 		fmt.Printf("And the number is: %d\n", n)
 	}
@@ -271,25 +271,25 @@ arg ... int 告诉Go这个函数接受不定数量的参数。注意，这些参
 	    a = a+1 // 我们改变了a的值
 	    return a //返回一个新值
 	}
-	
+
 	func main() {
 	    x := 3
-	
+
 	    fmt.Println("x = ", x) // 应该输出 "x = 3"
-	
+
 	    x1 := add1(x) //调用add1(x)
-	
+
 	    fmt.Println("x+1 = ", x1) // 应该输出"x+1 = 4"
 	    fmt.Println("x = ", x) // 应该输出"x = 3"
 	}

-看到了吗？虽然我们调用了add1函数，并且在add1中执行`a=a+1`操作，但是上面例子中x变量的值没有发生变化
+看到了吗？虽然我们调用了`add1`函数，并且在`add1`中执行`a=a+1`操作，但是上面例子中`x`变量的值没有发生变化

-理由很简单：因为当我们调用add1的时候，add1接收的参数其实是x的copy，而不是x本身
+理由很简单：因为当我们调用`add1`的时候，`add1`接收的参数其实是`x`的copy，而不是`x`本身

-那你也许会问了，如果真的需要传这个x本身,该怎么办呢？
+那你也许会问了，如果真的需要传这个`x`本身,该怎么办呢？

-这就牵扯到了所谓的指针。我们知道，变量在内存中是存放于一定地址上的，修改变量实际是修改变量地址处的内存。只有add1函数知道x变量所在的地址，才能修改x变量的值。所以我们需要将x所在地址&x传入函数，并将函数的参数的类型由int改为*int，即改为指针类型，才能在函数中修改x变量的值。此时参数仍然是按copy传递的，只是copy的是一个指针。请看下面的例子
+这就牵扯到了所谓的指针。我们知道，变量在内存中是存放于一定地址上的，修改变量实际是修改变量地址处的内存。只有`add1`函数知道`x`变量所在的地址，才能修改`x`变量的值。所以我们需要将`x`所在地址`&x`传入函数，并将函数的参数的类型由`int`改为`*int`，即改为指针类型，才能在函数中修改`x`变量的值。此时参数仍然是按copy传递的，只是copy的是一个指针。请看下面的例子

 	package main
 	import "fmt"
@@ -302,20 +302,20 @@ arg ... int 告诉Go这个函数接受不定数量的参数。注意，这些参

 	func main() {
 	    x := 3
-	
+
 	    fmt.Println("x = ", x) // 应该输出 "x = 3"
-	
+
 	    x1 := add1(&x) // 调用 add1(&x) 传x的地址
-	
+
 	    fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
 	    fmt.Println("x = ", x) // 应该输出 "x = 4"
 	}

-这样，我们就达到了修改x的目的。那么到底传指针有什么好处呢？
+这样，我们就达到了修改`x`的目的。那么到底传指针有什么好处呢？

 - 传指针使得多个函数能操作同一个对象。
 - 传指针比较轻量级，只是传内存地址，我们可以通过指针高效的传递大的结构体。如果传值的话，那么每次传递, 在copy上面就会花费大量的时间和内存。所以记住了，当你要传递大的结构体的时候，用指针是一个明智的选择。
- GO语言中string，slice，map这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数会改变slice的长度，则仍需要取地址传递指针）
+- Go语言中`string`，`slice`，`map`这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数需改变`slice`的长度，则仍需要取地址传递指针）

 ###defer
 Go里面有一个不错的设计，就是回调函数，有点类似面向对象语言里面的析构函数，当函数执行完之后再执行。特别是当你在进行一些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题。如下代码所示，我们一般写打开一个资源是这样操作的：
@@ -324,20 +324,20 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象
 		file.Open("file")
 	// 做一些工作
 		if failureX {
-			file.Close()  
+			file.Close()
 			return false
 		}

 		if failureY {
-			file.Close()  
+			file.Close()
 			return false
 		}
-		
-		file.Close()  
+
+		file.Close()
 		return true
 	}

-我们看到上面有很多重复的代码，Go的defer有效的解决了这个问题，使用它后，不但代码量减少了很多，而且程序变得更优雅。在defer 后指定的函数会在函数退出前调用。
+我们看到上面有很多重复的代码，Go的`defer`有效解决了这个问题。使用它后，不但代码量减少了很多，而且程序变得更优雅。在`defer`后指定的函数会在函数退出前调用。

 	func ReadWrite() bool {
 		file.Open("file")
@@ -351,7 +351,7 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象
 		return true
 	}

-如果有很多调用defer，那么defer是采用后进先出模式，所以如下代码会输出`4 3 2 1 0`
+如果有很多调用`defer`，那么`defer`是采用后进先出模式，所以如下代码会输出`4 3 2 1 0`

 	for i := 0; i < 5; i++ {
 	   defer fmt.Printf("%d ", i)
@@ -359,15 +359,16 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象

 ###函数作为值、类型

-在Go中函数也是一种变量，我们可以通过`type`来定义他，他的类型就是所有拥有相同的参数，相同的返回值的一种类型
+在Go中函数也是一种变量，我们可以通过`type`来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型
+
+	type typeName func(input1 inputType1 [, input2 inputType2 [, ...]) (result1 resultType1 [, ...])

-	type type_name func(input1 inputType1 [, input2 inputType2 [, ...]) (result1 resultType1 [, ...])
 函数作为类型到底有什么好处呢？那就是可以把这个类型的函数当做值来传递，请看下面的例子

 	package main
 	import "fmt"

-	type test_int func(int) bool //申明了一个函数类型
+	type testInt func(int) bool //声明了一个函数类型

 	func isOdd(integer int) bool {
 	    if integer%2 == 0 {
@@ -383,7 +384,7 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象
 	    return false
 	}

-    //申明的函数类型在这个地方当做了一个参数
+    //声明的函数类型在这个地方当做了一个参数
 	func filter(slice []int, f test_int) []int {
 	    var result []int
 	    for _, value := range slice {
@@ -403,19 +404,19 @@ Go里面有一个不错的设计，就是回调函数，有点类似面向对象
    	fmt.Println("Even elements of slice are: ", even)
 	}

-函数当做值和类型在我们写一些通用接口的时候非常有用，通过上面例子我们看到test_int这个类型是一个函数类型，然后两个filter函数的参数和返回值与test_int类型是一样的，但是我们可以实现很多种的逻辑，这样使得我们的程序变得非常的灵活。
+函数当做值和类型在我们写一些通用接口的时候非常有用，通过上面例子我们看到`testInt`这个类型是一个函数类型，然后两个`filter`函数的参数和返回值与`testInt`类型是一样的，但是我们可以实现很多种的逻辑，这样使得我们的程序变得非常的灵活。

 ###Panic和Recover

-Go没有例如像Java那样的异常机制：不能抛出一个异常。作为代替，它使用了panic和recover机制。一定要记得，这应当作为最后的手段被使用，你的代码中应当没有，或者很少的令人恐慌的东西。这是个强大的工具，明智的使用它。那么，应该如何使用它。
+Go没有像Java那样的异常机制：不能抛出一个异常。作为代替，它使用了`panic`和`recover`机制。一定要记得，这应当作为最后的手段被使用，你的代码中应当没有，或者很少的令人恐慌的东西。这是个强大的工具，请明智地使用它。那么，应该如何使用它？

 Panic
->是一个内建函数，可以中断原有的控制流程，进入一个令人恐慌的流程中。当函数F调用panic，函数F的执行被中断，但是F中的延迟函数会正常执行，然后F返回到调用它的地方。在调用的地方，F的行为就像调用了panic。这一过程继续向上，直到发生panic的goroutine中所有调用的函数返回，此时程序退出。恐慌可以直接调用panic产生。也可以由运行时错误产生，例如访问越界的数组。
+>是一个内建函数，可以中断原有的控制流程，进入一个令人恐慌的流程中。当函数`F`调用`panic`，函数F的执行被中断，但是`F`中的延迟函数会正常执行，然后F返回到调用它的地方。在调用的地方，`F`的行为就像调用了`panic`。这一过程继续向上，直到发生`panic`的`goroutine`中所有调用的函数返回，此时程序退出。恐慌可以直接调用`panic`产生。也可以由运行时错误产生，例如访问越界的数组。

 Recover
->是一个内建的函数，可以让进入令人恐慌的流程中的goroutine恢复过来。Recover仅在延迟函数中有效。在正常的执行过程中，调用recover会返回nil，并且没有其他任何效果。如果当前的goroutine 陷入恐慌，调用recover可以捕获到panic的输入值，并且恢复正常的执行。
+>是一个内建的函数，可以让进入令人恐慌的流程中的`goroutine`恢复过来。`recover`仅在延迟函数中有效。在正常的执行过程中，调用`recover`会返回`nil`，并且没有其它任何效果。如果当前的`goroutine`陷入恐慌，调用`recover`可以捕获到`panic`的输入值，并且恢复正常的执行。

-下面这个函数演示了如何在过程中使用panic
+下面这个函数演示了如何在过程中使用`panic`

 	var user = os.Getenv("USER")

@@ -425,10 +426,10 @@ Recover
 	    }
 	}

-下面这个函数检查作为其参数的函数在执行时是否会产生panic：
-	
+下面这个函数检查作为其参数的函数在执行时是否会产生`panic`：
+
 	func throwsPanic(f func()) (b bool) {
-		defer func() { 
+		defer func() {
 			if x := recover(); x != nil {
 				b = true
 			}
@@ -437,13 +438,13 @@ Recover
 		return
 	}

-###main函数和init函数
+###`main`函数和`init`函数

-Go里面有两个保留的函数：init函数(能够应用于所有的package)和main函数(只能应用于package main)。这两个函数定义的时候必须都是没有任何参数，也没有任何返回值的。虽然一个package里面可以随便写多个init函数，但是对于易读性还是以后的维护性来说，我们还是强烈建议用户一个package只写一个init函数。
+Go里面有两个保留的函数：`init`函数(能够应用于所有的`package`)和`main`函数(只能应用于`package main`)。这两个函数定义的时候必须都是没有任何参数，也没有任何返回值的。虽然一个`package`里面可以随便写多个`init`函数，但是对于易读性还是以后的维护性来说，我们还是强烈建议用户一个`package`只写一个`init`函数。

-Go程序里面会自动调用init()和main()，所以你不需要在任何地方调用这两个函数。init函数每个package里面是可选的，但是对于package main就必须包含一个main函数
+Go程序里面会自动调用`init()`和`main()`，所以你不需要在任何地方调用这两个函数。`init`函数每个`package`里面是可选的，但是对于`package main`就必须包含一个`main`函数。

-初始化和执行程序都是开始于main包，如果有import其他包，那么依次import进来。虽然有很多个包里面import了同一个包，但是这个包只会import一次(例如fmt包，可能很多package里面都会用到，但是只import了一次，因为没有必要包含多次)。当一个package被import进来的时候，如果他本身还import了其他包，那么先执行import其他包，然后执行这个包里面的包级别的常量和变量，然后执行init函数(如果包里面有的话)。最后所有的被main包import的包都加载完毕了，然后开始执行main包里面的常量和变量的初始化，然后执行main包里面的init函数(如果存在的话)，最后执行到了main函数。下图详细的解释了整个的执行过程。
+初始化和执行程序都是开始于`main`包，如果有`import`其它包，那么依次`import`进来。虽然有很多个包里面`import`了同一个包，但是这个包只会`import`一次（例如`fmt`包，可能很多`package`里面都会用到，但是只`import`了一次，因为没有必要包含多次）。当一个`package`被`import`进来的时候，如果它本身还`import`了其它包，那么先执行`import`其它包，然后执行这个包里面的包级别的常量和变量，然后执行`init`函数（如果包里面有的话）。最后所有的被`main`包`import`的包都加载完毕了，然后开始执行`main`包里面的常量和变量的初始化，然后执行`main`包里面的`init`函数（如果存在的话），最后执行到了`main`函数。下图详细的解释了整个的执行过程。

 ![](images/2.3.init.png?raw=true)

@@ -453,5 +454,5 @@ Go程序里面会自动调用init()和main()，所以你不需要在任何地方
   * 上一章: [Go基础](<2.2.md>)
   * 下一节: [struct类型](<2.4.md>)

-## LastModified 
+## LastModified
   * $Id$
--- a/2.4.md
+++ b/2.4.md
@@ -3,7 +3,7 @@
 Go语言中，也和C或者其他语言一样，我们可以声明新的类型，作为其它类型的属性或字段的容器。例如，我们可以创建一个自定义类型`person`代表一个人的实体。这个实体拥有属性：姓名和年龄。这样的类型我们称之`struct`。如下代码所示:

 	type person struct {
-    	name string 
+		name string
 		age int
 	}
 看到了吗？申明一个struct如此简单，上面的类型包含有两个字段
@@ -18,16 +18,16 @@ Go语言中，也和C或者其他语言一样，我们可以声明新的类型
 	}

 	var P person // P现在就是person类型的变量了
-	
+
 	P.name = "Astaxie" //赋值"Astaxie"给P的name属性.
 	P.age = 25 //赋值"25"给变量P的age属性
-	fmt.Printf("The person's name is %s", P.name) // 访问P的name属性.	
+	fmt.Printf("The person's name is %s", P.name) // 访问P的name属性.
 除了上面这种P的申明使用之外，还有两种申明使用方式

 - 1.按照顺序提供初始化值

 		P := person{"Tom", 25}
-	
+
 - 2.通过`field:value`的方式初始化，这样可以任意顺序

 		P := person{age:24, name:"Tom"}
@@ -54,26 +54,26 @@ Go语言中，也和C或者其他语言一样，我们可以声明新的类型

 	func main() {
 	    var tom person
-	
+
 	    //赋值初始化
 	    tom.name, tom.age = "Tom", 18
-	
+
 	    //两个字段都写清楚的初始化
 	    bob := person{age:25, name:"Bob"}
-	    
+
 	    //按照struct定义顺序初始化值
 	    paul := person{"Paul", 43}
-		
+
 	    tb_Older, tb_diff := Older(tom, bob)
 	    tp_Older, tp_diff := Older(tom, paul)
 	    bp_Older, bp_diff := Older(bob, paul)
-	
+
 	    fmt.Printf("Of %s and %s, %s is older by %d years\n",
 	                tom.name, bob.name, tb_Older.name, tb_diff)
-	
+
 	    fmt.Printf("Of %s and %s, %s is older by %d years\n",
 	                tom.name, paul.name, tp_Older.name, tp_diff)
-	
+
 	    fmt.Printf("Of %s and %s, %s is older by %d years\n",
 	                bob.name, paul.name, bp_Older.name, bp_diff)
 	}
@@ -87,22 +87,22 @@ Go语言中，也和C或者其他语言一样，我们可以声明新的类型

 	package main
 	import "fmt"
-	
+
 	type Human struct {
 	    name string
 	    age int
 	    weight int
 	}
-	
+
 	type Student struct {
 	    Human //匿名字段，那么默认Student就包含了Human的所有字段
 	    speciality string
 	}
-	
+
 	func main() {
 	    //我们初始化一个学生
 	    mark := Student{Human{"Mark", 25, 120}, "Computer Science"}
-	    
+
 	    //我们访问相应的字段
 	    fmt.Println("His name is ", mark.name)
 	    fmt.Println("His age is ", mark.age)
@@ -126,27 +126,27 @@ Go语言中，也和C或者其他语言一样，我们可以声明新的类型

 	mark.Human = Human{"Marcus", 55, 220}
 	mark.Human.age -= 1
-	
+
 通过匿名访问和修改字段相当的有用，但是不仅仅是struct字段哦，所有的内置类型和自定义类型都是可以作为匿名字段的。请看下面的例子

 	package main
 	import "fmt"

 	type Skills []string
-	
+
 	type Human struct {
 	    name string
 	    age int
 	    weight int
 	}
-	
+
 	type Student struct {
 	    Human //匿名字段，struct
 	    Skills //匿名字段，自定义的类型string slice
 	    int //内置类型作为匿名字段
 	    speciality string
 	}
-	
+
 	func main() {
 	    //初始化学生Jane
 	    jane := Student{Human:Human{"Jane", 35, 100}, speciality:"Biology"}
@@ -165,7 +165,7 @@ Go语言中，也和C或者其他语言一样，我们可以声明新的类型
 	    jane.int = 3
 	    fmt.Println("Her preferred number is", jane.int)
 	}
-	
+
 从上面例子我们看出来struct不仅仅能够将struct作为匿名字段、自定义类型、内置类型都可以作为匿名字段，而且可以在相应的字段上面进行函数操作(如例子中的append)。

 这里有一个问题：如果human里面有一个字段叫做phone，而student也有一个字段叫做phone，那么该怎么办呢？
@@ -182,13 +182,13 @@ Go里面很简单的解决了这个问题，最外层的优先访问，也就是
 	    age int
 	    phone string //Human类型拥有的字段
 	}
-	
+
 	type Employee struct {
 	    Human //匿名字段Human
 	    speciality string
 	    phone string //雇员的phone字段
 	}
-	
+
 	func main() {
 	    Bob := Employee{Human{"Bob", 34, "777-444-XXXX"}, "Designer", "333-222"}
 	    fmt.Println("Bob's work phone is:", Bob.phone)
@@ -202,5 +202,5 @@ Go里面很简单的解决了这个问题，最外层的优先访问，也就是
   * 上一章: [流程和函数](<2.3.md>)
   * 下一节: [面向对象](<2.5.md>)

-## LastModified 
+## LastModified
   * $Id$
--- a/2.md
+++ b/2.md
@@ -5,12 +5,12 @@
   * 2. [Go基础](2.2.md)
   * 3. [流程和函数](2.3.md)
   * 4. [struct类型](2.4.md)
-   * 5. [面向对象](2.5.md)
+   * 5. [面向对象](2.5.md)
   * 6. [interface](2.6.md)
   * 7. [并发](2.7.md)
   * 8. [小结](2.8.md)
-   
-Go是一门类似C的编译性语言，但是他的编译速度非常快，这门语言的关键字加起来也就二十五个，比英文字母的二十六还少一个，这对于我们来说学习就变得简单了很多，先让我们看一眼这些关键字都长成怎么样：
+
+Go是一门类似C的编译型语言，但是它的编译速度非常快。这门语言的关键字加起来也就二十五个，比英文字母的二十六还少一个，这对于我们来说学习就变得简单了很多。先让我们看一眼这些关键字都长成怎么样：

 	break    default      func    interface    select
 	case     defer        go      map          struct
@@ -18,7 +18,7 @@ Go是一门类似C的编译性语言，但是他的编译速度非常快，这
 	const    fallthrough  if      range        type
 	continue for          import  return       var

-在接下来的这一章里面，我将带领你去了解这门语言的基础，通过每个小节的介绍，你将会了解到Go的世界是那么的简洁，设计是如此的美妙，编写Go将会是一件愉快的事情，回过头来你就会发现上面这二十五个关键字是那么的亲切。
+在接下来的这一章里面，我将带领你去了解这门语言的基础，通过每个小节的介绍，你将会了解到Go的世界是那么的简洁，设计是如此的美妙，编写Go将会是一件愉快的事情，回过头来你就会发现上面这二十五个关键字是那么地亲切。


 ## links
@@ -26,5 +26,5 @@ Go是一门类似C的编译性语言，但是他的编译速度非常快，这
   * 上一章: [第一章总结](<1.5.md>)
   * 下一节: [你好，Go](<2.1.md>)

-## LastModified 
-   * $Id$
+## LastModified
+   * $Id$