Go语言基础之流程和函数

July 05 2018

上一章讲了Go语言基础里的变量、常量、基本类型以及数组等数据结构，这一章来讲讲Go语言里的流程及函数。

流程

每种编程语言中都少不了流程控制，主要分为条件判断和循环控制以及不太常用的跳转。

if 条件判断

Go语言里的if条件不需要括号，例如

1
2
3
4
5
if x > 10 {
  fmt.Println("x is greater than 10.")
} else {
  fmt.Println("x is less than 10.")
}

Go中的if还允许在条件判断语句里进行变量声明，不过声明的变量作用域只存在该条件逻辑块内

1
2
3
4
5
6
7
8
9
//声明并给x赋值
if x:= computedValue(); x > 10 {
  fmt.Println("x is greater than 10.")
} else {
  fmt.Println("x is less than 10.")
}

//这段话会导致编译出错，因为x的作用域只存在于if判断条件
//fmt.Println(x)
goto 跳转

Go语言里的goto关键字支持跳转，但还是少用为好。用goto跳转必须在当前函数内定义标签，且注意标签名大小写

1
2
3
4
5
6
7
func myFunc() {
  	i := 0
Here: 	//Here标签，以冒号结束
	println(i)
	i++
	goto Here	//跳转到Here标签
}
for 循环

for循环的语法如下

1
2
3
for expression1; expression2; expression3 {
  // ...
}

expression1、expression2和expression3都是表达式，其中expression1和expression3是变量声明或者函数调用返回值之类的，expression2是用来条件判断，expression1在循环开始之前调用，expression3在每轮循环结束之时调用。

举个例子

1
2
3
4
5
sum := 0
for index := 0; index < 10; index++ {
  sum += index
}
fmt.Println("sum is equal to ", sum)

有时候，我们可以省略expression1和expression3，甚至连;也可以省略，看上去结构就像while循环一样

1
2
3
4
sum := 1
for sum < 1000 {
  sum += sum
}

跳出循环和大部分语言一样，使用break以及continue关键字，逻辑都是一样的。

for可以配合range来读取slice和map等数据结构

1
2
3
4
for k, v := range map {
  fmt.Println("map's key = ", k)
  fmt.Println("map's value = ", v)
}

由于Go支持多值返回，对于声明但未调用的变量，编译器会给出报错，这种情况下，可以使用_来丢弃不需要的返回值

1
2
3
for _, v := range map {
  fmt.Println("map's value = ", v)
}
switch 条件判断

switch的语法如下

1
2
3
4
5
6
7
8
9
10
switch sExpr {
case expr1:
	some instructions
case expr2:
	some other instructions
case expr3:
	some other instructions
default:
	other code
}

Go里面switch默认相当于每个case最后带有break，这和其它语言有点不同，其它语言在case条件下都需要加break关键字来跳出条件判断，但Go不需要。如果在case条件中加fallthrough关键字，会强制执行后面的case判断，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
integer := 6
switch integer {
case 4:
	fmt.Println("The integer was <= 4")
	fallthrough
case 5:
	fmt.Println("The integer was <= 5")
	fallthrough
case 6:
	fmt.Println("The integer was <= 6")
	fallthrough
case 7:
	fmt.Println("The integer was <= 7")
	fallthrough
case 8:
	fmt.Println("The integer was <= 8")
	fallthrough
default:
	fmt.Println("default case")
}

上面的程序将输出

1
2
3
4
The integer was <= 6
The integer was <= 7
The integer was <= 8
default case

函数

函数是Go语言里的核心，它通过func关键字来声明，格式如下

1
2
3
func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
  return value1, value2
}

上面的代码我们看出

  • 关键字func用来声明一个函数funcName
  • 函数可以有一个或者多个参数，每个参数后面带有类型，通过,分隔
  • 函数可以返回多个值
  • 上面返回值声明了两个变量output1和output2，如果你不想声明也可以，直接就两个类型
  • 如果只有一个返回值且不声明返回值变量，那么你可以省略 包括返回值 的括号
  • 如果没有返回值，那么就直接省略最后的返回信息
  • 如果有返回值， 那么必须在函数的外层添加return语句
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"

// 返回a、b中最大值.
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	x := 3
	y := 4
	z := 5

	max_xy := max(x, y) //调用函数max(x, y)
	max_xz := max(x, z) //调用函数max(x, z)

	fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
	fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
	fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // 也可在这直接调用它
}

上面这个里面我们可以看到max函数有两个参数，它们的类型都是int，那么第一个变量的类型可以省略（即 a,b int,而非 a int, b int)，默认为离它最近的类型，同理多于2个同类型的变量或者返回值。同时我们注意到它的返回值就是一个类型，这个就是省略写法。

多个返回值

