EffectiveGo-2-控制结构、函数

Parts of Effective Go

控制结构

if

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// simple if
if x > 0 {
return y
}
// 带初始化参数的 if
if err := file:Chmod(0661); err := nil {
log.Print(err)
return err
}
// 1.当 if 语句不会执行下一条语句
// 2.当 if 的执行体以 break OR continue OR goto OR return 结束 (例如:防御式编程,错误时 return)
// 不必要的 else 会被省略
f, err := os.Open(name)
if err != nil {
return err
}
doSomething(f)

重新声明与再次赋值

1
2
3
4
5
6
7
// err 被声明
f, err := os:Open(name)
if err != nil {
return err
}
// err 被重新声明并再次赋值
d, err := f.Stat()

上述处理方法是合法的
尽管在两次初始化声明中都存在了err变量
满足以下三个条件,已被声明的变量x可以再次出现在:=声明中

  • 本次声明与已声明的x处于同一作用域(若x已在外层作用域中声明过,则本次声明会创建一个新的变量)
  • 在初始化时,与其类型相同的值才能赋予x
  • 在本次声明中至少另有一个变量是新声明的

函数的形参和返回值在词法上处于大括号以外,但它们的作用域与该函数体仍然相同。

for

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Go的for循环有三种形式
// 只有一种需要分号
// 1.Like a C for
for init; condition; post {
do()
}
// 2.Like a C while
for condition {
do()
}
// 3.Like a C for(;;)
for {
do()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 若想遍历
// 数组/切片/字符串/映射/从信道中读取
// range
for key, value := range old {}
for key := range old {}
for _, value := range old {} // 空白标识符
// 对于字符串
// range能解析UTF-8
// 分离每个独立的Unicode码点
// 错误的编码将占用一个字节
// 并以 U+FFFD 代替
for pos, char := range "日本\x80語" { // \x80是非法的UTF-8编码
fmt.Printf("character %#U starts at byte position %d\n", char, pos)
}
// character U+65E5 '日' starts at byte position 0
// character U+672C '本' starts at byte position 3
// character U+FFFD '�' starts at byte position 6
// character U+8A9E '語' starts at byte position 7

Go has no comma operator and ++ and -- are statements not expressions
Go中没有逗号操作符,而++--是语句而非表达式

1
2
3
4
5
6
7
// 若想在for中使用多个变量
// 应采用平行赋值(parallel assignment)的方式
// 因为它会拒绝 ++ 和 --
// Reverse a
for i, j := 0, len(a)-1; i < j; i, j = i+1, j+1 {
a[i], a[j] = a[j], a[i]
}

switch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// case语句会自上而下逐一求值直到匹配为止
// 若swich后没有表达式,它将匹配true
func unhex(c byte) byte {
switch {
case '0' <= c && c <= '9':
return c - '0'
case 'a' <= c && c <= 'f':
return c - 'a' + 10
case 'A' <= c && c <= 'F':
return c - 'A' + 10
}
return 0
}
// switch并不会自动下溯
// 但case可通过逗号分隔来列举相同的处理条件
func shouldEscape(c byte) bool {
switch c {
case ' ', '?', '&', '=', '+', '%':
return true
}
return false
}
// break终止switch
Loop:
for n := 0; n < len(src); n += size {
switch {
case src[n] < sizeOne:
if validateOnly {
break // 跳出switch
}
size = 1
update(src[n])
case src[n] < sizeTwo:
if n+1 >= len(src) {
err = errShortInput
break Loop // 跳到标签Loop处 breaking label
}
if validateOnly {
break // 跳出switch
}
size = 2
update(scr[n] + src[n+1]<<shift)
}
}
// continue语句也可以使用一个可选的标签
// 不过continue只能在循环中使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Compare 按字典顺序比较两个字节切片并返回一个整数。
// 若 a == b,则结果为零;若 a < b;则结果为 -1;若 a > b,则结果为 +1。
func Compare(a, b []byte) int {
for i := 0; i < len(a) && i < len(b); i++ {
switch {
case a[i] > b[i]:
return 1
case a[i] < b[i]:
return -1
}
}
switch {
case len(a) > len(b):
return 1
case len(a) < len(b):
return -1
}
return 0
}

类型选择

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main
import "fmt"
func main() {
var t interface{}
t = functionOfSomeType()
switch t := t.(type) {
default:
fmt.Printf("unexpected type %T", t) // %T 输出 t 是什么类型
case bool:
fmt.Printf("boolean %t\n", t) // t 是 bool 类型
case int:
fmt.Printf("integer %d\n", t) // t 是 int 类型
case *bool:
fmt.Printf("pointer to boolean %t\n", *t) // t 是 *bool 类型
case *int:
fmt.Printf("pointer to integer %d\n", *t) // t 是 *int 类型
}
}
func functionOfSomeType() int {
return 1
}

函数

多值返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 从字节数组中的特定位置获取其值,并返回该数值和下一个位置
func nextInt(b []byte, i int) (int, int) {
for ; i < len(b) && !isDigit(b[i]); i++ {
}
x := 0
for ; i < len(b) && !isDigit(b[i]); i++ {
x = x*10 + int(b[i]) - '0'
}
return x, i
}
// 通过扫描输入的切片b来获取数字
func main() {
for i := 0; i < len(b); {
x, i := nextInt(b, i)
fmt.Println(x)
}
}

可命名结果形参

1
2
3
4
5
6
func nextInt(b []byte, pos int) (value, nextPos int) {}
// 返回值被命名后,一旦该函数开始执行
// value nextPos会被初始化为与其类型相对应的零值
// 若该函数执行了一条不带实参的return
// 则结果形参的当前值将被返回
// 命名结果形参能使代码更加简短清晰

defer

defer语句用于预设一个函数调用,该函数会在执行defer的函数返回之前立即执行。
被推迟函数的实参在推迟执行时就会求值(defer时),而不是在调用执行时才求值。
被推迟的函数按照后进先出(LIFO)的顺序执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Contents 将文件的内容作为字符串返回。
func Contents(filename string) (string, error) {
f, err := os.Open(filename)
if err != nil {
return "", err
}
defer f.Close() // f.Close 会在我们结束后运行。
var result []byte
buf := make([]byte, 100)
for {
n, err := f.Read(buf[0:])
result = append(result, buf[0:n]...) // append 将在后面讨论。
if err != nil {
if err == io.EOF {
break
}
return "", err // 我们在这里返回后,f 就会被关闭。
}
}
return string(result), nil // 我们在这里返回后,f 就会被关闭。
}