removed all the footers; formated all the files

1.1.md

@@ -130,8 +130,5 @@ homebrew是Mac系统下面目前使用最多的管理软件的工具，目前已
 	* 上一节: [Go环境配置](<1.md>)
 	* 下一节: [GOPATH 与工作空间](<1.2.md>)
 
-## LastModified
-	* $Id$
-
 [downlink]: http://code.google.com/p/go/downloads/list "Go安装包下载"
 [hg]: http://mercurial.selenic.com/downloads/ "Mercurial下载"

1.2.md

-# 1.2 GOPATH与工作空间
-
-## GOPATH设置
-  go 命令依赖一个重要的环境变量：$GOPATH<sup>1</sup>
-  
-  *（注：这个不是Go安装目录。下面以笔者的工作目录为说明，请替换自己机器上的工作目录。）*
-
-  在类似 Unix 环境大概这样设置：
-
-    export GOPATH=/home/apple/mygo
-
-  Windows 设置如下，新建一个环境变量名称叫做GOPATH：
-
-    GOPATH=c:\mygo
-
-GOPATH允许多个目录，当有多个目录时，请注意分隔符，多个GOPATH的时候Windows是分号，Linux系统是冒号，当有多个GOPATH时，默认会将go get的内容放在第一个目录下
-
-
-以上 $GOPATH 目录约定有三个子目录：
-
-- src 存放源代码（比如：.go .c .h .s等）
-- pkg 编译后生成的文件（比如：.a）
-- bin 编译后生成的可执行文件（为了方便，可以把此目录加入到 $PATH 变量中）
-
-以后我所有的例子都是以mygo作为我的gopath目录
-
-## 应用目录结构
-建立包和目录：$GOPATH/src/mymath/sqrt.go（包名："mymath"）
-
-以后自己新建应用或者一个代码包都是在src目录下新建一个文件夹，文件夹名称代码包名称，当然也允许多级目录，例如在src下面新建了目录$GOPATH/src/github.com/astaxie/beedb 那么这个包名称就是“github.com/astaxie/beedb”
-
-执行如下代码
-
-    cd $GOPATH/src
-    mkdir mymath
-
-新建文件sqrt.go，内容如下
-
-    // $GOPATH/src/mymath/sqrt.go源码如下：
-    package mymath
-
-    func Sqrt(x float64) float64 {
-          z := 0.0
-          for i := 0; i < 1000; i++ {
-                  z -= (z*z - x) / (2 * x)
-          }
-          return z
-    }
-
-这样我的应用包目录和代码已经新建完毕，注意：package的名称必须和目录名保持一致
-
-## 编译应用
-上面我们已经建立了自己的应用包，如何进行编译安装呢？有两种方式可以进行安装
-
-1、只要进入对应的应用包目录，然后执行`go install`，就可以安装了
-
-2、在任意的目录执行如下代码`go install mymath`
-
-安装完之后，我们可以进入如下目录
-
-    cd $GOPATH/pkg/${GOOS}_${GOARCH}   
-    //可以看到如下文件
-    mymath.a
-
-这个.a文件是应用包，相当于一个函数库一样，那么我们如何进行调用呢？
-
-接下来我们新建一个应用程序来调用
-
-新建应用包mathapp
-
-    cd $GOPATH/src
-    mkdir mathapp
-    vim main.go
-
-// `$GOPATH/src/mathapp/main.go`源码：
-
-    package main
-
-    import (
-          "mymath"
-          "fmt"
-    )
-
-    func main() {
-          fmt.Printf("Hello, world.  Sqrt(2) = %v\n", mymath.Sqrt(2))
-    }
-
-如何编译程序呢？进入该应用目录，然后执行`go build`，那么在该目录下面会生成一个mathapp的可执行文件
-
-    ./mathapp
-
-输出如下内容
-
-    Hello, world.  Sqrt(2) = 1.414213562373095
-
-如何安装该应用，进入该目录执行`go install`,那么在$GOPATH/bin/下增加了一个可执行文件mathapp,这样可以在命令行输入如下命令就可以执行
-
-    mathapp
-
-也是输出如下内容
-
-    Hello, world.  Sqrt(2) = 1.414213562373095
-
-## 获取远程包
-   go语言有一个获取远程包的工具就是`go get`，目前go get支持多数开源社区(例如：github、googlecode、bitbucket、Launchpad)
-
-    go get github.com/astaxie/beedb
-
-通过这个命令可以获取相应的源码，对应的开源平台采用不同的源码控制工具，例如github采用git、googlecode采用hg，所以要想获取这些源码，必须先安装相应的源码控制工具
-
-通过上面获取的代码在我们本地的源码相应的代码结构如下
-
-    $GOPATH
-      src
-       |--github.com
-              |-astaxie
-                  |-beedb
-       pkg
-        |--相应平台
-             |-github.com
-                   |--astaxie
-                        |beedb.a
-
-go get本质上可以理解为首先第一步是通过源码工具clone代码到src下面，然后执行`go install`
-
-在代码中如何使用远程包，很简单的就是和使用本地包一样，只要在开头import相应的路径就可以
-
-    import "github.com/astaxie/beedb"
-
-## 程序的整体结构
-通过上面建立的我本地的mygo的目录结构如下所示
-
-    bin/
-        mathapp
-    pkg/
-        平台名/ 如：darwin_amd64、linux_amd64
-             mymath.a
-             github.com/
-                  astaxie/
-                       beedb.a
-    src/
-        mathapp
-              main.go
-          mymath/
-              sqrt.go
-          github.com/
-               astaxie/
-                    beedb/
-                        beedb.go
-                        util.go
-
-从上面的结构我们可以很清晰的看到，bin目录下面存的是编译之后可执行的文件，pkg下面存放的是函数包，src下面保存的是应用源代码
-
- - - -
-[1] Windows系统中环境变量的形式为`%GOPATH%`，本书主要使用Unix形式，Windows用户请自行替换。
-## links
-  * [目录](<preface.md>)
-  * 上一节: [GO安装](<1.1.md>)
-  * 下一节: [GO 命令](<1.3.md>)
-
-## LastModified
-   * $Id$
+# 1.2 GOPATH与工作空间
+
+## GOPATH设置
+  go 命令依赖一个重要的环境变量：$GOPATH<sup>1</sup>
+
+  *（注：这个不是Go安装目录。下面以笔者的工作目录为说明，请替换自己机器上的工作目录。）*
+
+  在类似 Unix 环境大概这样设置：
+
+	export GOPATH=/home/apple/mygo
+
+  Windows 设置如下，新建一个环境变量名称叫做GOPATH：
+
+	GOPATH=c:\mygo
+
+GOPATH允许多个目录，当有多个目录时，请注意分隔符，多个GOPATH的时候Windows是分号，Linux系统是冒号，当有多个GOPATH时，默认会将go get的内容放在第一个目录下
+
+
+以上 $GOPATH 目录约定有三个子目录：
+
+- src 存放源代码（比如：.go .c .h .s等）
+- pkg 编译后生成的文件（比如：.a）
+- bin 编译后生成的可执行文件（为了方便，可以把此目录加入到 $PATH 变量中）
+
+以后我所有的例子都是以mygo作为我的gopath目录
+
+## 应用目录结构
+建立包和目录：$GOPATH/src/mymath/sqrt.go（包名："mymath"）
+
+以后自己新建应用或者一个代码包都是在src目录下新建一个文件夹，文件夹名称代码包名称，当然也允许多级目录，例如在src下面新建了目录$GOPATH/src/github.com/astaxie/beedb 那么这个包名称就是“github.com/astaxie/beedb”
+
+执行如下代码
+
+	cd $GOPATH/src
+	mkdir mymath
+
+新建文件sqrt.go，内容如下
+
+	// $GOPATH/src/mymath/sqrt.go源码如下：
+	package mymath
+
+	func Sqrt(x float64) float64 {
+		z := 0.0
+		for i := 0; i < 1000; i++ {
+			z -= (z*z - x) / (2 * x)
+		}
+		return z
+	}
+
+这样我的应用包目录和代码已经新建完毕，注意：package的名称必须和目录名保持一致
+
+## 编译应用
+上面我们已经建立了自己的应用包，如何进行编译安装呢？有两种方式可以进行安装
+
+1、只要进入对应的应用包目录，然后执行`go install`，就可以安装了
+
+2、在任意的目录执行如下代码`go install mymath`
+
+安装完之后，我们可以进入如下目录
+
+	cd $GOPATH/pkg/${GOOS}_${GOARCH}
+	//可以看到如下文件
+	mymath.a
+
+这个.a文件是应用包，相当于一个函数库一样，那么我们如何进行调用呢？
+
+接下来我们新建一个应用程序来调用
+
+新建应用包mathapp
+
+	cd $GOPATH/src
+	mkdir mathapp
+	vim main.go
+
+// `$GOPATH/src/mathapp/main.go`源码：
+
+	package main
+
+	import (
+		  "mymath"
+		  "fmt"
+	)
+
+	func main() {
+		  fmt.Printf("Hello, world.  Sqrt(2) = %v\n", mymath.Sqrt(2))
+	}
+
+如何编译程序呢？进入该应用目录，然后执行`go build`，那么在该目录下面会生成一个mathapp的可执行文件
+
+	./mathapp
+
+输出如下内容
+
+	Hello, world.  Sqrt(2) = 1.414213562373095
+
+如何安装该应用，进入该目录执行`go install`,那么在$GOPATH/bin/下增加了一个可执行文件mathapp,这样可以在命令行输入如下命令就可以执行
+
+	mathapp
+
+也是输出如下内容
+
+	Hello, world.  Sqrt(2) = 1.414213562373095
+
+## 获取远程包
+   go语言有一个获取远程包的工具就是`go get`，目前go get支持多数开源社区(例如：github、googlecode、bitbucket、Launchpad)
+
+	go get github.com/astaxie/beedb
+
+通过这个命令可以获取相应的源码，对应的开源平台采用不同的源码控制工具，例如github采用git、googlecode采用hg，所以要想获取这些源码，必须先安装相应的源码控制工具
+
+通过上面获取的代码在我们本地的源码相应的代码结构如下
+
+	$GOPATH
+	  src
+	   |--github.com
+			  |-astaxie
+				  |-beedb
+	   pkg
+		|--相应平台
+			 |-github.com
+				   |--astaxie
+						|beedb.a
+
+go get本质上可以理解为首先第一步是通过源码工具clone代码到src下面，然后执行`go install`
+
+在代码中如何使用远程包，很简单的就是和使用本地包一样，只要在开头import相应的路径就可以
+
+	import "github.com/astaxie/beedb"
+
+## 程序的整体结构
+通过上面建立的我本地的mygo的目录结构如下所示
+
+	bin/
+		mathapp
+	pkg/
+		平台名/ 如：darwin_amd64、linux_amd64
+			 mymath.a
+			 github.com/
+				  astaxie/
+					   beedb.a
+	src/
+		mathapp
+			  main.go
+		  mymath/
+			  sqrt.go
+		  github.com/
+			   astaxie/
+					beedb/
+						beedb.go
+						util.go
+
+从上面的结构我们可以很清晰的看到，bin目录下面存的是编译之后可执行的文件，pkg下面存放的是函数包，src下面保存的是应用源代码
+
+ - - -
+[1] Windows系统中环境变量的形式为`%GOPATH%`，本书主要使用Unix形式，Windows用户请自行替换。
+## links
+  * [目录](<preface.md>)
+  * 上一节: [GO安装](<1.1.md>)
+  * 下一节: [GO 命令](<1.3.md>)

1.3.md

