update 11-21

Author: 3ks

PROGRESS.md

@@ -18,17 +18,17 @@
 - [x] Arrays->数组
 - [x] Slices->切片
 - [x] Maps->Map
-- [ ] Range->Range 遍历
-- [ ] Functions->函数
-- [ ] Multiple Return Values->多返回值
-- [ ] Variadic Functions->变参函数
-- [ ] Closures->闭包
-- [ ] Recursion->递归
-- [ ] Pointers->指针
-- [ ] Structs->结构体
-- [ ] Methods->方法
-- [ ] Interfaces->接口
-- [ ] Errors->错误处理
+- [x] Range->Range 遍历
+- [x] Functions->函数
+- [x] Multiple Return Values->多返回值
+- [x] Variadic Functions->变参函数
+- [x] Closures->闭包
+- [x] Recursion->递归
+- [x] Pointers->指针
+- [x] Structs->结构体
+- [x] Methods->方法
+- [x] Interfaces->接口
+- [x] Errors->错误处理
 - [ ] Goroutines->协程
 - [ ] Channels->通道
 - [ ] Channel Buffering->通道缓冲

examples/closures/closures.go

@@ -1,12 +1,13 @@
-// Go 支持[_匿名函数_](http://zh.wikipedia.org/wiki/%E5%8C%BF%E5%90%8D%E5%87%BD%E6%95%B0)，并能用其构造 <a href="http://zh.wikipedia.org/wiki/%E9%97%AD%E5%8C%85_(%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6)"><em>闭包</em></a>。
+// Go 支持[_匿名函数_](http://zh.wikipedia.org/wiki/%E5%8C%BF%E5%90%8D%E5%87%BD%E6%95%B0)，
+// 并能用其构造 <a href="http://zh.wikipedia.org/wiki/%E9%97%AD%E5%8C%85_(%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6)"><em>闭包</em></a>。
 // 匿名函数在你想定义一个不需要命名的内联函数时是很实用的。
-
 package main
 
 import "fmt"
 
