sync 1-10

Author: 3ks

PROGRESS.md

@@ -8,16 +8,16 @@
 
 # 同步进度
 
-- [ ] Hello World
-- [ ] Values->值
-- [ ] Variables->变量
-- [ ] Constants->常量
-- [ ] For->For 循环
-- [ ] If/Else->If/Else 分支
-- [ ] Switch->Switch 分支结构
-- [ ] Arrays->数组
-- [ ] Slices->切片
-- [ ] Maps->Map
+- [x] Hello World
+- [x] Values->值
+- [x] Variables->变量
+- [x] Constants->常量
+- [x] For->For 循环
+- [x] If/Else->If/Else 分支
+- [x] Switch->Switch 分支结构
+- [x] Arrays->数组
+- [x] Slices->切片
+- [x] Maps->Map
 - [ ] Range->Range 遍历
 - [ ] Functions->函数
 - [ ] Multiple Return Values->多返回值

examples/arrays/arrays.go

@@ -1,32 +1,31 @@
-// 在 Go 中，_数组_ 是一个具有固定长度且编号的元素序列。
+// 在 Go 中，_数组_ 是一个具有编号且长度固定的元素序列。
 
 package main
 
 import "fmt"
 
 func main() {
 
-	// 这里我们创建了一个数组 `a` 来存放刚好 5 个 `int`。
-	// 元素的类型和长度都是数组类型的一部分。数组默认是
-	// 零值的，对于 `int` 数组来说也就是 `0`。
+	// 这里我们创建了一个刚好可以存放 5 个 `int` 元素的数组 `a`。
+	// 元素的类型和长度都是数组类型的一部分。
+	// 数组默认值是零值，对于 `int` 数组来说，元素的零值是 `0`。
 	var a [5]int
 	fmt.Println("emp:", a)
 
-	// 我们可以使用 `array[index] = value` 语法来设置数组
-	// 指定位置的值，或者用 `array[index]` 得到值。
+	// 我们可以使用 `array[index] = value` 语法来设置数组指定位置的值，
+	// 或者用 `array[index]` 得到值。
 	a[4] = 100
 	fmt.Println("set:", a)
 	fmt.Println("get:", a[4])
 
-	// 使用内置函数 `len` 返回数组的长度。
+	// 内置函数 `len` 可以返回数组的长度。
 	fmt.Println("len:", len(a))
 
 	// 使用这个语法在一行内声明并初始化一个数组。
 	b := [5]int{1, 2, 3, 4, 5}
 	fmt.Println("dcl:", b)
 
-	// 数组类型是一维的，但是你可以组合
-	// 构造多维的数据结构。
+	// 数组类型是一维的，但是你可以组合构造多维的数据结构。
 	var twoD [2][3]int
 	for i := 0; i < 2; i++ {
 		for j := 0; j < 3; j++ {

examples/arrays/arrays.sh

@@ -1,5 +1,4 @@
-# 注意，在使用 `fmt.Println` 来打印数组的时候，会使用
-# `[v1 v2 v3 ...]` 的格式显示。
+# 注意，使用 `fmt.Println` 打印数组时，会按照 `[v1 v2 v3 ...]` 的格式打印。
 $ go run arrays.go
 emp: [0 0 0 0 0]
 set: [0 0 0 0 100]
@@ -8,5 +7,4 @@ len: 5
 dcl: [1 2 3 4 5]
 2d:  [[0 1 2] [1 2 3]]
 
-# 在 Go 程序中，相对于数组而言，_切片(slice)_ 使用
-# 的更多。下面我们讨论切片。
+# 在 Go 程序中，相较于数组，用得更多的是 _切片(slice)_。我们接着来看切片。

examples/constants/constants.go

@@ -10,20 +10,17 @@ const s string = "constant"
 func main() {
 	fmt.Println(s)
 
-	// `const` 语句可以出现在任何 `var` 语句可以出现
-	// 的地方
+	// `const` 语句可以出现在任何 `var` 语句可以出现的地方
 	const n = 500000000
 
 	// 常数表达式可以执行任意精度的运算
 	const d = 3e20 / n
 	fmt.Println(d)
 
-	// 数值型常量没有确定的类型，直到被给定
-	// ，比如一次显示的类型转化。
+	// 数值型常量没有确定的类型，直到被给定某个类型，比如显示类型转化。
 	fmt.Println(int64(d))
 
-	// 当上下文需要时，比如变量赋值或者函数调用，
-	// 一个数可以被给定一个类型。举个例子，这里的 `math.Sin`
-	// 函数需要一个 `float64` 的参数。
+	// 一个数字可以根据上下文的需要（比如变量赋值、函数调用）自动确定类型。
+	// 举个例子，这里的 `math.Sin` 函数需要一个 `float64` 的参数，`n` 会自动确定类型。
 	fmt.Println(math.Sin(n))
 }

examples/for/for.go

@@ -1,5 +1,4 @@
-// `for` 是 Go 中唯一的循环结构。这里有 `for` 循环
-// 的三个基本使用方式。
+// `for` 是 Go 中唯一的循环结构。这里会展示 `for` 循环的三种基本使用方式。
 
 package main
 
@@ -19,14 +18,14 @@ func main() {
 		fmt.Println(j)
 	}
 
-	// 不带条件的 `for` 循环将一直重复执行，直到在循环体内使用
-	// 了 `break` 或者 `return` 来跳出循环。
+	// 不带条件的 `for` 循环将一直重复执行，
+	// 直到在循环体内使用了 `break` 或者 `return` 跳出循环。
 	for {
 		fmt.Println("loop")
 		break
 	}
 
-	// 你也可以使用 `continue` 来跳到下一个循环迭代
+	// 你也可以使用 `continue` 直接进入下一次循环。
 	for n := 0; n <= 5; n++ {
 		if n%2 == 0 {
 			continue

examples/for/for.sh

@@ -10,5 +10,5 @@ loop
 3
 5
 
-# 后续教程中当我们学习 `range` 语句，channels，以及其他
-# 数据结构时，将会看到一些 `for` 的其它形式。
+# 我们在后续教程中学习 `range` 语句，channels 以及其他数据结构时，
+# 还会看到一些 `for` 的其它用法。

examples/hello-world/hello-world.go

@@ -1,5 +1,5 @@
-// 我们的第一个程序将打印传说中的 "`hello world`"
-// 消息，右边是完整的程序代码。
+// 我们的第一个程序将打印传说中的“hello world”，
+// 右边是完整的程序代码。
 package main
 
 import "fmt"

examples/hello-world/hello-world.sh

@@ -1,9 +1,9 @@
-# 要运行这个程序，将代码放到 `hello-world.go` 中
-# 然后执行 `go run` 。
+# 要运行这个程序，先将将代码放到名为 `hello-world.go`
+# 的文件中，然后执行 `go run`。
 $ go run hello-world.go
 hello world
 
-# 有时候我们想将程序编译成二进制文件，
+# 如果我们想将程序编译成二进制文件（Windows 平台是 .exe 可执行文件），
 # 可以通过 `go build` 来达到目的。
 $ go build hello-world.go
 $ ls
@@ -13,5 +13,5 @@ hello-world	hello-world.go
 $ ./hello-world
 hello world
 
-# 现在我们可以运行并编译基本的 Go 程序，让我们开始学习更多
-# 关于这门语言的知识吧。
+# 现在我们可以运行和编译基础的 Go 程序了，
+# 让我们开始学习更多关于这门语言的知识吧。

examples/if-else/if-else.go

@@ -18,8 +18,7 @@ func main() {
 		fmt.Println("8 is divisible by 4")
 	}
 
-	// 在条件语句之前可以有一个声明语句；在这里声明的变量
-	// 可以在所有的条件分支中使用。
+	// 在条件语句之前可以有一个声明语句；在这里声明的变量可以在这个语句所有的条件分支中使用。
 	if num := 9; num < 0 {
 		fmt.Println(num, "is negative")
 	} else if num < 10 {
@@ -29,4 +28,4 @@ func main() {
 	}
 }
 
-// 注意，在 Go 中条件语句不需要圆括号，但是需要加上花括号。
+// 注意，在 Go 中，条件语句的圆括号不是必需的，但是花括号是必需的。

examples/if-else/if-else.sh

@@ -3,6 +3,5 @@ $ go run if-else.go
 8 is divisible by 4
 9 has 1 digit
 
-# Go 里没有[三目运算符](http://en.wikipedia.org/wiki/%3F:)，
-# 所以即使你只需要基本的条件判断，你仍需要使用完整的 `if` 
-# 语句。
+# Go 没有[三目运算符](http://en.wikipedia.org/wiki/%3F:)，
+# 即使是基本的条件判断，依然需要使用完整的 `if` 语句。

examples/maps/maps.go

@@ -1,45 +1,40 @@
-// _map_ 是 Go 内置[关联数据类型](http://zh.wikipedia.org/wiki/关联数组)（
-// 在一些其他的语言中称为_哈希(hash)_ 或者_字典(dict)_ ）。
+// _map_ 是 Go 内建的[关联数据类型](http://zh.wikipedia.org/wiki/关联数组)
+// （在一些其他的语言中也被称为 _哈希(hash)_ 或者 _字典(dict)_ ）。
 
 package main
 
 import "fmt"
 
 func main() {
 
-	// 要创建一个空 map，需要使用内建的 `make`:
-	// `make(map[key-type]val-type)`.
+	// 要创建一个空 map，需要使用内建函数 `make`：`make(map[key-type]val-type)`。
 	m := make(map[string]int)
 
 	// 使用典型的 `make[key] = val` 语法来设置键值对。
 	m["k1"] = 7
 	m["k2"] = 13
 
-	// 使用例如 `fmt.Println` 来打印一个 map 将会输出所有的
-	// 键值对。
+	// 打印 map。例如，使用 `fmt.Println` 打印一个 map，会输出它所有的键值对。
 	fmt.Println("map:", m)
 
-	// 使用 `name[key]` 来获取一个键的值
+	// 使用 `name[key]` 来获取一个键的值。
 	v1 := m["k1"]
 	fmt.Println("v1: ", v1)
 
-	// 当对一个 map 调用内建的 `len` 时，返回的是键值对
-	// 数目
+	// 内建函数 `len` 可以返回一个 map 的键值对数量。
 	fmt.Println("len:", len(m))
 
-	// 内建的 `delete` 可以从一个 map 中移除键值对
+	// 内建函数 `delete` 可以从一个 map 中移除键值对。
 	delete(m, "k2")
 	fmt.Println("map:", m)
 
-	// 当从一个 map 中取值时，可选的第二返回值指示这个键
-	// 是否在这个 map 中。这可以用来消除键不存在和键有零值，
-	// 像 `0` 或者 `""` 而产生的歧义。这里我们不需要值，所以
-	// 用_空白标识符(blank identifier)_忽略。
+	// 当从一个 map 中取值时，还有可以选择是否接收的第二个返回值，该值表明了 map 中是否存在这个键。
+	// 这可以用来消除 `键不存在` 和 `键的值为零值` 产生的歧义，
+	// 例如 `0` 和 `""`。这里我们不需要值，所以用 _空白标识符(blank identifier)_ _ 将其忽略。
 	_, prs := m["k2"]
 	fmt.Println("prs:", prs)
 
-	// 你也可以通过这个语法在同一行声明和初始化一个新的
-	// map。
+	// 你也可以通过右边的语法在一行代码中声明并初始化一个新的 map。
 	n := map[string]int{"foo": 1, "bar": 2}
 	fmt.Println("map:", n)
 }

examples/maps/maps.sh

@@ -1,5 +1,5 @@
-# 注意一个 map 在使用 `fmt.Println` 打印的时候，是以 `map[k:v k:v]`
-# 的格式输出的。
+# 注意，使用 `fmt.Println` 打印一个 map 的时候，
+# 是以 `map[k:v k:v]` 的格式输出的。
 $ go run maps.go 
 map: map[k1:7 k2:13]
 v1:  7

examples/slices/slices.go

@@ -1,16 +1,14 @@
-// _Slice_ 是 Go 中一个关键的数据类型，是一个比数组更
-// 加强大的序列接口
+// _Slice_ 是 Go 中一个重要的数据类型，它提供了比数组更强大的序列交互方式。
 
 package main
 
 import "fmt"
 
 func main() {
 
-	// 与数组不同，slice 的类型仅由它所包含的元素决定（不需要
-	// 元素的个数）。要创建一个长度非零的空
-	// slice，需要使用内建的方法 `make`。这里我们创建了一
-	// 个长度为3的 `string` 类型 slice（初始化为零值）。
+	// 与数组不同，slice 的类型仅由它所包含的元素的类型决定（与元素个数无关）。
+	// 要创建一个长度不为 0 的空 slice，需要使用内建函数 `make`。
+	// 这里我们创建了一个长度为 3 的 `string` 类型的 slice（初始值为零值）。
 	s := make([]string, 3)
 	fmt.Println("emp:", s)
 
@@ -24,40 +22,37 @@ func main() {
 	// `len` 返回 slice 的长度
 	fmt.Println("len:", len(s))
 
-	// 除了基本操作外，slice 支持比数组更丰富的操作。
-	// 其中一个是内建的 `append`，它返回一个包含了一个
-	// 或者多个新值的 slice。注意由于 `append` 可能返回
-	// 新的 slice，我们需要接受其返回值。
+	// 除了基本操作外，slice 支持比数组更丰富的操作。比如 slice 支持内建函数 `append`，
+	// 该函数会返回一个包含了一个或者多个新值的 slice。
+	// 注意由于 `append` 可能返回一个新的 slice，我们需要接收其返回值。
 	s = append(s, "d")
 	s = append(s, "e", "f")
 	fmt.Println("apd:", s)
 
-	// Slice 也可以被 `copy`。这里我们创建一个空的和 `s` 有
-	// 相同长度的 slice `c`，并且将 `s` 复制给 `c`。
+	// slice 还可以 `copy`。这里我们创建一个空的和 `s` 有相同长度的 slice——`c`，
+	// 然后将 `s` 复制给 `c`。
 	c := make([]string, len(s))
 	copy(c, s)
 	fmt.Println("cpy:", c)
 
-	// Slice 支持通过 `slice[low:high]` 语法进行“切片”操
-	// 作。例如，这里得到一个包含元素 `s[2]`, `s[3]`,
-	// `s[4]` 的 slice。
+	// slice 支持通过 `slice[low:high]` 语法进行“切片”操作。
+	// 例如，右边的操作可以得到一个包含元素 `s[2]`、`s[3]` 和 `s[4]` 的 slice。
 	l := s[2:5]
 	fmt.Println("sl1:", l)
 
-	// 这个 slice 从 `s[0]` 切片到 `s[5]`（不包含）。
+	// 这个 slice 包含从 `s[0]` 到 `s[5]`（不包含 5）的元素。
 	l = s[:5]
 	fmt.Println("sl2:", l)
 
-	// 这个 slice 从 `s[2]` （包含）开始切片。
+	// 这个 slice 包含从 `s[2]`（包含 2）之后的元素。
 	l = s[2:]
 	fmt.Println("sl3:", l)
 
 	// 我们可以在一行代码中声明并初始化一个 slice 变量。
 	t := []string{"g", "h", "i"}
 	fmt.Println("dcl:", t)
 
-	// Slice 可以组成多维数据结构。内部的 slice 长度可以不
-	// 一致，这和多维数组不同。
+	// Slice 可以组成多维数据结构。内部的 slice 长度可以不一致，这一点和多维数组不同。
 	twoD := make([][]int, 3)
 	for i := 0; i < 3; i++ {
 		innerLen := i + 1

examples/slices/slices.sh

@@ -1,5 +1,4 @@
-# 注意，slice 和数组是不同的类型，但是它们通过 `fmt.Println` 打印
-# 结果类似。
+# 注意，slice 和数组是不同的类型，但它们通过 `fmt.Println` 打印的输出结果是类似的。
 $ go run slices.go
 emp: [  ]
 set: [a b c]
@@ -13,8 +12,6 @@ sl3: [c d e f]
 dcl: [g h i]
 2d:  [[0] [1 2] [2 3 4]]
 
-# 看看这个由 Go 团队撰写的一篇[很棒的博文](http://blog.golang.org/2011/01/go-slices-usage-and-internals.html)，
-# 了解更多关于 Go 中 slice 的设计和实现细节。
+# 看看这个由 Go 团队撰写的一篇[很棒的博文](http://blog.golang.org/2011/01/go-slices-usage-and-internals.html)，了解更多关于 Go 中 slice 的设计和实现细节。
 
-# 现在，我们学习了数组和 slice，接下来我们将学习
-# Go 中的另一个关键的内建数据类型：map。
+# 现在，我们已经学习了数组和 slice，接下来我们将学习 Go 中的另一个重要的内建数据类型：map。

examples/switch/switch.go

@@ -19,18 +19,17 @@ func main() {
 		fmt.Println("three")
 	}
 
-	// 在同一个 `case` 语句中，你可以使用逗号来分隔多个表
-	// 达式。在这个例子中，我们还使用了可选的
-	// `default` 分支。
+	// 在同一个 `case` 语句中，你可以使用逗号来分隔多个表达式。
+	// 在这个例子中，我们还使用了可选的 `default` 分支。
 	switch time.Now().Weekday() {
 	case time.Saturday, time.Sunday:
 		fmt.Println("It's the weekend")
 	default:
 		fmt.Println("It's a weekday")
 	}
 
-	// 不带表达式的 `switch` 是实现 if/else 逻辑的另一种
-	// 方式。这里还展示了 `case` 表达式也可以不使用常量。
+	// 不带表达式的 `switch` 是实现 if/else 逻辑的另一种方式。
+	// 这里还展示了 `case` 表达式也可以不使用常量。
 	t := time.Now()
 	switch {
 	case t.Hour() < 12:
@@ -39,8 +38,8 @@ func main() {
 		fmt.Println("It's after noon")
 	}
 
-	// 类型开关 (`type switch`) 比较类型而非值。可以用来发现一个接口值的
-	// 类型。在这个例子中，变量 `t` 在每个分支中会有相应的类型。
+	// 类型开关 (`type switch`) 比较类型而非值。可以用来发现一个接口值的类型。
+	// 在这个例子中，变量 `t` 在每个分支中会有相应的类型。
 	whatAmI := func(i interface{}) {
 		switch t := i.(type) {
 		case bool:

examples/values/values.go

@@ -1,5 +1,5 @@
-// Go 拥有多种值类型，包括字符串，整型，浮点型，布尔
-// 型等。下面是一些基本的例子。
+// Go 拥有多种值类型，包括字符串、整型、浮点型、布尔型等。
+// 下面是一些基础的例子。
 
 package main