-# 1.3 Go 命令
-
-## Go 命令
-
-  Go语言自带有一套完整的命令操作工具，你可以通过在命令行中执行`go`来查看它们：
-
-  ![](images/1.3.go.png?raw=true)
-
-  这些命令对于我们平时编写的代码非常有用，接下来就让我们了解一些常用的命令。
-
-## go build
-
-  这个命令主要用于测试编译。在包的编译过程中，若有必要，会同时编译与之相关联的包。
-
-  - 如果是普通包，就像我们在1.2节中编写的`mymath`包那样，当你执行`go build`之后，它不会产生任何文件。如果你需要在`$GOPATH/pkg`下生成相应的文件，那就得执行`go install`了。
-
-  - 如果是`main`包，当你执行`go build`之后，它就会在当前目录下生成一个可执行文件。如果你需要在`$GOPATH/bin`下生成相应的文件，同样需要执行`go install`。
-
-  - 如果某个项目文件夹下有多个文件，而你只想编译某个文件，就可在`go build`之后加上文件名，例如`go build a.go`；`go build`命令默认会编译当前目录下的所有go文件。
-
-  - 你也可以指定编译输出的文件名。例如1.2节中的`mathapp`应用，我们可以指定`go build -o astaxie.exe`，默认情况是你的package名，就是你的文件夹名称。
-
-  （注：实际上，package名在[Go语言规范](https://golang.org/ref/spec)中指代码中“package”后使用的名称，此名称可以与文件夹名不同。默认生成的可执行文件名是文件夹名。）
-
-  - go build会忽略目录下以“_”或“.”开头的go文件。
-
-  - 如果你的源代码针对不同的操作系统需要不同的处理，那么你可以根据不同的操作系统后缀来命名文件。例如有一个读取数组的程序，它对于不同的操作系统可能有如下几个源文件：
-
-		array_linux.go
-		array_darwin.go
-		array_windows.go
-		array_freebsd.go
-
-  `go build`的时候会选择性地编译以系统名结尾的文件（linux、darwin、windows、freebsd）。例如Linux系统下面编译只会选择array_linux.go文件，其它系统命名后缀文件全部忽略。
-
-## go clean
-
-  这个命令是用来移除当前源码包里面编译的文件的。这些文件包括
-
-	_obj/            旧的object目录，由Makefiles遗留
-	_test/           旧的test目录，由Makefiles遗留
-	_testmain.go     旧的gotest文件，由Makefiles遗留
-	test.out         旧的test记录，由Makefiles遗留
-	build.out        旧的test记录，由Makefiles遗留
-	*.[568ao]        object文件，由Makefiles遗留
-
-	DIR(.exe)        由go build产生
-	DIR.test(.exe)   由go test -c产生
-	MAINFILE(.exe)   由go build MAINFILE.go产生
-
-  我一般都是利用这个命令进行清除编译文件，然后github递交源码，在本机测试的时候这些编译文件都是和系统相关的，但是对于源码管理来说没必要
-
-## go fmt
-
-  有过C/C++经验的读者会知道,一些人经常为代码采取K&R风格还是ANSI风格而争论不休。在go中，代码则有标准的风格。由于之前已经有的一些习惯或其它的原因我们常将代码写成ANSI风格或者其它更合适自己的格式，这将为人们在阅读别人的代码时添加不必要的负担，所以go强制了代码格式（比如左大括号必须放在行尾），不按照此格式的代码将不能编译通过，为了减少浪费在排版上的时间，go工具集中提供了一个`go fmt`命令 它可以帮你格式化你写好的代码文件，使你写代码的时候不需要关心格式，你只需要在写完之后执行`go fmt <文件名>.go`，你的代码就被修改成了标准格式，但是我平常很少用到这个命令，因为开发工具里面一般都带了保存时候自动格式化功能，这个功能其实在底层就是调用了`go fmt`。接下来的一节我将讲述两个工具，这两个工具都自带了保存文件时自动化`go fmt`功能。
-
-## go get
-
-  这个命令是用来动态获取远程代码包的，目前支持的有BitBucket、GitHub、Google Code和Launchpad。这个命令在内部实际上分成了两步操作：第一步是下载源码包，第二步是执行`go install`。下载源码包的go工具会自动根据不同的域名调用不同的源码工具，对应关系如下：
-
-	BitBucket (Mercurial Git)
-	GitHub (Git)
-	Google Code Project Hosting (Git, Mercurial, Subversion)
-	Launchpad (Bazaar)
-
-  所以为了`go get` 能正常工作，你必须确保安装了合适的源码管理工具，并同时把这些命令加入你的PATH中。其实`go get`支持自定义域名的功能，具体参见`go help remote`。
-
-## go install
-
-  这个命令在内部实际上分成了两步操作：第一步是`go build`，第二步会把编译好的东西move到`$GOPATH/pkg`或者`$GOPATH/bin`。
-
-## go test
-
-  执行这个命令，会自动读取源码目录下面名为`*_test.go`的文件，生成并运行测试用的可执行文件。输出的信息类似
-
-	ok   archive/tar   0.011s
-	FAIL archive/zip   0.022s
-	ok   compress/gzip 0.033s
-	...
-
-  默认的情况下，不需要任何的参数，它会自动把你源码包下面所有test文件测试完毕，当然你也可以带上参数，详情请参考`go help testflag`
-
-## go doc
-
-  很多人说go不需要任何的第三方文档，例如chm手册之类的（其实我已经做了一个了，[chm手册](https://github.com/astaxie/godoc)），因为它内部就有一个很强大的文档工具。
-
-    如何查看相应package的文档呢？
-    例如builtin包，那么执行`go doc builtin`
-    如果是http包，那么执行`go doc net/http`
-    查看某一个包里面的函数，那么执行`godoc fmt Printf`
-    也可以查看相应的代码，执行`godoc -src fmt Printf`
-
-  通过命令在命令行执行 godoc -http=:端口号 比如`godoc -http=:8080`。然后在浏览器中打开`127.0.0.1:8080`，你将会看到一个golang.org的本地copy版本，通过它你可以查询pkg文档等其它内容。如果你设置了GOPATH，在pkg分类下，不但会列出标准包的文档，还会列出你本地`GOPATH`中所有项目的相关文档，这对于经常被墙的用户来说是一个不错的选择。
-
-## 其它命令
-
-  go还提供了其它很多的工具，例如下面的这些工具
-
-	go fix 用来修复以前老版本的代码到新版本，例如go1之前老版本的代码转化到go1
-	go version 查看go当前的版本
-	go env 查看当前go的环境变量
-	go list 列出当前全部安装的package
-	go run 编译并运行Go程序
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [GOPATH与工作空间](<1.2.md>)
-   * 下一节: [Go开发工具](<1.4.md>)
-
-## LastModified
-   * $Id$
+# 1.3 Go 命令
+
+## Go 命令
+
+  Go语言自带有一套完整的命令操作工具，你可以通过在命令行中执行`go`来查看它们：
+
+  ![](images/1.3.go.png?raw=true)
+
+  这些命令对于我们平时编写的代码非常有用，接下来就让我们了解一些常用的命令。
+
+## go build
+
+  这个命令主要用于测试编译。在包的编译过程中，若有必要，会同时编译与之相关联的包。
+
+  - 如果是普通包，就像我们在1.2节中编写的`mymath`包那样，当你执行`go build`之后，它不会产生任何文件。如果你需要在`$GOPATH/pkg`下生成相应的文件，那就得执行`go install`了。
+
+  - 如果是`main`包，当你执行`go build`之后，它就会在当前目录下生成一个可执行文件。如果你需要在`$GOPATH/bin`下生成相应的文件，同样需要执行`go install`。
+
+  - 如果某个项目文件夹下有多个文件，而你只想编译某个文件，就可在`go build`之后加上文件名，例如`go build a.go`；`go build`命令默认会编译当前目录下的所有go文件。
+
+  - 你也可以指定编译输出的文件名。例如1.2节中的`mathapp`应用，我们可以指定`go build -o astaxie.exe`，默认情况是你的package名，就是你的文件夹名称。
+
+  （注：实际上，package名在[Go语言规范](https://golang.org/ref/spec)中指代码中“package”后使用的名称，此名称可以与文件夹名不同。默认生成的可执行文件名是文件夹名。）
+
+  - go build会忽略目录下以“_”或“.”开头的go文件。
+
+  - 如果你的源代码针对不同的操作系统需要不同的处理，那么你可以根据不同的操作系统后缀来命名文件。例如有一个读取数组的程序，它对于不同的操作系统可能有如下几个源文件：
+
+	array_linux.go
+	array_darwin.go
+	array_windows.go
+	array_freebsd.go
+
+  `go build`的时候会选择性地编译以系统名结尾的文件（linux、darwin、windows、freebsd）。例如Linux系统下面编译只会选择array_linux.go文件，其它系统命名后缀文件全部忽略。
+
+## go clean
+
+  这个命令是用来移除当前源码包里面编译的文件的。这些文件包括
+
+	_obj/            旧的object目录，由Makefiles遗留
+	_test/           旧的test目录，由Makefiles遗留
+	_testmain.go     旧的gotest文件，由Makefiles遗留
+	test.out         旧的test记录，由Makefiles遗留
+	build.out        旧的test记录，由Makefiles遗留
+	*.[568ao]        object文件，由Makefiles遗留
+
+	DIR(.exe)        由go build产生
+	DIR.test(.exe)   由go test -c产生
+	MAINFILE(.exe)   由go build MAINFILE.go产生
+
+  我一般都是利用这个命令进行清除编译文件，然后github递交源码，在本机测试的时候这些编译文件都是和系统相关的，但是对于源码管理来说没必要
+
+## go fmt
+
+  有过C/C++经验的读者会知道,一些人经常为代码采取K&R风格还是ANSI风格而争论不休。在go中，代码则有标准的风格。由于之前已经有的一些习惯或其它的原因我们常将代码写成ANSI风格或者其它更合适自己的格式，这将为人们在阅读别人的代码时添加不必要的负担，所以go强制了代码格式（比如左大括号必须放在行尾），不按照此格式的代码将不能编译通过，为了减少浪费在排版上的时间，go工具集中提供了一个`go fmt`命令 它可以帮你格式化你写好的代码文件，使你写代码的时候不需要关心格式，你只需要在写完之后执行`go fmt <文件名>.go`，你的代码就被修改成了标准格式，但是我平常很少用到这个命令，因为开发工具里面一般都带了保存时候自动格式化功能，这个功能其实在底层就是调用了`go fmt`。接下来的一节我将讲述两个工具，这两个工具都自带了保存文件时自动化`go fmt`功能。
+
+## go get
+
+  这个命令是用来动态获取远程代码包的，目前支持的有BitBucket、GitHub、Google Code和Launchpad。这个命令在内部实际上分成了两步操作：第一步是下载源码包，第二步是执行`go install`。下载源码包的go工具会自动根据不同的域名调用不同的源码工具，对应关系如下：
+
+	BitBucket (Mercurial Git)
+	GitHub (Git)
+	Google Code Project Hosting (Git, Mercurial, Subversion)
+	Launchpad (Bazaar)
+
+  所以为了`go get` 能正常工作，你必须确保安装了合适的源码管理工具，并同时把这些命令加入你的PATH中。其实`go get`支持自定义域名的功能，具体参见`go help remote`。
+
+## go install
+
+  这个命令在内部实际上分成了两步操作：第一步是`go build`，第二步会把编译好的东西move到`$GOPATH/pkg`或者`$GOPATH/bin`。
+
+## go test
+
+  执行这个命令，会自动读取源码目录下面名为`*_test.go`的文件，生成并运行测试用的可执行文件。输出的信息类似
+
+	ok   archive/tar   0.011s
+	FAIL archive/zip   0.022s
+	ok   compress/gzip 0.033s
+	...
+
+  默认的情况下，不需要任何的参数，它会自动把你源码包下面所有test文件测试完毕，当然你也可以带上参数，详情请参考`go help testflag`
+
+## go doc
+
+  很多人说go不需要任何的第三方文档，例如chm手册之类的（其实我已经做了一个了，[chm手册](https://github.com/astaxie/godoc)），因为它内部就有一个很强大的文档工具。
+
+  如何查看相应package的文档呢？
+  例如builtin包，那么执行`go doc builtin`
+  如果是http包，那么执行`go doc net/http`
+  查看某一个包里面的函数，那么执行`godoc fmt Printf`
+  也可以查看相应的代码，执行`godoc -src fmt Printf`
+
+  通过命令在命令行执行 godoc -http=:端口号 比如`godoc -http=:8080`。然后在浏览器中打开`127.0.0.1:8080`，你将会看到一个golang.org的本地copy版本，通过它你可以查询pkg文档等其它内容。如果你设置了GOPATH，在pkg分类下，不但会列出标准包的文档，还会列出你本地`GOPATH`中所有项目的相关文档，这对于经常被墙的用户来说是一个不错的选择。
+
+## 其它命令
+
+  go还提供了其它很多的工具，例如下面的这些工具
+
+	go fix 用来修复以前老版本的代码到新版本，例如go1之前老版本的代码转化到go1
+	go version 查看go当前的版本
+	go env 查看当前go的环境变量
+	go list 列出当前全部安装的package
+	go run 编译并运行Go程序
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [GOPATH与工作空间](<1.2.md>)
+   * 下一节: [Go开发工具](<1.4.md>)

1.5.md

-# 总结
-
-这一章中我们主要介绍了如何安装Go，以及如何配置本地的`$GOPATH`，通过设置`$GOPATH`之后如何创建项目，项目创建之后如何编译、如何安装，接着介绍了一些Go的常用命令工具，最后介绍了Go的开发工具，希望能够通过有利的工具快速的开发Go应用。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [Go开发工具](<1.4.md>)
-   * 下一章: [go语言基础](<2.md>)
-
-## LastModified
-   * $Id$
+# 总结
+
+这一章中我们主要介绍了如何安装Go，以及如何配置本地的`$GOPATH`，通过设置`$GOPATH`之后如何创建项目，项目创建之后如何编译、如何安装，接着介绍了一些Go的常用命令工具，最后介绍了Go的开发工具，希望能够通过有利的工具快速的开发Go应用。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [Go开发工具](<1.4.md>)
+   * 下一章: [go语言基础](<2.md>)

1.md

-# 1 GO环境配置
-
-## 目录
-  * 1. [Go安装](1.1.md)
-  * 2. [GOPATH与工作空间](1.2.md)
-  * 3. [Go命令](1.3.md)
-  * 4. [Go开发工具](1.4.md)
-  * 5. [小结](1.5.md)
-
-欢迎来到Go的世界，让我们开始吧！
-
-Go是一种新的语言，一种并发的、带垃圾回收的、快速编译的语言。它具有以下特点：
-
-- 它可以在一台计算机上用几秒钟的时间编译一个大型的Go程序。
-- Go为软件构造提供了一种模型，它使依赖分析更加容易，且避免了大部分C风格include文件与库的开头。
-- Go是静态类型的语言，它的类型系统没有层级。因此用户不需要在定义类型之间的关系上花费时间，这样感觉起来比典型的面向对象语言更轻量级。
-- Go完全是垃圾回收型的语言，并为并发执行与通信提供了基本的支持。
-- 按照其设计，Go打算为多核机器上系统软件的构造提供一种方法。
-
-Go试图成为结合解释型编程的轻松、动态类型语言的高效以及静态类型语言的安全的编译型语言。它也打算成为现代的，支持网络与多核计算的语言。要满足这些目标，需要解决一些语言上的问题：一个富有表达能力但轻量级的类型系统，并发与垃圾回收机制，严格的依赖规范等等。这些无法通过库或工具解决好，因此Go也就应运而生了。
-
-在本章中，我们将讲述Go的安装方法，以及如何配置项目信息。
-
-## links
-  * [目录](<preface.md>)
-  * 下一节: [Go安装](<1.1.md>)
-
-## LastModified
-  * $Id$
+# 1 GO环境配置
+
+## 目录
+  * 1. [Go安装](1.1.md)
+  * 2. [GOPATH与工作空间](1.2.md)
+  * 3. [Go命令](1.3.md)
+  * 4. [Go开发工具](1.4.md)
+  * 5. [小结](1.5.md)
+
+欢迎来到Go的世界，让我们开始吧！
+
+Go是一种新的语言，一种并发的、带垃圾回收的、快速编译的语言。它具有以下特点：
+
+- 它可以在一台计算机上用几秒钟的时间编译一个大型的Go程序。
+- Go为软件构造提供了一种模型，它使依赖分析更加容易，且避免了大部分C风格include文件与库的开头。
+- Go是静态类型的语言，它的类型系统没有层级。因此用户不需要在定义类型之间的关系上花费时间，这样感觉起来比典型的面向对象语言更轻量级。
+- Go完全是垃圾回收型的语言，并为并发执行与通信提供了基本的支持。
+- 按照其设计，Go打算为多核机器上系统软件的构造提供一种方法。
+
+Go试图成为结合解释型编程的轻松、动态类型语言的高效以及静态类型语言的安全的编译型语言。它也打算成为现代的，支持网络与多核计算的语言。要满足这些目标，需要解决一些语言上的问题：一个富有表达能力但轻量级的类型系统，并发与垃圾回收机制，严格的依赖规范等等。这些无法通过库或工具解决好，因此Go也就应运而生了。
+
+在本章中，我们将讲述Go的安装方法，以及如何配置项目信息。
+
+## links
+  * [目录](<preface.md>)
+  * 下一节: [Go安装](<1.1.md>)

10.1.md

-# 10.1 设置默认地区
-## 什么是Locale
-Locale是一组描述世界上某一特定区域文本格式和语言习惯的设置的集合。locale名通常由三个部分组成：第一部分，是一个强制性的，表示语言的缩写，例如"en"表示英文或"zh"表示中文。第二部分，跟在一个下划线之后，是一个可选的国家说明符，用于区分讲同一种语言的不同国家，例如"en_US"表示美国英语，而"en_UK"表示英国英语。最后一部分，跟在一个句点之后，是可选的字符集说明符，例如"zh_CN.gb2312"表示中国使用gb2312字符集。
-
-GO语言默认采用"UTF-8"编码集，所以我们实现i18n时不考虑第三部分，接下来我们都采用locale描述的前面两部分来作为i18n标准的locale名。
-
-
->在Linux和Solaris系统中可以通过`locale -a`命令列举所有支持的地区名，读者可以看到这些地区名的命名规范。对于BSD等系统，没有locale命令，但是地区信息存储在/usr/share/locale中。
-
-## 设置Locale
-有了上面对locale的定义，那么我们就需要根据用户的信息(访问信息、个人信息、访问域名等)来设置与之相关的locale，我们可以通过如下几种方式来设置用户的locale。
-
-### 通过域名设置Locale
-设置Locale的办法这一就是在应用运行的时候采用域名分级的方式，例如，我们采用www.asta.com当做我们的英文站(默认站)，而把域名www.asta.cn当做中文站。这样通过在应用里面设置域名和相应的locale的对应关系，就可以设置好地区。这样处理有几点好处：
-
-- 通过URL就可以很明显的识别
-- 用户可以通过域名很直观的知道将访问那种语言的站点
-- 在Go程序中实现非常的简单方便，通过一个map就可以实现
-- 有利于搜索引擎抓取，能够提高站点的SEO
-
-我们可以通过下面的代码来实现域名的对应locale：
-
-	if r.Host == "www.asta.com" {
-		i18n.SetLocale("en")
-	} else if r.Host == "www.asta.cn" {
-		i18n.SetLocale("zh-CN")
-	} else if r.Host == "www.asta.tw" {
-		i18n.SetLocale("zh-TW")
-	}
-
-当然除了整域名设置地区之外，我们还可以通过子域名来设置地区，例如"en.asta.com"表示英文站点，"cn.asta.com"表示中文站点。实现代码如下所示：
-
-	prefix := strings.Split(r.Host,".")
-
-	if prefix[0] == "en" {
-		i18n.SetLocale("en")
-	} else if prefix[0] == "cn" {
-		i18n.SetLocale("zh-CN")
-	} else if prefix[0] == "tw" {
-		i18n.SetLocale("zh-TW")
-	}
-
-通过域名设置Locale有如上所示的优点，但是我们一般开发Web应用的时候不会采用这种方式，因为首先域名成本比较高，开发一个Locale就需要一个域名，而且往往统一名称的域名不一定能申请的到，其次我们不愿意为每个站点去本地化一个配置，而更多的是采用url后面带参数的方式，请看下面的介绍。
-
-### 从域名参数设置Locale
+# 10.1 设置默认地区
+## 什么是Locale
+Locale是一组描述世界上某一特定区域文本格式和语言习惯的设置的集合。locale名通常由三个部分组成：第一部分，是一个强制性的，表示语言的缩写，例如"en"表示英文或"zh"表示中文。第二部分，跟在一个下划线之后，是一个可选的国家说明符，用于区分讲同一种语言的不同国家，例如"en_US"表示美国英语，而"en_UK"表示英国英语。最后一部分，跟在一个句点之后，是可选的字符集说明符，例如"zh_CN.gb2312"表示中国使用gb2312字符集。
+
+GO语言默认采用"UTF-8"编码集，所以我们实现i18n时不考虑第三部分，接下来我们都采用locale描述的前面两部分来作为i18n标准的locale名。
+
+
+>在Linux和Solaris系统中可以通过`locale -a`命令列举所有支持的地区名，读者可以看到这些地区名的命名规范。对于BSD等系统，没有locale命令，但是地区信息存储在/usr/share/locale中。
+
+## 设置Locale
+有了上面对locale的定义，那么我们就需要根据用户的信息(访问信息、个人信息、访问域名等)来设置与之相关的locale，我们可以通过如下几种方式来设置用户的locale。
+
+### 通过域名设置Locale
+设置Locale的办法这一就是在应用运行的时候采用域名分级的方式，例如，我们采用www.asta.com当做我们的英文站(默认站)，而把域名www.asta.cn当做中文站。这样通过在应用里面设置域名和相应的locale的对应关系，就可以设置好地区。这样处理有几点好处：
+
+- 通过URL就可以很明显的识别
+- 用户可以通过域名很直观的知道将访问那种语言的站点
+- 在Go程序中实现非常的简单方便，通过一个map就可以实现
+- 有利于搜索引擎抓取，能够提高站点的SEO
+
+我们可以通过下面的代码来实现域名的对应locale：
+
+	if r.Host == "www.asta.com" {
+		i18n.SetLocale("en")
+	} else if r.Host == "www.asta.cn" {
+		i18n.SetLocale("zh-CN")
+	} else if r.Host == "www.asta.tw" {
+		i18n.SetLocale("zh-TW")
+	}
+
+当然除了整域名设置地区之外，我们还可以通过子域名来设置地区，例如"en.asta.com"表示英文站点，"cn.asta.com"表示中文站点。实现代码如下所示：
+
+	prefix := strings.Split(r.Host,".")
+
+	if prefix[0] == "en" {
+		i18n.SetLocale("en")
+	} else if prefix[0] == "cn" {
+		i18n.SetLocale("zh-CN")
+	} else if prefix[0] == "tw" {
+		i18n.SetLocale("zh-TW")
+	}
+
+通过域名设置Locale有如上所示的优点，但是我们一般开发Web应用的时候不会采用这种方式，因为首先域名成本比较高，开发一个Locale就需要一个域名，而且往往统一名称的域名不一定能申请的到，其次我们不愿意为每个站点去本地化一个配置，而更多的是采用url后面带参数的方式，请看下面的介绍。
+
+### 从域名参数设置Locale
 目前最常用的设置Locale的方式是在URL里面带上参数，例如www.asta.com/hello?locale=zh或者www.asta.com/zh/hello。这样我们就可以设置地区：`i18n.SetLocale(params["locale"])`。
 
 这种设置方式几乎拥有前面讲的通过域名设置Locale的所有优点，它采用RESTful的方式，以使得我们不需要增加额外的方法来处理。但是这种方式需要在每一个的link里面增加相应的参数locale，这也许有点复杂而且有时候甚至相当的繁琐。不过我们可以写一个通用的函数url，让所有的link地址都通过这个函数来生成，然后在这个函数里面增加`locale=params["locale"]`参数来缓解一下。
 
 也许我们希望URL地址看上去更加的RESTful一点，例如：www.asta.com/en/books(英文站点)和www.asta.com/zh/books(中文站点)，这种方式的URL更加有利于SEO，而且对于用户也比较友好，能够通过URL直观的知道访问的站点。那么这样的URL地址可以通过router来获取locale(参考REST小节里面介绍的router插件实现)：
 
-	mux.Get("/:locale/books", listbook)
-
+	mux.Get("/:locale/books", listbook)
+
 ### 从客户端设置地区
-在一些特殊的情况下，我们需要根据客户端的信息而不是通过URL来设置Locale，这些信息可能来自于客户端设置的喜好语言(浏览器中设置)，用户的IP地址，用户在注册的时候填写的所在地信息等。这种方式比较适合Web为基础的应用。
-
+在一些特殊的情况下，我们需要根据客户端的信息而不是通过URL来设置Locale，这些信息可能来自于客户端设置的喜好语言(浏览器中设置)，用户的IP地址，用户在注册的时候填写的所在地信息等。这种方式比较适合Web为基础的应用。
+
 - Accept-Language
 
-	客户端请求的时候在HTTP头信息里面有`Accept-Language`，一般的客户端都会设置该信息，下面是Go语言实现的一个简单的根据`Accept-Language`实现设置地区的代码：
-	
-		AL := r.Header.Get("Accept-Language")
-		if AL == "en" {
-			i18n.SetLocale("en")
-		} else if AL == "zh-CN" {
-			i18n.SetLocale("zh-CN")
-		} else if AL == "zh-TW" {
-			i18n.SetLocale("zh-TW")
-		}
-	当然在实际应用中，可能需要更加严格的判断来进行设置地区
+客户端请求的时候在HTTP头信息里面有`Accept-Language`，一般的客户端都会设置该信息，下面是Go语言实现的一个简单的根据`Accept-Language`实现设置地区的代码：
+
+	AL := r.Header.Get("Accept-Language")
+	if AL == "en" {
+		i18n.SetLocale("en")
+	} else if AL == "zh-CN" {
+		i18n.SetLocale("zh-CN")
+	} else if AL == "zh-TW" {
+		i18n.SetLocale("zh-TW")
+	}
+
+当然在实际应用中，可能需要更加严格的判断来进行设置地区
 - IP地址
 
-	另一种根据客户端来设定地区就是用户访问的IP，我们根据相应的IP库，对应访问的IP到地区，目前全球比较常用的就是GeoIP Lite Country这个库。这种设置地区的机制非常简单，我们只需要根据IP数据库查询用户的IP然后返回国家地区，根据返回的结果设置对应的地区。
+	另一种根据客户端来设定地区就是用户访问的IP，我们根据相应的IP库，对应访问的IP到地区，目前全球比较常用的就是GeoIP Lite Country这个库。这种设置地区的机制非常简单，我们只需要根据IP数据库查询用户的IP然后返回国家地区，根据返回的结果设置对应的地区。
 
 - 用户profile
 
-	当然你也可以让用户根据你提供的下拉菜单或者别的什么方式的设置相应的locale，然后我们将用户输入的信息，保存到与它帐号相关的profile中，当用户再次登陆的时候把这个设置复写到locale设置中，这样就可以保证该用户每次访问都是基于自己先前设置的locale来获得页面。
+	当然你也可以让用户根据你提供的下拉菜单或者别的什么方式的设置相应的locale，然后我们将用户输入的信息，保存到与它帐号相关的profile中，当用户再次登陆的时候把这个设置复写到locale设置中，这样就可以保证该用户每次访问都是基于自己先前设置的locale来获得页面。
 
 ## 总结
 通过上面的介绍可知，设置Locale可以有很多种方式，我们应该根据需求的不同来选择不同的设置Locale的方法，以让用户能以它最熟悉的方式，获得我们提供的服务，提高应用的用户友好性。
-
-## links
-  * [目录](<preface.md>)
-  * 上一节: [国际化和本地化](<10.md>)
-  * 下一节: [本地化资源](<10.2.md>)
-
-## LastModified
-  * $Id$
+
+## links
+  * [目录](<preface.md>)
+  * 上一节: [国际化和本地化](<10.md>)
+  * 下一节: [本地化资源](<10.2.md>)

10.2.md

@@ -44,7 +44,7 @@
 	fmt.Printf(msg(lang, "how old"), 30)
 
 上面的示例代码仅用以演示内部的实现方案，而实际数据是存储在JSON里面的，所以我们可以通过`json.Unmarshal`来为相应的map填充数据。
-	
+
 ## 本地化日期和时间
 因为时区的关系，同一时刻，在不同的地区，表示是不一样的，而且因为Locale的关系，时间格式也不尽相同，例如中文环境下可能显示：`2012年10月24日 星期三 23时11分13秒 CST`，而在英文环境下可能显示:`Wed Oct 24 23:11:13 CST 2012`。这里面我们需要解决两点:
 
@@ -55,7 +55,7 @@ $GOROOT/lib/time包中的timeinfo.zip含有locale对应的时区的定义，为
 
 	en["time_zone"]="America/Chicago"
 	cn["time_zone"]="Asia/Shanghai"
-	
+
 	loc,_:=time.LoadLocation(msg(lang,"time_zone"))
 	t:=time.Now()
 	t = t.In(loc)
@@ -65,9 +65,9 @@ $GOROOT/lib/time包中的timeinfo.zip含有locale对应的时区的定义，为
 
 	en["date_format"]="%Y-%m-%d %H:%M:%S"
 	cn["date_format"]="%Y年%m月%d日 %H时%M分%S秒"
-	
+
 	fmt.Println(date(msg(lang,"date_format"),t))
-	
+
 	func date(fomate string,t time.Time) string{
 		year, month, day = t.Date()
 		hour, min, sec = t.Clock()
@@ -84,54 +84,51 @@ $GOROOT/lib/time包中的timeinfo.zip含有locale对应的时区的定义，为
 	cn["money"] ="￥%d元"
 
 	fmt.Println(date(msg(lang,"date_format"),100))
-	
+
 	func money_format(fomate string,money int64) string{
 		return fmt.Sprintf(fomate,money)
 	}
-	
+
 
 ## 本地化视图和资源
 我们可能会根据Locale的不同来展示视图，这些视图包含不同的图片、css、js等各种静态资源。那么应如何来处理这些信息呢？首先我们应按locale来组织文件信息，请看下面的文件目录安排：
 
 	views
-	 |--en  //英文模板
-	     |--images     //存储图片信息
-	     |--js         //存储JS文件
-	     |--css        //存储css文件
-	     index.tpl     //用户首页
-	     login.tpl     //登陆首页
-	 |--zh-CN //中文模板
-	     |--images
-	     |--js
-	     |--css
-	     index.tpl
-	     login.tpl
-	
+	|--en  //英文模板
+		|--images     //存储图片信息
+		|--js         //存储JS文件
+		|--css        //存储css文件
+		index.tpl     //用户首页
+		login.tpl     //登陆首页
+	|--zh-CN //中文模板
+		|--images
+		|--js
+		|--css
+		index.tpl
+		login.tpl
+
 有了这个目录结构后我们就可以在渲染的地方这样来实现代码：
 
-	
+
 	s1, _ := template.ParseFiles("views"+lang+"index.tpl")
 	VV.Lang=lang
-	s1.Execute(os.Stdout, VV)	 
-	
+	s1.Execute(os.Stdout, VV)
+
 而对于里面的index.tpl里面的资源设置如下：
 
-	//js文件
-	<script type="text/javascript" src="views/{{.VV.Lang}}/js/jquery/jquery-1.8.0.min.js"></script>	   
-	//css文件
-	<link href="views/{{.VV.Lang}}/css/bootstrap-responsive.min.css" rel="stylesheet"> 
-	//图片文件
-	<img src="views/{{.VV.Lang}}/images/btn.png">
-	
-采用这种方式来本地化视图以及资源时，我们就可以很容易的进行扩展了。	
-	     
+// js文件
+<script type="text/javascript" src="views/{{.VV.Lang}}/js/jquery/jquery-1.8.0.min.js"></script>
+// css文件
+<link href="views/{{.VV.Lang}}/css/bootstrap-responsive.min.css" rel="stylesheet">
+// 图片文件
+<img src="views/{{.VV.Lang}}/images/btn.png">
+
+采用这种方式来本地化视图以及资源时，我们就可以很容易的进行扩展了。
+
 ## 总结
 本小节介绍了如何使用及存储本地资源，有时需要通过转换函数来实现，有时通过lang来设置，但是最终都是通过key-value的方式来存储Locale对应的数据，在需要时取出相应于Locale的信息后，如果是文本信息就直接输出，如果是时间日期或者货币，则需要先通过`fmt.Printf`或其他格式化函数来处理，而对于不同Locale的视图和资源则是最简单的，只要在路径里面增加lang就可以实现了。
-
-## links
-  * [目录](<preface.md>)
-  * 上一节: [设置默认地区](<10.1.md>)
-  * 下一节: [国际化站点](<10.3.md>)
-
-## LastModified
-  * $Id$
+
+## links
+  * [目录](<preface.md>)
+  * 上一节: [设置默认地区](<10.1.md>)
+  * 下一节: [国际化站点](<10.3.md>)

10.3.md

@@ -2,30 +2,30 @@
 前面小节介绍了如何处理本地化资源，即Locale一个相应的配置文件，那么如果处理多个的本地化资源呢？而对于一些我们经常用到的例如：简单的文本翻译、时间日期、数字等如果处理呢？本小节将一一解决这些问题。
 ## 管理多个本地包
 在开发一个应用的时候，首先我们要决定是只支持一种语言，还是多种语言，如果要支持多种语言，我们则需要制定一个组织结构，以方便将来更多语言的添加。在此我们设计如下：Locale有关的文件放置在config/locales下，假设你要支持中文和英文，那么你需要在这个文件夹下放置en.json和zh.json。大概的内容如下所示：
-	
+
 	# zh.json
 
 	{
-    "zh": {
-        "submit": "提交",
-        "create": "创建"
-    	}
+	"zh": {
+		"submit": "提交",
+		"create": "创建"
+		}
 	}
 
 	#en.json
 
 	{
-    "en": {
-        "submit": "Submit",
-        "create": "Create"
-    	}
+	"en": {
+		"submit": "Submit",
+		"create": "Create"
+		}
 	}
 
 为了支持国际化，在此我们使用了一个国际化相关的包——go-i18n(https://github.com/astaxie/go-i18n)，首先我们向go-i18n包注册config/locales这个目录,以加载所有的locale文件
 
-	Tr:=i18n.NewLocale()	
+	Tr:=i18n.NewLocale()
 	Tr.LoadPath("config/locales")
-	
+
 这个包使用起来很简单，你可以通过下面的方式进行测试：
 
 	fmt.Println(Tr.Translate("submit"))
@@ -41,27 +41,27 @@
 	//加载默认配置文件，这些文件都放在go-i18n/locales下面
 
 	//文件命名zh.json、en-json、en-US.json等，可以不断的扩展支持更多的语言
-	
+
 	func (il *IL) loadDefaultTranslations(dirPath string) error {
 		dir, err := os.Open(dirPath)
 		if err != nil {
 			return err
 		}
 		defer dir.Close()
-	
+
 		names, err := dir.Readdirnames(-1)
 		if err != nil {
 			return err
 		}
-	
+
 		for _, name := range names {
 			fullPath := path.Join(dirPath, name)
-	
+
 			fi, err := os.Stat(fullPath)
 			if err != nil {
 				return err
 			}
-	
+
 			if fi.IsDir() {
 				if err := il.loadTranslations(fullPath); err != nil {
 					return err
@@ -72,13 +72,13 @@
 					return err
 				}
 				defer file.Close()
-	
+
 				if err := il.loadTranslation(file, locale); err != nil {
 					return err
 				}
 			}
 		}
-	
+
 		return nil
 	}
 
@@ -100,83 +100,81 @@
 
 1. 文本信息
 
-	文本信息调用`Tr.Translate`来实现相应的信息转换，mapFunc的实现如下：
+文本信息调用`Tr.Translate`来实现相应的信息转换，mapFunc的实现如下：
 
-		func I18nT(args ...interface{}) string {
-			ok := false
-			var s string
-			if len(args) == 1 {
-				s, ok = args[0].(string)
-			}
-			if !ok {
-				s = fmt.Sprint(args...)
-			}
-			return Tr.Translate(s)
+	func I18nT(args ...interface{}) string {
+		ok := false
+		var s string
+		if len(args) == 1 {
+			s, ok = args[0].(string)
 		}
+		if !ok {
+			s = fmt.Sprint(args...)
+		}
+		return Tr.Translate(s)
+	}
 
-	注册函数如下：
+注册函数如下：
 
-		t.Funcs(template.FuncMap{"T": I18nT})
+	t.Funcs(template.FuncMap{"T": I18nT})
 
-	模板中使用如下：
+模板中使用如下：
+
+	{{.V.Submit | T}}
 
-		{{.V.Submit | T}}
 
-	
 2. 时间日期
 
-	时间日期调用`Tr.Time`函数来实现相应的时间转换，mapFunc的实现如下：
+时间日期调用`Tr.Time`函数来实现相应的时间转换，mapFunc的实现如下：
 
-		func I18nTimeDate(args ...interface{}) string {
-			ok := false
-			var s string
-			if len(args) == 1 {
-				s, ok = args[0].(string)
-			}
-			if !ok {
-				s = fmt.Sprint(args...)
-			}
-			return Tr.Time(s)
+	func I18nTimeDate(args ...interface{}) string {
+		ok := false
+		var s string
+		if len(args) == 1 {
+			s, ok = args[0].(string)
+		}
+		if !ok {
+			s = fmt.Sprint(args...)
 		}
+		return Tr.Time(s)
+	}
 
-	注册函数如下：
+注册函数如下：
 
-		t.Funcs(template.FuncMap{"TD": I18nTimeDate})
+	t.Funcs(template.FuncMap{"TD": I18nTimeDate})
 
-	模板中使用如下：
+模板中使用如下：
+
+	{{.V.Now | TD}}
 
-		{{.V.Now | TD}}	
 3. 货币信息
 
-	货币调用`Tr.Money`函数来实现相应的时间转换，mapFunc的实现如下：
+货币调用`Tr.Money`函数来实现相应的时间转换，mapFunc的实现如下：
 
-		func I18nMoney(args ...interface{}) string {
-			ok := false
-			var s string
-			if len(args) == 1 {
-				s, ok = args[0].(string)
-			}
-			if !ok {
-				s = fmt.Sprint(args...)
-			}
-			return Tr.Money(s)
+	func I18nMoney(args ...interface{}) string {
+		ok := false
+		var s string
+		if len(args) == 1 {
+			s, ok = args[0].(string)
 		}
+		if !ok {
+			s = fmt.Sprint(args...)
+		}
+		return Tr.Money(s)
+	}
+
+注册函数如下：
 
-	注册函数如下：
+	t.Funcs(template.FuncMap{"M": I18nMoney})
 
-		t.Funcs(template.FuncMap{"M": I18nMoney})
+模板中使用如下：
 
-	模板中使用如下：
+	{{.V.Money | M}}
 
-		{{.V.Money | M}}
+## 总结
+通过这小节我们知道了如何实现一个多语言包的Web应用，通过自定义语言包我们可以方便的实现多语言，而且通过配置文件能够非常方便的扩充多语言，默认情况下，go-i18n会自定加载一些公共的配置信息，例如时间、货币等，我们就可以非常方便的使用，同时为了支持在模板中使用这些函数，也实现了相应的模板函数，这样就允许我们在开发Web应用的时候直接在模板中通过pipeline的方式来操作多语言包。
 
-## 总结
-通过这小节我们知道了如何实现一个多语言包的Web应用，通过自定义语言包我们可以方便的实现多语言，而且通过配置文件能够非常方便的扩充多语言，默认情况下，go-i18n会自定加载一些公共的配置信息，例如时间、货币等，我们就可以非常方便的使用，同时为了支持在模板中使用这些函数，也实现了相应的模板函数，这样就允许我们在开发Web应用的时候直接在模板中通过pipeline的方式来操作多语言包。
-
-## links
-  * [目录](<preface.md>)
-  * 上一节: [本地化资源](<10.2.md>)
-  * 下一节: [小结](<10.4.md>)
-
-## LastModified
-  * $Id$
+## links
+  * [目录](<preface.md>)
+  * 上一节: [本地化资源](<10.2.md>)
+  * 下一节: [小结](<10.4.md>)

10.4.md

 # 10.4 小结
-通过这一章的介绍，读者应该对如何操作i18n有了深入的了解，我也根据这一章介绍的内容实现了一个开源的解决方案go-i18n：https://github.com/astaxie/go-i18n  通过这个开源库我们可以很方便的实现多语言版本的Web应用，使得我们的应用能够轻松的实现国际化。如果你发现这个开源库中的错误或者那些缺失的地方，请一起参与到这个开源项目中来，让我们的这个库争取成为Go的标准库。
-## links
-  * [目录](<preface.md>)
-  * 上一节: [国际化站点](<10.3.md>)
-  * 下一节: [错误处理，故障排除和测试](<11.md>)
-
-## LastModified
-  * $Id$
+通过这一章的介绍，读者应该对如何操作i18n有了深入的了解，我也根据这一章介绍的内容实现了一个开源的解决方案go-i18n：https://github.com/astaxie/go-i18n  通过这个开源库我们可以很方便的实现多语言版本的Web应用，使得我们的应用能够轻松的实现国际化。如果你发现这个开源库中的错误或者那些缺失的地方，请一起参与到这个开源项目中来，让我们的这个库争取成为Go的标准库。
+## links
+  * [目录](<preface.md>)
+  * 上一节: [国际化站点](<10.3.md>)
+  * 下一节: [错误处理，故障排除和测试](<11.md>)

10.md

-# 10 国际化和本地化
-为了适应经济的全球一体化，作为开发者，我们需要开发出支持多国语言、国际化的Web应用，即同样的页面在不同的语言环境下需要显示不同的效果，也就是说应用程序在运行时能够根据请求所来自的地域与语言的不同而显示不同的用户界面。这样，当需要在应用程序中添加对新的语言的支持时，无需修改应用程序的代码，只需要增加语言包即可实现。
-
-国际化与本地化（Internationalization and localization,通常用i18n和L10N表示），国际化是将针对某个地区设计的程序进行重构，以使它能够在更多地区使用，本地化是指在一个面向国际化的程序中增加对新地区的支持。
-
-目前，Go语言的标准包没有提供对i18n的支持，但有一些比较简单的第三方实现，这一章我们将实现一个go-i18n库，用来支持Go语言的i18n。
-
-所谓的国际化：就是根据特定的locale信息，提取与之相应的字符串或其它一些东西（比如时间和货币的格式）等等。这涉及到三个问题：
- 
-1、如何确定locale。
- 
-2、如何保存与locale相关的字符串或其它信息。
- 
-3、如何根据locale提取字符串和其它相应的信息。
-
-在第一小节里，我们将介绍如何设置正确的locale以便让访问站点的用户能够获得与其语言相应的页面。第二小节将介绍如何处理或存储字符串、货币、时间日期等与locale相关的信息，第三小节将介绍如何实现国际化站点，即如何根据不同locale返回不同合适的内容。通过这三个小节的学习，我们将获得一个完整的i18n方案。
-
-## 目录
-  * 1 [设置默认地区](10.1.md)
-  * 2 [本地化资源](10.2.md)
-  * 3 [国际化站点](10.3.md)
-  * 4 [小结](10.4.md)
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [第九章总结](<9.7.md>)
-   * 下一节: [设置默认地区](<10.1.md>)
-
-## LastModified 
-   * $Id$
+# 10 国际化和本地化
+为了适应经济的全球一体化，作为开发者，我们需要开发出支持多国语言、国际化的Web应用，即同样的页面在不同的语言环境下需要显示不同的效果，也就是说应用程序在运行时能够根据请求所来自的地域与语言的不同而显示不同的用户界面。这样，当需要在应用程序中添加对新的语言的支持时，无需修改应用程序的代码，只需要增加语言包即可实现。
+
+国际化与本地化（Internationalization and localization,通常用i18n和L10N表示），国际化是将针对某个地区设计的程序进行重构，以使它能够在更多地区使用，本地化是指在一个面向国际化的程序中增加对新地区的支持。
+
+目前，Go语言的标准包没有提供对i18n的支持，但有一些比较简单的第三方实现，这一章我们将实现一个go-i18n库，用来支持Go语言的i18n。
+
+所谓的国际化：就是根据特定的locale信息，提取与之相应的字符串或其它一些东西（比如时间和货币的格式）等等。这涉及到三个问题：
+
+1、如何确定locale。
+
+2、如何保存与locale相关的字符串或其它信息。
+
+3、如何根据locale提取字符串和其它相应的信息。
+
+在第一小节里，我们将介绍如何设置正确的locale以便让访问站点的用户能够获得与其语言相应的页面。第二小节将介绍如何处理或存储字符串、货币、时间日期等与locale相关的信息，第三小节将介绍如何实现国际化站点，即如何根据不同locale返回不同合适的内容。通过这三个小节的学习，我们将获得一个完整的i18n方案。
+
+## 目录
+  * 1 [设置默认地区](10.1.md)
+  * 2 [本地化资源](10.2.md)
+  * 3 [国际化站点](10.3.md)
+  * 4 [小结](10.4.md)
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第九章总结](<9.7.md>)
+   * 下一节: [设置默认地区](<10.1.md>)

11.1.md

@@ -6,9 +6,9 @@ Go语言设计的时候主要的特点是：简洁、明白，简洁是指语法
 下面这个例子通过`os.Open`打开一个文件，如果出错那么会执行`log.Fatal`打印出来错误信息：
 
 	f, err := os.Open("filename.ext")
-    if err != nil {
-        log.Fatal(err)
-    }
+	if err != nil {
+		log.Fatal(err)
+	}
 
 其实这样的error返回在Go语言的很多内置包里面有很多，我们这个小节将详细的介绍这些error是怎么设计的，以及在我们设计的Web应用如何更好的处理error。
 ## Error类型
@@ -35,14 +35,14 @@ error是一个内置的类型变量，我们可以在/builtin/包下面找到相
 		return &errorString{text}
 	}
 
-下面这个例子演示了如何使用`errors.New`:	
+下面这个例子演示了如何使用`errors.New`:
 
 	func Sqrt(f float64) (float64, error) {
 	if f < 0 {
 		return 0, errors.New("math: square root of negative number")
 	}
 	// implementation
-	}	
+	}
 
 ## 自定义Error
 
@@ -53,4 +53,4 @@ error是一个内置的类型变量，我们可以在/builtin/包下面找到相
 ## links
    * [目录](<preface.md>)
    * 上一节: [错误处理，调试和测试](<11.md>)
-   * 下一节: [使用GDB调试](<11.2.md>)
\ No newline at end of file
+   * 下一节: [使用GDB调试](<11.2.md>)

11.md

@@ -9,13 +9,13 @@
 
 长期以来，培养良好的调试、测试习惯一直是很多程序员逃避的事情，所以现在你不要再逃避了，就从你现在的项目开发，从学习Go Web开发开始养成良好的习惯。
 
-## 目录
-  * 1 [错误处理](11.1.md)
-  * 2 [使用GDB调试](11.2.md)
-  * 3 [Go怎么写测试用例](11.3.md)
-  * 4 [小结](11.4.md)
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [第十章总结](<10.4.md>)
+## 目录
+  * 1 [错误处理](11.1.md)
+  * 2 [使用GDB调试](11.2.md)
+  * 3 [Go怎么写测试用例](11.3.md)
+  * 4 [小结](11.4.md)
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第十章总结](<10.4.md>)
    * 下一节: [错误处理](<11.1.md>)
\ No newline at end of file

2.1.md

-# 2.1 你好，Go
-
-在开始编写应用之前，我们先从最基本的程序开始。就像你造房子之前不知道什么是地基一样，编写程序也不知道如何开始。因此，在本节中，我们要学习用最基本的语法让Go程序运行起来。
-
-## 程序
-
-这就像一个传统，在学习大部分语言之前，你先学会如何编写一个可以输出`hello world`的程序。
-
-准备好了吗？Let's Go!
-
-	package main
-
-	import "fmt"
-
-	func main() {
-		fmt.Printf("Hello, world or καλημ ́ρα κóσμ or こんにちは世界\n")
-	}
-
-输出如下：
-
-	Hello, world or καλημ ́ρα κóσμ or こんにちは世界
-
-## 详解
-首先我们要了解一个概念，Go程序是通过`package`来组织的
-
-`package <pkgName>`（在我们的例子中是`package main`）这一行告诉我们当前文件属于哪个包，而包名`main`则告诉我们它是一个可独立运行的包，它在编译后会产生可执行文件。除了`main`包之外，其它的包最后都会生成`*.a`文件（也就是包文件）并放置在`$GOPATH/pkg/$GOOS_$GOARCH`中（以Mac为例就是`$GOPATH/pkg/darwin_amd64`）。
-
->每一个可独立运行的Go程序，必定包含一个`package main`，在这个`main`包中必定包含一个入口函数`main`，而这个函数既没有参数，也没有返回值。
-
-为了打印`Hello, world...`，我们调用了一个函数`Printf`，这个函数来自于`fmt`包，所以我们在第三行中导入了系统级别的`fmt`包：`import "fmt"`。
-
-包的概念和Python中的module相同，它们都有一些特别的好处：模块化（能够把你的程序分成多个模块)和可重用性（每个模块都能被其它应用程序反复使用）。我们在这里只是先了解一下包的概念，后面我们将会编写自己的包。
-
-在第五行中，我们通过关键字`func`定义了一个`main`函数，函数体被放在`{}`（大括号）中，就像我们平时写C、C++或Java时一样。
-
-大家可以看到`main`函数是没有任何的参数的，我们接下来就学习如何编写带参数的、返回0个或多个值的函数。
-
-第六行，我们调用了`fmt`包里面定义的函数`Printf`。大家可以看到，这个函数是通过`<pkgName>.<funcName>`的方式调用的，这一点和Python十分相似。
-
->前面提到过，包名和包所在的文件夹名可以是不同的，此处的`<pkgName>`即为通过`package <pkgName>`声明的包名，而非文件夹名。
-
-最后大家可以看到我们输出的内容里面包含了很多非ASCII码字符。实际上，Go是天生支持UTF-8的，任何字符都可以直接输出，你甚至可以用UTF-8中的任何字符作为标识符。
-
-
-## 结论
-
-Go使用`package`（和Python的模块类似）来组织代码。`main.main()`函数(这个函数主要位于主包）是每一个独立的可运行程序的入口点。Go使用UTF-8字符串和标识符(因为UTF-8的发明者也就是Go的发明者)，所以它天生就具有多语言的支持。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [Go语言基础](<2.md>)
-   * 下一节: [Go基础](<2.2.md>)
-
-## LastModified
-   * $Id$
+# 2.1 你好，Go
+
+在开始编写应用之前，我们先从最基本的程序开始。就像你造房子之前不知道什么是地基一样，编写程序也不知道如何开始。因此，在本节中，我们要学习用最基本的语法让Go程序运行起来。
+
+## 程序
+
+这就像一个传统，在学习大部分语言之前，你先学会如何编写一个可以输出`hello world`的程序。
+
+准备好了吗？Let's Go!
+
+	package main
+
+	import "fmt"
+
+	func main() {
+		fmt.Printf("Hello, world or καλημ ́ρα κóσμ or こんにちは世界\n")
+	}
+
+输出如下：
+
+	Hello, world or καλημ ́ρα κóσμ or こんにちは世界
+
+## 详解
+首先我们要了解一个概念，Go程序是通过`package`来组织的
+
+`package <pkgName>`（在我们的例子中是`package main`）这一行告诉我们当前文件属于哪个包，而包名`main`则告诉我们它是一个可独立运行的包，它在编译后会产生可执行文件。除了`main`包之外，其它的包最后都会生成`*.a`文件（也就是包文件）并放置在`$GOPATH/pkg/$GOOS_$GOARCH`中（以Mac为例就是`$GOPATH/pkg/darwin_amd64`）。
+
+>每一个可独立运行的Go程序，必定包含一个`package main`，在这个`main`包中必定包含一个入口函数`main`，而这个函数既没有参数，也没有返回值。
+
+为了打印`Hello, world...`，我们调用了一个函数`Printf`，这个函数来自于`fmt`包，所以我们在第三行中导入了系统级别的`fmt`包：`import "fmt"`。
+
+包的概念和Python中的module相同，它们都有一些特别的好处：模块化（能够把你的程序分成多个模块)和可重用性（每个模块都能被其它应用程序反复使用）。我们在这里只是先了解一下包的概念，后面我们将会编写自己的包。
+
+在第五行中，我们通过关键字`func`定义了一个`main`函数，函数体被放在`{}`（大括号）中，就像我们平时写C、C++或Java时一样。
+
+大家可以看到`main`函数是没有任何的参数的，我们接下来就学习如何编写带参数的、返回0个或多个值的函数。
+
+第六行，我们调用了`fmt`包里面定义的函数`Printf`。大家可以看到，这个函数是通过`<pkgName>.<funcName>`的方式调用的，这一点和Python十分相似。
+
+>前面提到过，包名和包所在的文件夹名可以是不同的，此处的`<pkgName>`即为通过`package <pkgName>`声明的包名，而非文件夹名。
+
+最后大家可以看到我们输出的内容里面包含了很多非ASCII码字符。实际上，Go是天生支持UTF-8的，任何字符都可以直接输出，你甚至可以用UTF-8中的任何字符作为标识符。
+
+
+## 结论
+
+Go使用`package`（和Python的模块类似）来组织代码。`main.main()`函数(这个函数主要位于主包）是每一个独立的可运行程序的入口点。Go使用UTF-8字符串和标识符(因为UTF-8的发明者也就是Go的发明者)，所以它天生就具有多语言的支持。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [Go语言基础](<2.md>)
+   * 下一节: [Go基础](<2.2.md>)

2.4.md

-# 2.4 struct类型
-## struct
-Go语言中，也和C或者其他语言一样，我们可以声明新的类型，作为其它类型的属性或字段的容器。例如，我们可以创建一个自定义类型`person`代表一个人的实体。这个实体拥有属性：姓名和年龄。这样的类型我们称之`struct`。如下代码所示:
-
-	type person struct {
-		name string
-		age int
-	}
-看到了吗？声明一个struct如此简单，上面的类型包含有两个字段
-- 一个string类型的字段name，用来保存用户名称这个属性
-- 一个int类型的字段age,用来保存用户年龄这个属性
-
-如何使用struct呢？请看下面的代码
-
-	type person struct {
-		name string
-		age int
-	}
-
-	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属性.
-除了上面这种P的声明使用之外，还有两种声明使用方式
-
-- 1.按照顺序提供初始化值
-
-		P := person{"Tom", 25}
-
-- 2.通过`field:value`的方式初始化，这样可以任意顺序
-
-		P := person{age:24, name:"Tom"}
-
-下面我们看一个完整的使用struct的例子
-
-	package main
-	import "fmt"
-
-	// 声明一个新的类型
-	type person struct {
-		name string
-		age int
-	}
-
-	// 比较两个人的年龄，返回年龄大的那个人，并且返回年龄差
-	// struct也是传值的
-	func Older(p1, p2 person) (person, int) {
-		if p1.age>p2.age {  // 比较p1和p2这两个人的年龄
-			return p1, p1.age-p2.age
-		}
-		return p2, p2.age-p1.age
-	}
-
-	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)
-	}
-
-### struct的匿名字段
-我们上面介绍了如何定义一个struct，定义的时候是字段名与其类型一一对应，实际上Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段。
-
-当匿名字段是一个struct的时候，那么这个struct所拥有的全部字段都被隐式地引入了当前定义的这个struct。
-
-让我们来看一个例子，让上面说的这些更具体化
-
-	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)
-		fmt.Println("His weight is ", mark.weight)
-		fmt.Println("His speciality is ", mark.speciality)
-		// 修改对应的备注信息
-		mark.speciality = "AI"
-		fmt.Println("Mark changed his speciality")
-		fmt.Println("His speciality is ", mark.speciality)
-		// 修改他的年龄信息
-		fmt.Println("Mark become old")
-		mark.age = 46
-		fmt.Println("His age is", mark.age)
-		// 修改他的体重信息
-		fmt.Println("Mark is not an athlet anymore")
-		mark.weight += 60
-		fmt.Println("His weight is", mark.weight)
-	}
-
-图例如下:
-
-![](images/2.4.student_struct.png?raw=true)
-
-我们看到Student访问属性age和name的时候，就像访问自己所有用的字段一样，对，匿名字段就是这样，能够实现字段的继承。是不是很酷啊？还有比这个更酷的呢，那就是student还能访问Human这个字段作为字段名。请看下面的代码，是不是更酷了。
-
-	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"}
-		// 现在我们来访问相应的字段
-		fmt.Println("Her name is ", jane.name)
-		fmt.Println("Her age is ", jane.age)
-		fmt.Println("Her weight is ", jane.weight)
-		fmt.Println("Her speciality is ", jane.speciality)
-		// 我们来修改他的skill技能字段
-		jane.Skills = []string{"anatomy"}
-		fmt.Println("Her skills are ", jane.Skills)
-		fmt.Println("She acquired two new ones ")
-		jane.Skills = append(jane.Skills, "physics", "golang")
-		fmt.Println("Her skills now are ", jane.Skills)
-		// 修改匿名内置类型字段
-		jane.int = 3
-		fmt.Println("Her preferred number is", jane.int)
-	}
-
-从上面例子我们看出来struct不仅仅能够将struct作为匿名字段、自定义类型、内置类型都可以作为匿名字段，而且可以在相应的字段上面进行函数操作（如例子中的append）。
-
-这里有一个问题：如果human里面有一个字段叫做phone，而student也有一个字段叫做phone，那么该怎么办呢？
-
-Go里面很简单的解决了这个问题，最外层的优先访问，也就是当你通过`student.phone`访问的时候，是访问student里面的字段，而不是human里面的字段。
-
-这样就允许我们去重载通过匿名字段继承的一些字段，当然如果我们想访问重载后对应匿名类型里面的字段，可以通过匿名字段名来访问。请看下面的例子
-
-	package main
-	import "fmt"
-
-	type Human struct {
-		name string
-		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)
-		// 如果我们要访问Human的phone字段
-		fmt.Println("Bob's personal phone is:", Bob.Human.phone)
-	}
-
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [流程和函数](<2.3.md>)
-   * 下一节: [面向对象](<2.5.md>)
-
-## LastModified
-   * $Id$
+# 2.4 struct类型
+## struct
+Go语言中，也和C或者其他语言一样，我们可以声明新的类型，作为其它类型的属性或字段的容器。例如，我们可以创建一个自定义类型`person`代表一个人的实体。这个实体拥有属性：姓名和年龄。这样的类型我们称之`struct`。如下代码所示:
+
+	type person struct {
+		name string
+		age int
+	}
+看到了吗？声明一个struct如此简单，上面的类型包含有两个字段
+- 一个string类型的字段name，用来保存用户名称这个属性
+- 一个int类型的字段age,用来保存用户年龄这个属性
+
+如何使用struct呢？请看下面的代码
+
+	type person struct {
+		name string
+		age int
+	}
+
+	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属性.
+除了上面这种P的声明使用之外，还有两种声明使用方式
+
+- 1.按照顺序提供初始化值
+
+		P := person{"Tom", 25}
+
+- 2.通过`field:value`的方式初始化，这样可以任意顺序
+
+	P := person{age:24, name:"Tom"}
+
+下面我们看一个完整的使用struct的例子
+
+	package main
+	import "fmt"
+
+	// 声明一个新的类型
+	type person struct {
+		name string
+		age int
+	}
+
+	// 比较两个人的年龄，返回年龄大的那个人，并且返回年龄差
+	// struct也是传值的
+	func Older(p1, p2 person) (person, int) {
+		if p1.age>p2.age {  // 比较p1和p2这两个人的年龄
+			return p1, p1.age-p2.age
+		}
+		return p2, p2.age-p1.age
+	}
+
+	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)
+	}
+
+### struct的匿名字段
+我们上面介绍了如何定义一个struct，定义的时候是字段名与其类型一一对应，实际上Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段。
+
+当匿名字段是一个struct的时候，那么这个struct所拥有的全部字段都被隐式地引入了当前定义的这个struct。
+
+让我们来看一个例子，让上面说的这些更具体化
+
+	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)
+		fmt.Println("His weight is ", mark.weight)
+		fmt.Println("His speciality is ", mark.speciality)
+		// 修改对应的备注信息
+		mark.speciality = "AI"
+		fmt.Println("Mark changed his speciality")
+		fmt.Println("His speciality is ", mark.speciality)
+		// 修改他的年龄信息
+		fmt.Println("Mark become old")
+		mark.age = 46
+		fmt.Println("His age is", mark.age)
+		// 修改他的体重信息
+		fmt.Println("Mark is not an athlet anymore")
+		mark.weight += 60
+		fmt.Println("His weight is", mark.weight)
+	}
+
+图例如下:
+
+![](images/2.4.student_struct.png?raw=true)
+
+我们看到Student访问属性age和name的时候，就像访问自己所有用的字段一样，对，匿名字段就是这样，能够实现字段的继承。是不是很酷啊？还有比这个更酷的呢，那就是student还能访问Human这个字段作为字段名。请看下面的代码，是不是更酷了。
+
+	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"}
+		// 现在我们来访问相应的字段
+		fmt.Println("Her name is ", jane.name)
+		fmt.Println("Her age is ", jane.age)
+		fmt.Println("Her weight is ", jane.weight)
+		fmt.Println("Her speciality is ", jane.speciality)
+		// 我们来修改他的skill技能字段
+		jane.Skills = []string{"anatomy"}
+		fmt.Println("Her skills are ", jane.Skills)
+		fmt.Println("She acquired two new ones ")
+		jane.Skills = append(jane.Skills, "physics", "golang")
+		fmt.Println("Her skills now are ", jane.Skills)
+		// 修改匿名内置类型字段
+		jane.int = 3
+		fmt.Println("Her preferred number is", jane.int)
+	}
+
+从上面例子我们看出来struct不仅仅能够将struct作为匿名字段、自定义类型、内置类型都可以作为匿名字段，而且可以在相应的字段上面进行函数操作（如例子中的append）。
+
+这里有一个问题：如果human里面有一个字段叫做phone，而student也有一个字段叫做phone，那么该怎么办呢？
+
+Go里面很简单的解决了这个问题，最外层的优先访问，也就是当你通过`student.phone`访问的时候，是访问student里面的字段，而不是human里面的字段。
+
+这样就允许我们去重载通过匿名字段继承的一些字段，当然如果我们想访问重载后对应匿名类型里面的字段，可以通过匿名字段名来访问。请看下面的例子
+
+	package main
+	import "fmt"
+
+	type Human struct {
+		name string
+		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)
+		// 如果我们要访问Human的phone字段
+		fmt.Println("Bob's personal phone is:", Bob.Human.phone)
+	}
+
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [流程和函数](<2.3.md>)
+   * 下一节: [面向对象](<2.5.md>)

