msb-public
/
golang-tutorial
mirror of https://github.com/Tinywan/golang-tutorial.git
1
0
Code Issues Projects Releases Wiki Activity

数组和切片

Browse Source
pull/5/head
wanshaobo 7 years ago
parent e20f26b3c8
commit 015e2f5f0c
3 changed files with 177 additions and 206 deletions
Show Stats Download Patch File Download Diff File

2
README.md
Unescape View File

@ -29,7 +29,7 @@ $ go get github.com/Tinywan/golang-tutorial
## 第5章 数组、切片和变参函数
### 11 - 数组和切片
### [11 - 数组和切片](/docs/golang_tutorial_11.md)
### 12 - 变参函数
## 第6章 更多的类型

205
docs/golang_tutorial_09 - 副本 - 副本.md
Unescape View File

@ -1,205 +0,0 @@
9 - 循环语句
========================
上一节：[第八篇 if else 语句](/docs/golang_tutorial_08.md)
下一节：[第十篇 包](/docs/golang_tutorial_10.md)
这是本Golang系列教程的第9篇。
循环语句用于重复执行一段代码。
for 语句是 Go 中唯一的循环语句。Go 没有提供其他语言（如 C）中的 while 和 do while 语句。
## for 语句语法
for 语句的语法如下：
```golang
for initialisation; condition; post {
}
```
其中， `initialisation` 为初始化语句，该语句仅执行一次。`initialisation` 语句结束后，接着对 `condition` 求值，如果 `condition` 求值结果为 `true`，则执行大括号` {} `里面的循环体，然后执行 post 语句，如果 `condition` 求值结果为 false 则退出循环。`post` 语句会在每次循环体执行结束后执行。执行完 `post` 语句之后，`condition` 会被重新求值，如果是`true`，则继续执行循环体，否则退出循环。
## 例子
下面的程序使用 for 循环打印 1 到 10 之间的整数。
```golang
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 10; i++ {
fmt.Printf(" %d",i)
}
}
```
在上面的程序中，`i` 被初始化为 `1`。条件语句判断` i `是否小于等于 `10`，如果是则打印 `i`，否则结束循环。`post` 语句在每次迭代结束时将 `i`递增 `1`。直到`i`的值大于 `10` 循环结束。
上面的程序打印：`1 2 3 4 5 6 7 8 9 10`
在 `for` 头部定义的变量仅在 `for` 语句范围内可见，因此 `i `不能在 `for` 循环体外被访问。
## break
`break` 语句用于终止 `for` 循环，继续执行 `for` 循环后面的语句。
下面的程序打印 1 到 5 之间的整数。请注意该程序中 `break` 的用法。
```golang
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 10; i++ {
if i > 5 {
break //loop is terminated if i > 5
}
fmt.Printf("%d ", i)
}
fmt.Printf("\nline after for loop")
}
```
在上面的程序中，每次迭代都会检查`i`的值，如果`i`大于 5 则执行 `break` 语句跳出循环，并执行 for 循环后面的那条 fmt.Printf 语句。上面的程序输出如下：
```golang
1 2 3 4 5
line after for loop
```
## continue
`continue` 语句用于跳过 `for` 循环的当前迭代。循环体中`continue`语句之后的所有语句将被跳过不予执行。循环将继续执行下一次迭代。
让我们写一个程序利用 `continue` 来打印 `1` 到 `10` 之间的奇数。
```golang
package main
import (
"fmt"
)
func main() {
for i := 1; i <= 10; i++ {
if i%2 == 0 {
continue
}
fmt.Printf("%d ", i)
}
}
```
在上面的程序中，`if i%2 == 0`检测 `i` 除以 `2` 的余数是否为 `0`，如果为 `0` 则 `i` 是偶数，利用 `continue` 语句跳过当前迭代并继续下一次迭代。因此 `continue` 语句之后的 `fmt.Printf` 语句将不被执行，并且循环进入到下一次迭代。上面的程序输出为：`1 3 5 7 9`。
## 更多例子
让我们再写一些代码来演示 for 循环的其它变体。
下面的程序 打印 0 到 10 之间的所有偶数。
```golang
package main
import (
"fmt"
)
func main() {
i := 0
for ;i <= 10; { // initialisation and post are omitted
fmt.Printf("%d ", i)
i += 2
}
}
```
我们已经知道 `for` 循环头部的三个部分`initialisation`，`condition`，`post` 都是可选的。上面的程序中，忽略了 `initialisation` 和 `post` 部分。`i` 在 `for` 循环之外初始化为 `0`，只要`i <= 10` 循环就一直执行，`i` 在循环体内每次递增 `2`。上面的程序输出为：`0 2 4 6 8 10`。
上面程序中的分号（`;`）也可以省略。这种形式的 `for` 循环可以视为 `while` 循环的替代品。上面的程序可以被重写如下：
```golang
package main
import (
"fmt"
)
func main() {
i := 0
for i <= 10 { //semicolons are ommitted and only condition is present
fmt.Printf("%d ", i)
i += 2
}
}
```
可以在 `for` 循环中声明和操作多个变量，比如下面的程序：
```golang
package main
import (
"fmt"
)
func main() {
for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { //multiple initialisation and increment
fmt.Printf("%d * %d = %d\n", no, i, no*i)
}
}
```
上面的程序中，`no` 和` i `被声明并初始化为 `10` 和 `1`。它们在每次迭代结束时递增 `1`。在 `condition` 部分使用 `&&` 操作符来确保 `i` 小于或等于 `10` 并且 `no` 小于或等于 `19`。程序的输出如下：
```golang
10 * 1 = 10
11 * 2 = 22
12 * 3 = 36
13 * 4 = 52
14 * 5 = 70
15 * 6 = 90
16 * 7 = 112
17 * 8 = 136
18 * 9 = 162
19 * 10 = 190
```
## 无限循环
可以用下面的语法实现无限循环：
```golang
for {
}
```
下面的程序将一直打印` Hello World `永不终止。
```golang
package main
import "fmt"
func main() {
for {
fmt.Println("Hello World")
}
}
```
如果你在 [go playground ](https://play.golang.org/p/kYQZw1AWT4)执行上面的程序，你将得到一个错误：`process took too long`。请尝试在本地系统中运行它以无限打印`"Hello World"`。
还有一个` range for `可用于遍历数组，我们将在介绍数组时介绍它。
希望你喜欢阅读。请留下宝贵的意见和反馈:)

