初识Go(3)

函数是 Go 里面的核心设计，它通过关键字 func 来声明，它的格式如下：

func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {

//这里是处理逻辑代码

//返回多个值

return value1, value2

}

上面的代码我们看出

• 关键字 func 用来声明一个函数 funcName

• 函数可以有一个或者多个参数，每个参数后面带有类型，通过,分隔

• 函数可以返回多个值

• 上面返回值声明了两个变量 output1 和 output2，如果你不想声明也可以，直接就

两个类型

• 如果只有一个返回值且不声明返回值变量，那么你可以省略 包括返回值 的括号

• 如果没有返回值，那么就直接省略最后的返回信息

• 如果有返回值， 那么必须在函数的外层添加 return 语句



func max(a, b int) int {

	if a > b {

		return a

	}

		return b

}



如果你的函数是导出的(首字母大写)，官方建议：最好命名返回值，因为不命名返回值，

虽然使得代码更加简洁了，但是会造成生成的文档可读性差。

func SumAndProduct(A, B int) (add int, Multiplied int) {

add = A+B

Multiplied = A*B

return

}



变 参

Go 函数支持变参。 接受变参的函数是有着不定数量的参数的。为了做到这点，首先需要定义

函数使其接受变参：

func myfunc(arg ...int) {}

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

体中，变量 arg 是一个 int 的 slice：

for _, n := range arg {

fmt.Printf("And the number is: %d\n", n)

}



指针

当我们传一个参数值到被调用函数里面时，实际上是传了这个值的一份 copy，当在被调用

函数中修改参数值的时候，调用函数中相应实参不会发生任何变化，因为数值变化只作用

在 copy 上。

这就牵扯到了所谓的指针。我们知道，变量在内存中是存放于一定地址上的，修改变量实际

是修改变量地址处的内存。 只有 add1 函数知道 x 变量所在的地址，才能修改 x 变量的值。 所

以我们需要将 x 所在地址&x 传入函数，并将函数的参数的类型由 int 改为*int，即改为指针

类型，才能在函数中修改 x 变量的值。此时参数仍然是按 copy 传递的，只是 copy 的是一个

指针。请看下面的例子

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"

}



这样，我们就达到了修改 x 的目的。那么到底传指针有什么好处呢？

• 传指针使得多个函数能操作同一个对象。

• 传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构

体。如果用参数值传递的话, 在每次 copy 上面就会花费相对较多的系统开销（内存和时

间）。所以当你要传递大的结构体的时候，用指针是一个明智的选择。

• Go 语言中 string，slice，map 这三种类型的实现机制类似指针，所以可以直接传

递，而不用取地址后传递指针。（注：若函数需改变 slice 的长度，则仍需要取地址传递指

针）