2.5.md

@@ -34,7 +34,7 @@
 
 基于上面的原因所以就有了`method`的概念，`method`是附属在一个给定的类型上的，他的语法和函数的声明语法几乎一样，只是在`func`后面增加了一个receiver(也就是method所依从的主体)。
 
-用上面提到的形状的例子来说，method `area()` 是依赖于某个形状(比如说Rectangle)来发生作用的。Rectangle.area()的发出者是Rectangle， area()是属于Rectangle的方法，而非一个外围函数。   
+用上面提到的形状的例子来说，method `area()` 是依赖于某个形状(比如说Rectangle)来发生作用的。Rectangle.area()的发出者是Rectangle， area()是属于Rectangle的方法，而非一个外围函数。
 
 更具体地说，Rectangle存在字段length 和 width, 同时存在方法area(), 这些字段和方法都属于Rectangle。
 
@@ -311,7 +311,7 @@ method的语法如下：
 		mark.SayHi()
 		sam.SayHi()
 	}
-	
+
 上面的代码设计的是如此的美妙，让人不自觉的为Go的设计惊叹！
 
 通过这些内容，我们可以设计出基本的面向对象的程序了，但是Go里面的面向对象是如此的简单，没有任何的私有、共有关键字，通过大小写来实现(大写开头的为共有，小写开头的为私有)，方法也同样适用这个原则。