Go语言相比于一般的语言，其中的一个特色在于，Go支持函数返回多个值。其它语言可能要借助其它的手段，但Go语言天然支持

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import "fmt"

//返回 A+B 和 A*B
func SumAndProduct(A, B int) (int, int) {
	return A+B, A*B
}

func main() {
	x := 3
	y := 4

	xPLUSy, xTIMESy := SumAndProduct(x, y)

	fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
	fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
}

上面的例子我们可以看到直接返回了两个参数，当然我们也可以命名返回参数的变量，这个例子里面只是用了两个类型，我们也可以改成如下这样的定义，然后返回的时候不用带上变量名，因为直接在函数里面初始化了。但如果你的函数是导出的(首字母大写)，官方建议：最好命名返回值，因为不命名返回值，虽然使得代码更加简洁了，但是会造成生成的文档可读性差。

1
2
3
4
5
func SumAndProduct(A, B int) (add int, Multiplied int) {
	add = A+B
	Multiplied = A*B
	return
}
变参

变参的格式如下

1
func myfunc(arg ...int) {}

arg ...int告诉Go这个函数接受不定数量的参数。注意，这些参数的类型全部是int。在函数体中，变量arg是一个int的slice：

1
2
3
for _, n := range arg {
	fmt.Printf("And the number is: %d\n", n)
}
传值与传指针

当我们传一个参数值到被调用函数里面时，实际上是传了这个值的一份copy，当在被调用函数中修改参数值的时候，调用函数中相应实参不会发生任何变化，因为数值变化只作用在copy上。举个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

//简单的一个函数，实现了参数+1的操作
func add1(a int) int {
	a = a+1 // 我们改变了a的值
	return a //返回一个新值
}

func main() {
	x := 3

	fmt.Println("x = ", x)  // 应该输出 "x = 3"

	x1 := add1(x)  //调用add1(x)

	fmt.Println("x+1 = ", x1) // 应该输出"x+1 = 4"
	fmt.Println("x = ", x)    // 应该输出"x = 3"
}

那如果想要将上一个例子中的参数传指针过去该怎么办呢？很简单，将函数参数int改为*int，即指针类型即可。还是上面的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

//简单的一个函数，实现了参数+1的操作
func add1(a *int) int { // 请注意，
	*a = *a+1 // 修改了a的值
	return *a // 返回新值
}

func main() {
	x := 3

	fmt.Println("x = ", x)  // 应该输出 "x = 3"

	x1 := add1(&x)  // 调用 add1(&x) 传x的地址

	fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
	fmt.Println("x = ", x)    // 应该输出 "x = 4"
}

可以看到，运算符&是用来取地址，而*是用来解析地址的。*type代表变量是指针类型。

有些场景下，传指针比传值更好，原因如下：

  • 传指针使得多个函数能操作同一个对象。
  • 传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构体。如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销（内存和时间）。所以当你要传递大的结构体的时候，用指针是一个明智的选择。
  • Go语言中channel，slice，map这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数需改变slice的长度，则仍需要取地址传递指针）
defer关键字

Go语言中支持一种延迟语句，由defer关键字声明。你可以在函数中添加多个defer语句，当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回。举个例子

1
2
3
4
5
6
7
8
9
10
11
func ReadWrite() bool {
	file.Open("file")
	defer file.Close()
	if failureX {
		return false
	}
	if failureY {
		return false
	}
	return true
}

上面这段代码在执行到defer语句时，不会立马执行，而是继续执行下面的代码，在执行到return之前，才执行file.Close()，最后再执行return语句。

在使用defer后，不但代码量减少了很多，而且程序变得更优雅。在defer后指定的函数会在函数退出前调用。

如果有很多调用defer，那么defer是采用后进先出模式，所以如下代码会输出4 3 2 1 0

1
2
3
for i := 0; i < 5; i++ {
	defer fmt.Printf("%d ", i)
}
函数作为值、类型

在Go中函数也是一种变量，我们可以通过type来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型

1
type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...])

函数作为类型到底有什么好处呢？那就是可以把这个类型的函数当做值来传递，请看下面的例子

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
package main

import "fmt"

type testInt func(int) bool // 声明了一个函数类型

func isOdd(integer int) bool {
	if integer%2 == 0 {
		return false
	}
	return true
}

func isEven(integer int) bool {
	if integer%2 == 0 {
		return true
	}
	return false
}

// 声明的函数类型在这个地方当做了一个参数

func filter(slice []int, f testInt) []int {
	var result []int
	for _, value := range slice {
		if f(value) {
			result = append(result, value)
		}
	}
	return result
}

func main(){
	slice := []int {1, 2, 3, 4, 5, 7}
	fmt.Println("slice = ", slice)
	odd := filter(slice, isOdd)    // 函数当做值来传递了
	fmt.Println("Odd elements of slice are: ", odd)
	even := filter(slice, isEven)  // 函数当做值来传递了
	fmt.Println("Even elements of slice are: ", even)
}