-// 这个 `intSeq` 函数返回另一个在 `intSeq` 函数体内定义的
-// 匿名函数。这个返回的函数使用闭包的方式 _隐藏_ 变量 `i`。
+// `intSeq` 函数返回一个在其函数体内定义的匿名函数。
+// 返回的函数使用闭包的方式 _隐藏_ 变量 `i`。
+// 返回的函数 _隐藏_ 变量 `i` 以形成闭包。
 func intSeq() func() int {
 	i := 0
 	return func() int {
@@ -17,18 +18,16 @@ func intSeq() func() int {
 
 func main() {
 
-	// 我们调用 `intSeq` 函数，将返回值（一个函数）赋给
-	// `nextInt`。这个函数的值包含了自己的值 `i`，这样在每
-	// 次调用 `nextInt` 时都会更新 `i` 的值。
+	// 我们调用 `intSeq` 函数，将返回值（一个函数）赋给 `nextInt`。
+	// 这个函数的值包含了自己的值 `i`，这样在每次调用 `nextInt` 时，都会更新 `i` 的值。
 	nextInt := intSeq()
 
 	// 通过多次调用 `nextInt` 来看看闭包的效果。
 	fmt.Println(nextInt())
 	fmt.Println(nextInt())
 	fmt.Println(nextInt())
 
-	// 为了确认这个状态对于这个特定的函数是唯一的，我们
-	// 重新创建并测试一下。
+	// 为了确认这个状态对于这个特定的函数是唯一的，我们重新创建并测试一下。
 	newInts := intSeq()
 	fmt.Println(newInts())
 }

examples/errors/errors.go

@@ -1,21 +1,18 @@
 // 符合 Go 语言习惯的做法是使用一个独立、明确的返回值来传递错误信息。
-// 这与使用异常(exception)的 Java 和 Ruby
-// 以及在 C 语言中有时用到的重载(overloaded)的单返回/错误值有着明显的不同。
-// Go 语言的处理方式能清楚的知道哪个函数
-// 返回了错误，并能像调用那些没有出错的函数一样调用。
+// 这与 Java、Ruby 使用的异常（exception）
+// 以及在 C 语言中有时用到的重载 (overloaded) 的单返回/错误值有着明显的不同。
+// Go 语言的处理方式能清楚的知道哪个函数返回了错误，并使用跟其他（无异常处理的）语言类似的方式来处理错误。
 
 package main
 
 import "errors"
 import "fmt"
 
-// 按照惯例，错误通常是最后一个返回值并且是 `error` 类
-// 型，一个内建的接口。
+// 按照惯例，错误通常是最后一个返回值并且是 `error` 类型，它是一个内建的接口。
 func f1(arg int) (int, error) {
 	if arg == 42 {
 
-		// `errors.New` 构造一个使用给定的错误信息的基本
-		// `error` 值。
+		// `errors.New` 使用给定的错误信息构造一个基本的 `error` 值。
 		return -1, errors.New("can't work with 42")
 
 	}
@@ -24,7 +21,7 @@ func f1(arg int) (int, error) {
 	return arg + 3, nil
 }
 
-// 通过实现 `Error` 方法来自定义 `error` 类型是可以的。
+// 你还可以通过实现 `Error()` 方法来自定义 `error` 类型。
 // 这里使用自定义错误类型来表示上面例子中的参数错误。
 type argError struct {
 	arg  int
@@ -38,18 +35,17 @@ func (e *argError) Error() string {
 func f2(arg int) (int, error) {
 	if arg == 42 {
 
-		// 在这个例子中，我们使用 `&argError` 语法来建立一个
-		// 新的结构体，并提供了 `arg` 和 `prob` 这两个字段
-		// 的值。
+		// 在这个例子中，我们使用 `&argError` 语法来建立一个新的结构体，
+		// 并提供了 `arg` 和 `prob` 两个字段的值。
 		return -1, &argError{arg, "can't work with it"}
 	}
 	return arg + 3, nil
 }
 
 func main() {
 
-	// 下面的两个循环测试了各个返回错误的函数。注意在 `if`
-	// 行内的错误检查代码，在 Go 中是一个普遍的用法。
+	// 下面的两个循环测试了每一个会返回错误的函数。
+	// 注意，在 `if` 的同一行进行错误检查，是 Go 代码中的一种常见用法。
 	for _, i := range []int{7, 42} {
 		if r, e := f1(i); e != nil {
 			fmt.Println("f1 failed:", e)
@@ -65,8 +61,8 @@ func main() {
 		}
 	}
 
-	// 你如果想在程序中使用一个自定义错误类型中的数据，你
-	// 需要通过类型断言来得到这个错误类型的实例。
+	// 如果你想在程序中使用自定义错误类型的数据，
+	// 你需要通过类型断言来得到这个自定义错误类型的实例。
 	_, e := f2(42)
 	if ae, ok := e.(*argError); ok {
 		fmt.Println(ae.arg)

examples/errors/errors.sh

@@ -6,5 +6,5 @@ f2 failed: 42 - can't work with it
 42
 can't work with it
 
-# 到 Go 官方博客去看这篇[很棒的文章](http://blog.golang.org/2011/07/error-handling-and-go.html)
-# 获取更多关于错误处理的信息。
+# 到 Go 官方博客去看这篇[很棒的文章](http://blog.golang.org/2011/07/error-handling-and-go.html)，
+# 以获取更多关于错误处理的信息。

examples/functions/functions.go

@@ -1,27 +1,25 @@
-// _函数_ 是 Go 的中心。我们将通过一些不同的例子来
-// 进行学习。
-
+// _函数_ 是 Go 的核心。
+// 我们将通过一些不同的例子来进行学习。
 package main
 
 import "fmt"
 
 // 这里是一个函数，接受两个 `int` 并且以 `int` 返回它们的和
 func plus(a int, b int) int {
 
-	// Go 需要明确的返回，不会自动返回最
-	// 后一个表达式的值
+	// Go 需要明确的 return，也就是说，它不会自动 return 最后一个表达式的值
 	return a + b
 }
 
-// 当多个连续的参数为同样类型时，最多可以仅声明最后一个参数类型
-// 而忽略之前相同类型参数的类型声明。
+// 当多个连续的参数为同样类型时，
+// 可以仅声明最后一个参数的类型，忽略之前相同类型参数的类型声明。
 func plusPlus(a, b, c int) int {
 	return a + b + c
 }
 
 func main() {
 
-	// 通过 `name(args)` 来调用函数，
+	// 通过 `函数名(参数列表)` 来调用函数，
 	res := plus(1, 2)
 	fmt.Println("1+2 =", res)
 

examples/functions/functions.sh

@@ -2,5 +2,5 @@ $ go run functions.go
 1+2 = 3
 1+2+3 = 6
 
-# Go 函数有很多其他的特性。其中一个就是多值返回，也是
-# 我们接下来需要接触的。
+# Go 函数还有很多其他的特性。
+# 其中一个就是多值返回，它也是我们接下来要接触的。

examples/interfaces/interfaces.go

@@ -1,27 +1,25 @@
-// _接口(Interfaces)_ 是命名了的方法签名(signatures)的集合。
-
+// 方法签名的集合叫做：_接口(Interfaces)_。
 package main
 
 import "fmt"
 import "math"
 
-// 这里是一个几何体的基本接口。
+// 这是一个几何体的基本接口。
 type geometry interface {
 	area() float64
 	perim() float64
 }
 
-// 在我们的例子中，我们将在类型 `rect` 和 `circle` 上实现
-// 这个接口
+// 在这个例子中，我们将为 `rect` 和 `circle` 实现该接口。
 type rect struct {
 	width, height float64
 }
 type circle struct {
 	radius float64
 }
 
-// 要在 Go 中实现一个接口，我们就需要实现接口中的所有
-// 方法。这里我们在 `rect` 上实现了 `geometry` 接口。
+// 要在 Go 中实现一个接口，我们只需要实现接口中的所有方法。
+// 这里我们为 `rect` 实现了 `geometry` 接口。
 func (r rect) area() float64 {
 	return r.width * r.height
 }
@@ -37,9 +35,8 @@ func (c circle) perim() float64 {
 	return 2 * math.Pi * c.radius
 }
 
-// 如果一个变量具有接口类型，那么我们可以调用指定接口中的
-// 方法。这里有一个通用的 `measure` 函数，利用它来在任
-// 何的 `geometry` 上工作。
+// 如果一个变量实现了某个接口，我们就可以调用指定接口中的方法。
+// 这儿有一个通用的 `measure` 函数，我们可以通过它来使用所有的 `geometry`。
 func measure(g geometry) {
 	fmt.Println(g)
 	fmt.Println(g.area())
@@ -50,8 +47,8 @@ func main() {
 	r := rect{width: 3, height: 4}
 	c := circle{radius: 5}
 
-	// 结构体类型 `circle` 和 `rect` 都实现了 `geometry`
-	// 接口，所以我们可以使用它们的实例作为 `measure` 的参数。
+	// 结构体类型 `circle` 和 `rect` 都实现了 `geometry` 接口，
+	// 所以我们可以将其实例作为 `measure` 的参数。
 	measure(r)
 	measure(c)
 }

examples/interfaces/interfaces.sh

@@ -6,5 +6,5 @@ $ go run interfaces.go
 78.53981633974483
 31.41592653589793
 
-# 要学习更多关于 Go 的接口的知识，看看这篇
-# [很棒的博文](http://jordanorelli.tumblr.com/post/32665860244/how-to-use-interfaces-in-go)。
+# 要学习更多关于 Go 接口的知识，
+# 可以看看这篇[很棒的博文](http://jordanorelli.tumblr.com/post/32665860244/how-to-use-interfaces-in-go)。

examples/methods/methods.go

@@ -1,5 +1,4 @@
-// Go 支持在结构体类型中定义_方法(methods)_ 。
-
+// Go 支持为结构体类型定义_方法(methods)_ 。
 package main
 
 import "fmt"
@@ -8,13 +7,13 @@ type rect struct {
 	width, height int
 }
 
-// 这里的 `area` 方法有一个_接收器(receiver)类型_ `rect`。
+// 这里的 `area` 方法有一个 _接收者类型_：`rect`。
 func (r *rect) area() int {
 	return r.width * r.height
 }
 
-// 可以为值类型或者指针类型的接收器定义方法。这里是一个
-// 值类型接收器的例子。
+// 可以为值类型或者指针类型的接收者定义方法。
+// 这是一个值类型接收者的例子。
 func (r rect) perim() int {
 	return 2*r.width + 2*r.height
 }
@@ -26,9 +25,10 @@ func main() {
 	fmt.Println("area: ", r.area())
 	fmt.Println("perim:", r.perim())
 
-	// Go 自动处理方法调用时的值和指针之间的转化。你可以使
-	// 用指针来调用方法来避免在方法调用时产生一个拷贝，或者
-	// 让方法能够改变接受的结构体。
+	// 调用方法时，Go 会自动处理值和指针之间的转换。
+	// 想要避免在调用方法时产生一个拷贝，或者想让方法可以修改接受结构体的值，
+	// 你都可以使用指针来调用方法。
+
 	rp := &r
 	fmt.Println("area: ", rp.area())
 	fmt.Println("perim:", rp.perim())

examples/methods/methods.sh

@@ -4,5 +4,4 @@ perim: 30
 area:  50
 perim: 30
 
-# 接下来我们将介绍Go用于分组和命名相关
-# 方法集合的另一机制：接口。
+# 接下来，我们将学习 Go 对方法集进行命名和分组的另一机制：接口。

examples/multiple-return-values/multiple-return-values.go

@@ -1,6 +1,5 @@
-// Go 内建_多返回值_支持。这个特性在 Go 语言中经常被用到，
-// 例如用来同时返回一个函数的结果和错误信息。
-
+// Go 原生支持 _多返回值_。
+// 这个特性在 Go 语言中经常用到，例如用来同时返回一个函数的结果和错误信息。
 package main
 
 import "fmt"
@@ -12,12 +11,12 @@ func vals() (int, int) {
 
 func main() {
 
-	// 这里我们通过_多赋值_操作来使用这两个不同的返回值。
+	// 这里我们通过 _多赋值_ 操作来使用这两个不同的返回值。
 	a, b := vals()
 	fmt.Println(a)
 	fmt.Println(b)
 
-	// 如果你仅仅需要返回值的一部分的话，你可以使用空白标识符`_`。
+	// 如果你仅仅需要返回值的一部分的话，你可以使用空白标识符 `_`。
 	_, c := vals()
 	fmt.Println(c)
 }

examples/multiple-return-values/multiple-return-values.sh

@@ -3,5 +3,4 @@ $ go run multiple-return-values.go
 7
 7
 
-# 允许可变长参数是 Go 函数另一个很好的特性；我们将在接下来
-# 进行学习。
+# 我们接下来要学习的是 Go 函数另一个很好的特性：变长参数。

examples/pointers/pointers.go

@@ -1,22 +1,19 @@
 // Go 支持 <em><a href="http://zh.wikipedia.org/wiki/%E6%8C%87%E6%A8%99_(%E9%9B%BB%E8%85%A6%E7%A7%91%E5%AD%B8)">指针</a></em>，
-// 允许在程序中通过引用传递值或者数据结构。
-
+// 允许在程序中通过 `引用传递` 来传递值和数据结构。
 package main
 
 import "fmt"
 
-// 我们将通过两个函数：`zeroval` 和 `zeroptr` 来比较指针和
-// 值类型的不同。`zeroval` 有一个 `int` 型参数，所以使用值
-// 传递。`zeroval` 将从调用它的那个函数中得到一个 `ival`
-// 形参的拷贝。
+// 我们将通过两个函数：`zeroval` 和 `zeroptr` 来比较 `指针` 和 `值`。
+// `zeroval` 有一个 `int` 型参数，所以使用值传递。
+// `zeroval` 将从调用它的那个函数中得到一个实参的拷贝：ival。
 func zeroval(ival int) {
 	ival = 0
 }
 
-// `zeroptr` 有一和上面不同的 `*int` 参数，意味着它用了一
-// 个 `int`指针。函数体内的 `*iptr` 接着_解引用_这个指针，
-// 从它内存地址得到这个地址对应的当前值。对一个解引用的指
-// 针赋值将会改变这个指针引用的真实地址的值。
+// `zeroptr` 有一个和上面不同的参数：`*int`，这意味着它使用了 `int` 指针。
+// 紧接着，函数体内的 `*iptr` 会 _解引用_ 这个指针，从它的内存地址得到这个地址当前对应的值。
+// 对解引用的指针赋值，会改变这个指针引用的真实地址的值。
 func zeroptr(iptr *int) {
 	*iptr = 0
 }

examples/pointers/pointers.sh

@@ -1,6 +1,5 @@
-# `zeroval` 在 `main` 函数中不能改变 `i` 的值，但是
-# `zeroptr` 可以，因为它有这个变量的内存地址的
-# 引用。
+# `zeroval` 在 `main` 函数中不能改变 `i` 的值，
+# 但是 `zeroptr` 可以，因为它有这个变量的内存地址的引用。
 $ go run pointers.go
 initial: 1
 zeroval: 1

examples/range/range.go

@@ -1,14 +1,13 @@
-// _range_ 迭代各种各样的数据结构。让我们来看看如何在我们
-// 已经学过的数据结构上使用 `range`。
-
+// _range_ 用于迭代各种各样的数据结构。
+// 让我们来看看如何在我们已经学过的数据结构上使用 `range`。
 package main
 
 import "fmt"
 
 func main() {
 
 	// 这里我们使用 `range` 来对 slice 中的元素求和。
-	// 对于数组也可以采用这种方法。
+	// 数组也可以用这种方法初始化并赋初值。
 	nums := []int{2, 3, 4}
 	sum := 0
 	for _, num := range nums {
@@ -17,8 +16,8 @@ func main() {
 	fmt.Println("sum:", sum)
 
 	// `range` 在数组和 slice 中提供对每项的索引和值的访问。
-	// 上面我们不需要索引，所以我们使用 _空白标识符_
-	// `_` 来忽略它。有时候我们实际上是需要这个索引的。
+	// 上面我们不需要索引，所以我们使用 _空白标识符_ `_` 将其忽略。
+	// 实际上，我们有时候是需要这个索引的。
 	for i, num := range nums {
 		if num == 3 {
 			fmt.Println("index:", i)