@@ -319,6 +319,3 @@ method的语法如下：
    * [目录](<preface.md>)
    * 上一章: [struct类型](<2.4.md>)
    * 下一节: [interface](<2.6.md>)
-
-## LastModified
-   * $Id$

2.6.md

@@ -16,73 +16,73 @@ Go语言里面设计最精妙的应该算interface，它让面向对象，内容
 interface类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。详细的语法参考下面这个例子
 
 	type Human struct {
-    	name string
-    	age int
-    	phone string
+		name string
+		age int
+		phone string
 	}
-	
+
 	type Student struct {
-	    Human //匿名字段Human
-	    school string
-	    loan float32
+		Human //匿名字段Human
+		school string
+		loan float32
 	}
-	
+
 	type Employee struct {
-	    Human //匿名字段Human
-	    company string
-	    money float32
+		Human //匿名字段Human
+		company string
+		money float32
 	}
-	
+
 	//Human对象实现Sayhi方法
 	func (h *Human) SayHi() {
-	    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
+		fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
 	}
-	
+
 	// Human对象实现Sing方法
 	func (h *Human) Sing(lyrics string) {
-	    fmt.Println("La la, la la la, la la la la la...", lyrics)
+		fmt.Println("La la, la la la, la la la la la...", lyrics)
 	}