函数当做值和类型在我们写一些通用接口的时候非常有用，通过上面例子我们看到testInt这个类型是一个函数类型，然后两个filter函数的参数和返回值与testInt类型是一样的，但是我们可以实现很多种的逻辑，这样使得我们的程序变得非常的灵活。

main函数和init函数

Go里面有两个保留的函数：init函数（能够应用于所有的package）和main函数（只能应用于package main）。这两个函数在定义时不能有任何的参数和返回值。虽然一个package里面可以写任意多个init函数，但这无论是对于可读性还是以后的可维护性来说，我们都强烈建议用户在一个package中每个文件只写一个init函数。

Go程序会自动调用init()和main()，所以你不需要在任何地方调用这两个函数。每个package中的init函数都是可选的，但package main就必须包含一个main函数。

程序的初始化和执行都起始于main包。如果main包还导入了其它的包，那么就会在编译时将它们依次导入。有时一个包会被多个包同时导入，那么它只会被导入一次（例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次）。当一个包被导入时，如果该包还导入了其它的包，那么会先将其它包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行init函数（如果有的话），依次类推。等所有被导入的包都加载完毕了，就会开始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数。

下图详细地解释了整个执行过程：

import

我们在写Go代码的时候经常用到import这个命令用来导入包文件，而我们经常看到的方式参考如下：

1
2
3
import(
    "fmt"
)

然后我们代码里面可以通过如下的方式调用

1
fmt.Println("hello world")

上面这个fmt是Go语言的标准库，其实是去GOROOT环境变量指定目录下去加载该模块，当然Go的import还支持如下两种方式来加载自己写的模块：

  1. 相对路径

import “./model” //当前文件同一目录的model目录，但是不建议这种方式来import

  1. 绝对路径

import “shorturl/model” //加载gopath/src/shorturl/model模块

上面展示了一些import常用的几种方式，但是还有一些特殊的import，让很多新手很费解，下面我们来一一讲解一下到底是怎么一回事

  1. 点操作

我们有时候会看到如下的方式导入包

1
2
3
import(
	. "fmt"
)

这个点操作的含义就是这个包导入之后在你调用这个包的函数时，你可以省略前缀的包名，也就是前面你调用的fmt.Println(“hello world”)可以省略的写成Println(“hello world”)

  1. 别名操作

别名操作顾名思义我们可以把包命名成另一个我们用起来容易记忆的名字

别名操作的话调用包函数时前缀变成了我们的前缀，即f.Println(“hello world”)

  1. _操作

这个操作经常是让很多人费解的一个操作符，请看下面这个import

1
2
3
4
import (
	"database/sql"
	_ "github.com/ziutek/mymysql/godrv"
)

_操作其实是引入该包，而不直接使用包里面的函数，而是调用了该包里面的init函数。

——————分割线——————

以下这部分是我目前还看不懂，但还是记录下来的

Panic和Recover

Go没有像Java那样的异常机制，它不能抛出异常，而是使用了panic和recover机制。一定要记住，你应当把它作为最后的手段来使用，也就是说，你的代码中应当没有，或者很少有panic的东西。这是个强大的工具，请明智地使用它。那么，我们应该如何使用它呢？

Panic

是一个内建函数，可以中断原有的控制流程，进入一个令人恐慌的流程中。当函数F调用panic，函数F的执行被中断，但是F中的延迟函数会正常执行，然后F返回到调用它的地方。在调用的地方，F的行为就像调用了panic。这一过程继续向上，直到发生panic的goroutine中所有调用的函数返回，此时程序退出。恐慌可以直接调用panic产生。也可以由运行时错误产生，例如访问越界的数组。

Recover

是一个内建的函数，可以让进入令人恐慌的流程中的goroutine恢复过来。recover仅在延迟函数中有效。在正常的执行过程中，调用recover会返回nil，并且没有其它任何效果。如果当前的goroutine陷入恐慌，调用recover可以捕获到panic的输入值，并且恢复正常的执行。

下面这个函数演示了如何在过程中使用panic

1
2
3
4
5
6
7
var user = os.Getenv("USER")

func init() {
	if user == "" {
		panic("no value for $USER")
	}
}

下面这个函数检查作为其参数的函数在执行时是否会产生panic：

1
2
3
4
5
6
7
8
9
func throwsPanic(f func()) (b bool) {
	defer func() {
		if x := recover(); x != nil {
			b = true
		}
	}()
	f() //执行函数f，如果f中出现了panic，那么就可以恢复回来
	return
}

总结

函数是Go语言中的核心设计，对于函数的掌握也就是对Go语言基础的掌握之一。

avatar

chilihotpot

You Are The JavaScript In My HTML