176
docs/golang_tutorial_11.md
Unescape View File

@ -0,0 +1,176 @@
11 - 数组和切片
========================
上一节：[第十篇 if else 语句](/docs/golang_tutorial_10.md)
下一节：[第十二篇 包](/docs/golang_tutorial_12.md)
这是本Golang系列教程的第11篇。
## 数组
数组是类型相同的元素的集合。例如，整数 5, 8, 9, 79, 76 的集合就构成了一个数组。Go不允许在数组中混合使用不同类型的元素（比如整数和字符串）。
## 申明
数组的类型为` n[T]`，其中 `n` 表示数组中元素的个数，`T` 表示数组中元素的类型。元素的个数 `n`也是数组类型的一部分（我们将在稍后详细讨论）。
有很多声明数组的方式，让我们一个一个地介绍。
```golang
package main
import (
"fmt"
)
func main() {
var a [3]int //int array with length 3
fmt.Println(a)
}
```
`var a [3]int `声明了一个长度为 3 的整型数组。数组中的所有元素都被自动赋值为元素类型的 0 值。比如这里 a 是一个整型数组，因此 a 中的所有元素都被赋值为 0（即整型的 0 值）。运行上面的程序，输出为：`[0 0 0]`。
数组的索引从 0 开始到 `length - 1` 结束。下面让我们给上面的数组赋一些值。
```golang
package main
import (
"fmt"
)
func main() {
var a [3]int //int array with length 3
a[0] = 12 // array index starts at 0
a[1] = 78
a[2] = 50
fmt.Println(a)
}
```
`a[0]`表示数组中的第一个元素。程序的输出为：`[12 78 50]`。
（译者注：可以用下标运算符（`[]`）来访问数组中的元素，下标从 0 开始，例如 `a[0]` 表示数组 a 的第一个元素，`a[1] `表示数组 a 的第二元素，以此类推。）
可以利用**速记声明（shorthand declaration）**的方式来创建同样的数组：
```golang
package main
import (
"fmt"
)
func main() {
a := [3]int{12, 78, 50} // shorthand declaration to create array
fmt.Println(a)
}
```
上面的程序输出为：`[12 78 50]`。
（译者注：这个例子给出了速记声明的方式：在数组类型后面加一对大括号（`{}`），在大括号里面写元素初始值列表，多个值用逗号分隔。）
在速记声明中，没有必要为数组中的每一个元素指定初始值。
```golang
package main
import (
"fmt"
)
func main() {
a := [3]int{12}
fmt.Println(a)
}
```
上面程序的第 8 行：`a := [3]int{12} `声明了一个长度为 3 的数组，但是只提供了一个初值 12。剩下的两个元素被自动赋值为 0。程序 的输出为：`[12 0 0]`。
在声明数组时你可以忽略数组的长度并用` ... `代替，让编译器为你自动推导数组的长度。比如下面的程序：
```golang
package main
import (
"fmt"
)
func main() {
a := [...]int{12, 78, 50} // ... makes the compiler determine the length
fmt.Println(a)
}
```
上面已经提到，数组的长度是数组类型的一部分。因此 `[5]int` 和 `[25]int`是两个不同类型的数组。正是因为如此，一个数组不能动态改变长度。不要担心这个限制，因为切片（`slices`）可以弥补这个不足。
```golang
package main
func main() {
a := [3]int{5, 78, 8}
var b [5]int
b = a //not possible since [3]int and [5]int are distinct types
}
```
在上面程序的第 6 行，我们试图将一个` [3]int `类型的数组赋值给一个 `[5]int `类型的数组，这是不允许的。编译会报错：`main.go:6: cannot use a (type [3]int) as type [5]int in assignment。`
## 数组是值类型
在 Go 中数组是值类型而不是引用类型。这意味着当数组变量被赋值时，将会获得原数组（*译者注：也就是等号右面的数组*）的拷贝。新数组中元素的改变不会影响原数组中元素的值。
```golang
package main
import "fmt"
func main() {
a := [...]string{"USA", "China", "India", "Germany", "France"}
b := a // a copy of a is assigned to b
b[0] = "Singapore"
fmt.Println("a is ", a)
fmt.Println("b is ", b)
}
```
上面程序的第 7 行，将数组 a 的拷贝赋值给数组 b。第 8 行，b 的第一个元素被赋值为 `Singapore`。这将不会影响到原数组 a。程序的输出为：
```golang
a is [USA China India Germany France]
b is [Singapore China India Germany France]
```
同样的，如果将数组作为参数传递给函数，仍然是值传递，在函数中对（作为参数传入的）数组的修改不会造成原数组的改变。
```golang
package main
import "fmt"
func changeLocal(num [5]int) {
num[0] = 55
fmt.Println("inside function ", num)
}
func main() {
num := [...]int{5, 6, 7, 8, 8}
fmt.Println("before passing to function ", num)
changeLocal(num) //num is passed by value
fmt.Println("after passing to function ", num)
}
```
上面程序的第 13 行，数组 num 是通过值传递的方式传递给函数 `changeLocal` 的，因此该函数执行过程中不会造成 num 的改变。程序输出如下：
```golang
before passing to function [5 6 7 8 8]
inside function [55 6 7 8 8]
after passing to function [5 6 7 8 8]
```
## 数组的长度
希望你喜欢阅读。请留下宝贵的意见和反馈:)
Write Preview
Loading…
Cancel
Save