-	
+
 	//Human对象实现Guzzle方法
 	func (h *Human) Guzzle(beerStein string) {
-	    fmt.Println("Guzzle Guzzle Guzzle...", beerStein)
+		fmt.Println("Guzzle Guzzle Guzzle...", beerStein)
 	}
-	
+
 	// Employee重载Human的Sayhi方法
 	func (e *Employee) SayHi() {
-	    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
-	        e.company, e.phone) //Yes you can split into 2 lines here.
+		fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
+			e.company, e.phone) //Yes you can split into 2 lines here.
 	}
-	
+
 	//Student实现BorrowMoney方法
 	func (s *Student) BorrowMoney(amount float32) {
-	    s.loan += amount // (again and again and...)
+		s.loan += amount // (again and again and...)
 	}
-	
+
 	//Employee实现SpendSalary方法
 	func (e *Employee) SpendSalary(amount float32) {
-	    e.money -= amount // More vodka please!!! Get me through the day!
+		e.money -= amount // More vodka please!!! Get me through the day!
 	}
-	
+
 	// 定义interface
 	type Men interface {
-	    SayHi()
-	    Sing(lyrics string)
-	    Guzzle(beerStein string)
+		SayHi()
+		Sing(lyrics string)
+		Guzzle(beerStein string)
 	}
-	
+
 	type YoungChap interface {
-	    SayHi()
-	    Sing(song string)
-	    BorrowMoney(amount float32)
+		SayHi()
+		Sing(song string)
+		BorrowMoney(amount float32)
 	}
-	
+
 	type ElderlyGent interface {
-	    SayHi()
-	    Sing(song string)
-	    SpendSalary(amount float32)
+		SayHi()
+		Sing(song string)
+		SpendSalary(amount float32)
 	}
-	
+
 通过上面的代码我们可以知道，interface可以被任意的对象实现。我们看到上面的Men interface被Human、Student和Employee实现。同理，一个对象可以实现任意多个interface，例如上面的Student实现了Men和YonggChap两个interface。
 
 最后，任意的类型都实现了空interface(我们这样定义：interface{})，也就是包含0个method的interface。
@@ -96,78 +96,78 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 
 	package main
 	import "fmt"
-	
+
 	type Human struct {
-	    name string
-	    age int
-	    phone string
+		name string
+		age int
+		phone string
 	}
-	
+
 	type Student struct {
-	    Human //匿名字段
-	    school string
-	    loan float32
+		Human //匿名字段
+		school string
+		loan float32
 	}
-	
+
 	type Employee struct {
-	    Human //匿名字段
-	    company string
-	    money float32
+		Human //匿名字段
+		company string
+		money float32
 	}
-	
+
 	//Human实现Sayhi方法
 	func (h Human) SayHi() {
-	    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
+		fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
 	}
-	
+
 	//Human实现Sing方法
 	func (h Human) Sing(lyrics string) {
-	    fmt.Println("La la la la...", lyrics)
+		fmt.Println("La la la la...", lyrics)
 	}
-	
+
 	//Employee重载Human的SayHi方法
 	func (e Employee) SayHi() {
-	    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
-	        e.company, e.phone) //Yes you can split into 2 lines here.
+		fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
+			e.company, e.phone) //Yes you can split into 2 lines here.
 		}
-	
+
 	// Interface Men被Human,Student和Employee实现
 	// 因为这三个类型都实现了这两个方法
 	type Men interface {
-	    SayHi()
-	    Sing(lyrics string)
+		SayHi()
+		Sing(lyrics string)
 	}
-	
+
 	func main() {
-	    mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
-	    paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
-	    sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
-	    Tom := Employee{Human{"Sam", 36, "444-222-XXX"}, "Things Ltd.", 5000}
-	
-	    //定义Men类型的变量i
-	    var i Men
-	
-	    //i能存储Student
-	    i = mike
-	    fmt.Println("This is Mike, a Student:")
-	    i.SayHi()
-	    i.Sing("November rain")
-	
-	    //i也能存储Employee
-	    i = Tom
-	    fmt.Println("This is Tom, an Employee:")
-	    i.SayHi()
-	    i.Sing("Born to be wild")
-	
-	    //定义了slice Men
-	    fmt.Println("Let's use a slice of Men and see what happens")
-	    x := make([]Men, 3)
-	    //T这三个都是不同类型的元素，但是他们实现了interface同一个接口
-	    x[0], x[1], x[2] = paul, sam, mike
-	
-	    for _, value := range x{
-	        value.SayHi()
-	    }
+		mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
+		paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
+		sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
+		Tom := Employee{Human{"Sam", 36, "444-222-XXX"}, "Things Ltd.", 5000}
+
+		//定义Men类型的变量i
+		var i Men
+
+		//i能存储Student
+		i = mike
+		fmt.Println("This is Mike, a Student:")
+		i.SayHi()
+		i.Sing("November rain")
+
+		//i也能存储Employee
+		i = Tom
+		fmt.Println("This is Tom, an Employee:")
+		i.SayHi()
+		i.Sing("Born to be wild")
+
+		//定义了slice Men
+		fmt.Println("Let's use a slice of Men and see what happens")
+		x := make([]Men, 3)
+		//T这三个都是不同类型的元素，但是他们实现了interface同一个接口
+		x[0], x[1], x[2] = paul, sam, mike
+
+		for _, value := range x{
+			value.SayHi()
+		}
 	}
 
 通过上面的代码，你会发现interface就是一组抽象方法的集合，它必须由其他非interface类型实现，而不能自我实现， go 通过interface实现了duck-typing:即"当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子"。
@@ -182,41 +182,41 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 	// a可以存储任意类型的数值
 	a = i
 	a = s
-	
-一个函数把interface{}作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的值。是不是很有用啊！	
+
+一个函数把interface{}作为参数，那么他可以接受任意类型的值作为参数，如果一个函数返回interface{},那么也就可以返回任意类型的值。是不是很有用啊！
 ### interface函数参数
 interface的变量可以持有任意实现该interface类型的对象，这给我们编写函数(包括method)提供了一些额外的思考，我们是不是可以通过定义interface参数，让函数接受各种类型的参数。
 
 举个例子：我们已经知道fmt.Println是我们常用的一个函数，但是你是否注意到它可以接受任意类型的数据。打开fmt的源码文件，你会看到这样一个定义:
 
 	type Stringer interface {
-    	 String() string
+		 String() string
 	}
 任何实现了String方法的类型都能作为参数去调用fmt.Println,让我们来试一试
 
 	package main
 	import (
-	    "fmt"
-	    "strconv"
+		"fmt"
+		"strconv"
 	)
-	
+
 	type Human struct {
 		name string
-    	age int
-    	phone string
+		age int
+		phone string
 	}
-	
+
 	// 通过这个方法 Human 实现了 fmt.Stringer
 	func (h Human) String() string {
-	    return "❰"+h.name+" - "+strconv.Itoa(h.age)+" years -  ✆ " +h.phone+"❱"
+		return "❰"+h.name+" - "+strconv.Itoa(h.age)+" years -  ✆ " +h.phone+"❱"
 	}
-	
+
 	func main() {
-	    Bob := Human{"Bob", 39, "000-7777-XXX"}
-	    fmt.Println("This Human is : ", Bob)
+		Bob := Human{"Bob", 39, "000-7777-XXX"}
+		fmt.Println("This Human is : ", Bob)
 	}
 现在我们再回顾一下前面的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())
@@ -229,98 +229,98 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 - Comma-ok断言
 
 	Go语言里面有一个语法，可以直接判断是否是该类型的变量： value, ok = element.(T)，这里value就是变量的值，ok是一个bool类型，element是interface变量，T是断言的类型。
-	
+
 	如果element里面确实存储了T类型的数值，那么ok返回true，否则返回false。
-	
+
 	让我们通过一个例子来更加深入的理解。
-	
-		package main
-
-		import (
-    		"fmt"
-    		"strconv"
-		)
-		
-		type Element interface{}
-		type List [] Element
-
-		type Person struct {
-    		name string
-    		age int
-		}
 
-		//定义了String方法，实现了fmt.Stringer
-		func (p Person) String() string {
-    		return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
-		}
+	package main
 
-		func main() {
-    		list := make(List, 3)
-    		list[0] = 1 // an int
-    		list[1] = "Hello" // a string
-    		list[2] = Person{"Dennis", 70}
-
-    		for index, element := range list {
-        		if value, ok := element.(int); ok {
-            		fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
-        		} else if value, ok := element.(string); ok {
-            		fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
-        		} else if value, ok := element.(Person); ok {
-            		fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
-        		} else {
-            		fmt.Println("list[%d] is of a different type", index)
-        		}
-    		}
+	import (
+		"fmt"
+		"strconv"
+	)
+
+	type Element interface{}
+	type List [] Element
+
+	type Person struct {
+		name string
+		age int
+	}
+
+	//定义了String方法，实现了fmt.Stringer
+	func (p Person) String() string {
+		return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
+	}
+
+	func main() {
+		list := make(List, 3)
+		list[0] = 1 // an int
+		list[1] = "Hello" // a string
+		list[2] = Person{"Dennis", 70}
+
+		for index, element := range list {
+			if value, ok := element.(int); ok {
+				fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
+			} else if value, ok := element.(string); ok {
+				fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
+			} else if value, ok := element.(Person); ok {
+				fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
+			} else {
+				fmt.Println("list[%d] is of a different type", index)
+			}
 		}
-		
-	是不是很简单啊，同时你是否注意到了多个ifs里面，还记得我前面介绍流程里面讲过，if里面允许初始化变量。
-	
-	也许你注意到了，我们断言的类型越多，那么ifelse也就越多，所以才引出了下面要介绍的switch。	
+	}
+
+是不是很简单啊，同时你是否注意到了多个ifs里面，还记得我前面介绍流程里面讲过，if里面允许初始化变量。
+
+也许你注意到了，我们断言的类型越多，那么ifelse也就越多，所以才引出了下面要介绍的switch。
 - switch测试
 
-	最好的讲解就是代码例子，现在让我们重写上面的这个实现
-	
-		package main
-
-		import (
-    		"fmt"
-    		"strconv"
-		)
-
-		type Element interface{}
-		type List [] Element
-	
-		type Person struct {
-		    name string
-	    	age int
-		}
+最好的讲解就是代码例子，现在让我们重写上面的这个实现
 
-		//打印
-		func (p Person) String() string {
-    		return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
-		}
+	package main
+
+	import (
+		"fmt"
+		"strconv"
+	)
 
-		func main() {
-    		list := make(List, 3)
-    		list[0] = 1 //an int
-    		list[1] = "Hello" //a string
-    		list[2] = Person{"Dennis", 70}
-
-    		for index, element := range list{
-        		switch value := element.(type) {
-            		case int:
-                		fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
-            		case string:
-                		fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
-            		case Person:
-                		fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
-            		default:
-                		fmt.Println("list[%d] is of a different type", index)
-        		}
-    		}
+	type Element interface{}
+	type List [] Element
+
+	type Person struct {
+		name string
+		age int
+	}
+
+	//打印
+	func (p Person) String() string {
+		return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)"
+	}
+
+	func main() {
+		list := make(List, 3)
+		list[0] = 1 //an int
+		list[1] = "Hello" //a string
+		list[2] = Person{"Dennis", 70}
+
+		for index, element := range list{
+			switch value := element.(type) {
+				case int:
+					fmt.Printf("list[%d] is an int and its value is %d\n", index, value)
+				case string:
+					fmt.Printf("list[%d] is a string and its value is %s\n", index, value)
+				case Person:
+					fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)
+				default:
+					fmt.Println("list[%d] is of a different type", index)
+			}
 		}
-		
-	这里有一点需要强调的是：`element.(type)`语法不能在switch外的任何逻辑里面使用，如果你要在switch外面判断一个类型就使用`comma-ok`。	
+	}
+
+	这里有一点需要强调的是：`element.(type)`语法不能在switch外的任何逻辑里面使用，如果你要在switch外面判断一个类型就使用`comma-ok`。
 
 ### 嵌入interface
 Go里面真正吸引人的是他内置的逻辑语法，就像我们在学习Struct时学习的匿名字段，多么的优雅啊，那么相同的逻辑引入到interface里面，那不是更加完美了。如果一个interface1作为interface2的一个嵌入字段，那么interface2隐式的包含了interface1里面的method。
@@ -328,21 +328,21 @@ Go里面真正吸引人的是他内置的逻辑语法，就像我们在学习Str
 我们可以看到源码包container/heap里面有这样的一个定义
 
 	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
+		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给隐式的包含进来了。也就是下面三个方法
 
 	type Interface interface {
-    	// Len is the number of elements in the collection.
-    	Len() int
-    	// Less returns whether the element with index i should sort
-    	// before the element with index j.
-    	Less(i, j int) bool
-    	// Swap swaps the elements with indexes i and j.
-    	Swap(i, j int)
+		// Len is the number of elements in the collection.
+		Len() int
+		// Less returns whether the element with index i should sort
+		// before the element with index j.
+		Less(i, j int) bool
+		// Swap swaps the elements with indexes i and j.
+		Swap(i, j int)
 	}
 
 另一个例子就是io包下面的 io.ReadWriter ，他包含了io包下面的Reader和Writer两个interface。
@@ -350,9 +350,9 @@ Go里面真正吸引人的是他内置的逻辑语法，就像我们在学习Str
 	// io.ReadWriter
 	type ReadWriter interface {
 		Reader
-    	Writer
-	}	
-	
+		Writer
+	}
+
 ### 反射
 Go语言实现了反射，所谓反射就是动态运行时的状态。我们一般用到的包是reflect包。如何运用reflect包，官方的这篇文章详细的讲解了reflect包的实现原理，[laws of reflection](http://golang.org/doc/articles/laws_of_reflection.html)
 
@@ -365,34 +365,31 @@ Go语言实现了反射，所谓反射就是动态运行时的状态。我们一
 
 	tag := t.Elem().Field(0).Tag  //获取定义在strcut里面的标签
 	name := v.Elem().Field(0).String()  //获取存储在第一个字段里面的值
-	
+
 获取反射值能返回相应的类型和数值
-	
+
 	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())	
-    
+	v := reflect.ValueOf(x)
+	fmt.Println("type:", v.Type())
+	fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
+	fmt.Println("value:", v.Float())
+
 最后，反射的话，那么反射的字段必须是可修改的，我们前面学习过传值和传引用，这个里面也是一样的道理，反射的字段必须是可读写的意思是，如果下面这样写，那么会发生错误
 
 	var x float64 = 3.4
-    v := reflect.ValueOf(x)
-    v.SetFloat(7.1)
-    
+	v := reflect.ValueOf(x)
+	v.SetFloat(7.1)
+
 如果要修改相应的值，必须这样写
 
 	var x float64 = 3.4
-    p := reflect.ValueOf(&x)
-    v := p.Elem()
-    v.SetFloat(7.1)
-	
+	p := reflect.ValueOf(&x)
+	v := p.Elem()
+	v.SetFloat(7.1)
+
 使用反射需要自己在编程中不断的深入去了解，我这边只能大概的介绍一些。
 
 ## links
    * [目录](<preface.md>)
    * 上一章: [面向对象](<2.5.md>)
    * 下一节: [并发](<2.7.md>)
-
-## LastModified 
-   * $Id$

2.7.md

@@ -115,19 +115,19 @@ channel通过操作符`<-`来接收和发送数据
 	)
 
 	func fibonacci(n int, c chan int) {
-			x, y := 1, 1
-			for i := 0; i < n; i++ {
-					c <- x
-					x, y = y, x + y
-			}
-			close(c)
+		x, y := 1, 1
+		for i := 0; i < n; i++ {
+			c <- x
+			x, y = y, x + y
+		}
+		close(c)
 	}
 
 	func main() {
 		c := make(chan int, 10)
 		go fibonacci(cap(c), c)
 		for i := range c {
-			 fmt.Println(i)
+			fmt.Println(i)
 		}
 	}
 
@@ -149,13 +149,13 @@ channel通过操作符`<-`来接收和发送数据
 	func fibonacci(c, quit chan int) {
 		x, y := 1, 1
 		for {
-				select {
-				case c <- x:
-						  x, y = y, x + y
-				case <-quit:
+			select {
+			case c <- x:
+				x, y = y, x + y
+			case <-quit:
 			fmt.Println("quit")
-						return
-				}
+				return
+			}
 		}
 	}
 
@@ -187,6 +187,3 @@ channel通过操作符`<-`来接收和发送数据
    * [目录](<preface.md>)
    * 上一章: [interface](<2.6.md>)
    * 下一节: [总结](<2.8.md>)
-
-## LastModified
-   * $Id$

2.8.md

-# 2.8总结
-
-这一章我们主要介绍了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 用于定义函数和方法
-- return 用于从函数返回
-- defer 用于类似析构函数
-- go 用于并行
-- select 用于选择不同类型的通讯
-- interface 用于定义接口，参考2.6小节
-- struct 用于定义抽象数据类型，参考2.5小节
-- break、case、continue、for、fallthrough、else、if、switch、goto、default这些参考2.3流程介绍里面
-- chan用于channel通讯
-- type用于声明自定义类型
-- map用于声明map类型数据
-- range用于读取slice、map、channel数据
-
-上面这二十五个关键字记住了，那么Go你也已经差不多学会了。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [并发](<2.7.md>)
-   * 下一章: [Web基础](<3.md>)
-
-## LastModified
-   * $Id$
+# 2.8总结
+
+这一章我们主要介绍了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 用于定义函数和方法
+- return 用于从函数返回
+- defer 用于类似析构函数
+- go 用于并行
+- select 用于选择不同类型的通讯
+- interface 用于定义接口，参考2.6小节
+- struct 用于定义抽象数据类型，参考2.5小节
+- break、case、continue、for、fallthrough、else、if、switch、goto、default这些参考2.3流程介绍里面
+- chan用于channel通讯
+- type用于声明自定义类型
+- map用于声明map类型数据
+- range用于读取slice、map、channel数据
+
+上面这二十五个关键字记住了，那么Go你也已经差不多学会了。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [并发](<2.7.md>)
+   * 下一章: [Web基础](<3.md>)

2.md

-# 2 Go语言基础
-
-## 目录
-   * 1. [你好，Go](2.1.md)
-   * 2. [Go基础](2.2.md)
-   * 3. [流程和函数](2.3.md)
-   * 4. [struct类型](2.4.md)
-   * 5. [面向对象](2.5.md)
-   * 6. [interface](2.6.md)
-   * 7. [并发](2.7.md)
-   * 8. [小结](2.8.md)
-
-Go是一门类似C的编译型语言，但是它的编译速度非常快。这门语言的关键字总共也就二十五个，比英文字母还少一个，这对于我们的学习来说就简单了很多。先让我们看一眼这些关键字都长什么样：
-
-	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
-
-在接下来的这一章中，我将带领你去学习这门语言的基础。通过每一小节的介绍，你将发现，Go的世界是那么地简洁，设计是如此地美妙，编写Go将会是一件愉快的事情。等回过头来，你就会发现这二十五个关键字是多么地亲切。
-
-
-## links
-   * [目录](<preface.md>)
-   * 上一章: [第一章总结](<1.5.md>)
-   * 下一节: [你好，Go](<2.1.md>)
-
-## LastModified
-   * $Id$
+# 2 Go语言基础
+
+## 目录
+   * 1. [你好，Go](2.1.md)
+   * 2. [Go基础](2.2.md)
+   * 3. [流程和函数](2.3.md)
+   * 4. [struct类型](2.4.md)
+   * 5. [面向对象](2.5.md)
+   * 6. [interface](2.6.md)
+   * 7. [并发](2.7.md)
+   * 8. [小结](2.8.md)
+
+Go是一门类似C的编译型语言，但是它的编译速度非常快。这门语言的关键字总共也就二十五个，比英文字母还少一个，这对于我们的学习来说就简单了很多。先让我们看一眼这些关键字都长什么样：
+
+	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
+
+在接下来的这一章中，我将带领你去学习这门语言的基础。通过每一小节的介绍，你将发现，Go的世界是那么地简洁，设计是如此地美妙，编写Go将会是一件愉快的事情。等回过头来，你就会发现这二十五个关键字是多么地亲切。
+
+
+## links
+   * [目录](<preface.md>)
+   * 上一章: [第一章总结](<1.5.md>)
+   * 下一节: [你好，Go](<2.1.md>)

3.2.md

@@ -62,6 +62,3 @@
    * [目录](<preface.md>)
    * 上一节: [Web工作方式](<3.1.md>)
    * 下一节: [Go如何使得web工作](<3.3.md>)
-
-## LastModified 
-   * $Id$

3.3.md

@@ -48,6 +48,3 @@ Handler：处理请求和生成返回信息的处理逻辑
    * [目录](<preface.md>)
    * 上一节: [GO搭建一个简单的web服务](<3.2.md>)
    * 下一节: [Go的http包详解](<3.4.md>)
-
-## LastModified 
-   * $Id$

3.5.md

-# 3.5小结
-这一章我们介绍了HTTP协议, DNS解析的过程, 如何用go实现一个简陋的web server。并深入到net/http包的源码中为大家揭开如何实现此server的秘密。
-
-我希望通过这一章的学习，你能够对Go开发Web有了初步的了解，我们也看到相应的代码了，Go开发Web应用是很方便的，同时又是相当的灵活。
-
-## links
-   * [目录](<preface.md>)
-   * 上一节: [Go的http包详解](<3.4.md>)
-   * 下一章: [表单](<4.md>)
-
-## LastModified 
-   * $Id$
\ No newline at end of file
+# 3.5小结
+这一章我们介绍了HTTP协议, DNS解析的过程, 如何用go实现一个简陋的web server。并深入到net/http包的源码中为大家揭开如何实现此server的秘密。
+
+我希望通过这一章的学习，你能够对Go开发Web有了初步的了解，我们也看到相应的代码了，Go开发Web应用是很方便的，同时又是相当的灵活。
+
+## links
+   * [目录](<preface.md>)
+   * 上一节: [Go的http包详解](<3.4.md>)
+   * 下一章: [表单](<4.md>)