Go语言学习笔记(四)------函数

一、介绍

1.除了main()、init()函数外，其它所有类型的函数都可以有参数与返回值。函数参数、返回值以及它们的类型被统称为函数签名。函数重载（function overloading）指的是可以编写多个同名函数，只要它们拥有不同的形参与/或者不同的返回值，在 Go里面函数重载是不被允许的，这将导致一个编译错误。函数可以将其他函数调用作为它的参数，只要这个被调用函数的返回值个数、返回值类型和返回值的顺序与调用函数所需求的实参是一致的，例如：
假设 f1 需要 3 个参数 f1(a, b, c int) ，同时 f2 返回 3 个参数 f2(a, b int) (int, int, int) ，就可以这样调用f1： f1(f2(a, b)) 。

2.如果需要申明一个在外部定义的函数，你只需要给出函数名与函数签名，不需要给出函数体：

func flushICache(begin, end uintptr) //implemented externally

3.函数也可以以申明的方式被使用，作为一个函数类型，就像：

type binOp func(int, int) int

4.目前 Go 没有泛型（generic）的概念，也就是说它不支持那种支持多种类型的函数。不过在大部分情况下可以通过接口
（interface）。

二、 函数参数与返回值

1.函数能够接收参数供自己使用，也可以返回零个或多个值（我们通常把返回多个值称为返回一组值）。函数定义时，它的形参一般是有名字的，不过我们也可以定义没有形参名的函数，只有相应的形参类型，就像这样： func f(int, int, float64) 。没有参数的函数通常被称为 niladic 函数（niladic function），就像 main.main() 。我们通过 return 关键字返回一组值。事实上，任何一个有返回值（单个或多个）的函数都必须以 return 或panic 结尾。在函数块里面， return 之后的语句都不会执行。

2.Go 默认使用按值传递来传递参数，也就是传递参数的副本。函数接收参数副本之后，在使用变量的过程中可能对副本的值进行更改，但不会影响到原来的变量，比如 Function(arg1) 。将参数的地址（变量名前面添加&符号，比如 &variable）传递给函数，这就是按引用传递，比如 Function(&arg1) ，此时传递给函数的是一个指针。如果传递给函数的是一个指针，指针的值（一个地址）会被复制，但指针的值所指向的地址上的值不会被复制；我们可以通过这个指针的值来修改这个值所指向的地址上的值。

3.在函数调用时，像切片（slice）、字典（map）、接口（interface）、通道（channel）这样的引用类型都是默认使用引用传递（即使没有显式的指出指针）。如果一个函数需要返回四到五个值，我们可以传递一个切片给函数（如果返回值具有相同类型）或者是传递一个结构体（如果返回值具有不同的类型）。因为传递一个指针允许直接修改变量的值，消耗也更少。

4.当需要返回多个非命名返回值时，需要使用 () 把它们括起来，比如 (int, int) 。任何一个非命名返回值（使用非命名返回值是很糟的编程习惯）在 return 语句里面都要明确指出包含返回值的变量或是一个可计算的值（就像上面警告所指出的那样）。命名返回值作为结果形参（result parameters）被初始化为相应类型的零值，当需要返回的时候，我们只需要一条简单的不带参数的return语句。需要注意的是，即使只有一个命名返回值，也需要使用 () 括起来。即使函数使用了命名返回值，你依旧可以无视它而返回明确的值。

package main
import "fmt"
var num int = 10
var numx2, numx3 int
func main() {
	numx2, numx3 = getX2AndX3(num)
	PrintValues()
	numx2, numx3 = getX2AndX3_2(num)
	PrintValues()
}
func PrintValues() {
	fmt.Printf("num = %d, 2x num = %d, 3x num = %d\n", num, numx2, numx3)
}
func getX2AndX3(input int) (int, int) { //不推荐这种写法
	return 2 * input, 3 * input
}
func getX2AndX3_2(input int) (x2 int, x3 int) {
	x2 = 2 * input
	x3 = 3 * input
	// return x2, x3
	return 
}

5.空白符用来匹配一些不需要的值，然后丢弃掉。

package main
import "fmt"
func main() {
	var i1 int
	var f1 float32
	i1, _, f1 = ThreeValues()
	fmt.Printf("The int: %d, the float: %f \n", i1, f1)
}
func ThreeValues() (int, int, float32) {
	return 5, 6, 7.5
}

6.传递指针给函数不但可以节省内存（因为没有复制变量的值），而且赋予了函数直接修改外部变量的能力，所以被修改的变量不再需要使用 return 返回。

package main
import (
	"fmt"
)
// this function changes reply:
func Multiply(a, b int, reply *int) {
	*reply = a * b
}
func main() {
	n := 0
	reply := &n
	Multiply(10, 5, reply)
	fmt.Println("Multiply:", *reply) // Multiply: 50
}

三、传递变长参数。

1.如果函数最后一个参数采用 ...type 的形式，那么这个函数就可以处理一个变长的参数，这个长度可以为 0，这样的函数称为变参函数。

func myFunc(a, b, arg ...int) 

2.函数接受一个类似某个类型的 slice 的参数，该参数可以通过 for 循环结构迭代。如果参数被存储在一个 slice 类型的变量 slice 中，则可以通过 slice... 的形式来传递参数，调用变参函数。

package main
import "fmt"
func main() {
	x := min(1, 3, 2, 0) //类似切片[]int{1，3，2，0}
	fmt.Printf("The minimum is: %d\n", x)
	slice := []int{7,9,3,5,1} //如果传入切片，需要slice...调用
	x = min(slice...)
	fmt.Printf("The minimum in the slice is: %d", x)
}
func min(s ...int) int {
	if len(s)==0 {
		return 0
	}
	min := s[0]
	for _, v := range s {
		if v < min {
			min = v
		}
	}
	return min
}

3.一个接受变长参数的函数可以将这个参数作为其它函数的参数进行传递，也就是说变长参数可以作为对应类型的 slice 进行二次传递：

func F1(s ...string) {
F2(s...)
F3(s)
}
func F2(s ...string) { }
func F3(s []string) { }

4.如果变长参数的类型并不是都相同的，可以使用结构或者使用空接口。

四、defer 和追踪

1.关键字 defer 允许我们推迟到函数返回之前（或任意位置执行 return 语句之后）一刻才执行某个语句或函数，它一般用于释放某些已分配的资源。使用 defer 的语句同样可以接受参数，当有多个 defer 行为被注册时，它们会以逆序执行（类似栈，即后进先出），合理使用 defer 语句能够使得代码更加简洁。关闭文件流 、解锁一个加锁的资源 、打印最终报告、关闭数据库链接等操作。
// open a file
defer file.Close()

mu.Lock()
defer mu.Unlock()

printHeader()
defer printFooter()

// open a database connection
defer disconnectFromDB()

package main
import "fmt"
func main() {
	doDBOperations()
}
func connectToDB() {
	fmt.Println("ok, connected to db")
}
func disconnectFromDB() {
	fmt.Println("ok, disconnected from db")
}
func doDBOperations() {
	connectToDB()
	fmt.Println("Defering the database disconnect.")
	defer disconnectFromDB() //function called here with defer
	fmt.Println("Doing some DB operations ...")
	fmt.Println("Oops! some crash or network error ...")
	fmt.Println("Returning from function here!")
	return //terminate the program
	// deferred function executed here just before actually returning, even if
	// there is a return or abnormal termination before
}

2.使用 defer 语句实现代码追踪，一个基础但十分实用的实现代码执行追踪的方案就是在进入和离开某个函数打印相关的消息：

package main
import "fmt"
func trace(s string) string {
	fmt.Println("entering:", s)
	return s
}
func un(s string) {
	fmt.Println("leaving:", s)
}
func a() {
	defer un(trace("a"))
	fmt.Println("in a")
}
func b() {
	defer un(trace("b"))
	fmt.Println("in b")
	a()
}
func main() {
	b()
}

输出：

entering: b
in b
entering: a
in a
leaving: a
leaving: b

3.使用 defer 语句来记录函数的参数与返回值。

package main
import (
"io"
"log"
)
func func1(s string) (n int, err error) {
defer func() {
log.Printf("func1(%q) = %d, %v", s, n, err)
}()
return 7, io.EOF
}
func main() {
func1("Go")
}

五、内置函数

1.Go 语言拥有一些不需要进行导入操作就可以使用的内置函数。它们有时可以针对不同的类型进行操作，例如：len、cap和 append，或必须用于系统级的操作，例如：panic。因此，它们需要直接获得编译器的支持。

2.len 用于返回某个类型的长度或数量（字符串、数组、切片、map 和管道）；cap 是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）；

3.copy和append用于复制和连接切片；

4.panic、recover 两者均用于错误处理机制；

5.print、println 底层打印函数，在部署环境中建议使用 fmt 包；

6.complex、real imag 用于创建和操作复数；

7.close 用于管道通信；

8.new 和 make 均是用于分配内存：new 用于值类型和用户定义的类型，如自定义结构，make 用于内置引用类型（切片、map 和管道），它们的用法就像是函数，但是将类型作为参数：new(type)、make(type)。new(T) 分配类型 T 的零值并返回其地址，也就是指向类型 T 的指针。它也可以被用于基本类型： v := new(int) 。make(T) 返回类型 T 的初始化之后的值，因此它比 new 进行更多的工作，new() 是一个函数，不要忘记它的括号。

六、递归函数

1.当一个函数在其函数体内调用自身，则称之为递归。最经典的例子便是计算斐波那契数列，即前两个数为1，从第三个数开始每个数均为前两个数之和。使用递归函数时经常会遇到的一个重要问题就是栈溢出：一般出现在大量的递归调用导致的程序栈内存分配耗尽。这个问题可以通过一个名为懒惰求值的技术解决，在 Go 语言中，我们可以使用管道（channel）和 goroutine来实现。

package main
import "fmt"
func main() {
	result := 0
	for i := 0; i <= 15; i++ {
		result = fibonacci(i)
		fmt.Printf("fibonacci(%d) is: %d\n", i, result)
	}
}
func fibonacci(n int) (res int) {
	if n <= 1 {
		res = 1
	} else {
		res = fibonacci(n-1) + fibonacci(n-2)
	}
	return
}

2.Go 语言中也可以使用相互调用的递归函数：多个函数之间相互调用形成闭环。因为 Go 语言编译器的特殊性，这些函数的声明顺序可以是任意的。

//奇偶判断
package main
import (
"fmt"
)
func main() {
fmt.Printf("%d is even: is %t\n", 16, even(16)) // 16 is even偶数: is true
fmt.Printf("%d is odd: is %t\n", 17, odd(17))
// 17 is odd: is true
fmt.Printf("%d is odd: is %t\n", 18, odd(18))
// 18 is odd: is false
}
func even(nr int) bool {
if nr == 0 {
return true
}
return odd(RevSign(nr) - 1)
}
func odd(nr int) bool {
if nr == 0 {
return false
}
return even(RevSign(nr) - 1)
}
func RevSign(nr int) int {
if nr < 0 {
return -nr
}
return nr
}

七、将函数作为参数

函数可以作为其它函数的参数进行传递，然后在其它函数内调用执行，一般称之为回调。

package main
import (
"fmt"
)
func main() {
callback(1, Add)
}
func Add(a, b int) {
fmt.Printf("The sum of %d and %d is: %d\n", a, b, a+b)
}
func callback(y int, f func(int, int)) {
f(y, 2) // this becomes Add(1, 2)
}

八、闭包

1.当我们不希望给函数起名字的时候，可以使用匿名函数，例如： func(x, y int) int { return x + y } ，然后赋值于某个变量，即保存函数的地址到变量中： fplus := func(x, y int) int { return x + y } ，然后通过变量名对函数进行调用： fplus(3,4) 。当然，可以直接对匿名函数进行调用： func(x, y int) int { return x + y } (3, 4) 。

2.匿名函数，表示参数列表的第一对括号必须紧挨着关键字 func ，因为匿名函数没有名称。花括号 {} 涵盖着函数体，最后的一对
括号表示对该匿名函数的调用。

func() {
sum := 0
for i := 1; i <= 1e6; i++ {
sum += i
}
}()

3.将匿名函数赋值给变量并对其进行调用，我们可以看到变量 g 代表的是 func(int) ，变量的值是一个内存地址。所以我们实际上拥有的是一个函数值：匿名函数可以被赋值给变量并作为值使用。

package main
import "fmt"
func main() {
f()
}
func f() {
for i := 0; i < 4; i++ {
g := func(i int) { fmt.Printf("%d ", i) } //此例子中只是为了演示匿名函数可分配不同的内存地址，现实开发中，不应该把该部分信息放置到循环中。
g(i)
fmt.Printf(" - g is of type %T and has value %v\n", g, g)
}
}

4.匿名函数像所有函数一样可以接受或不接受参数。下面的例子展示了如何传递参数到匿名函数中：

func (u string) {
fmt.Println(u)
…
}(v)

5.关键字 defer 经常配合匿名函数使用，它可以用于改变函数的命名返回值。匿名函数还可以配合 go 关键字来作为 goroutine 使用。变量 ret 的值为 2，因为 ret++ 是在执行 return 1 语句后发生的。这可用于在返回语句之后修改返回的 error 时使用。

package main
import "fmt"
func f() (ret int) {
defer func() {
ret++
}()
return 1
}
func main() {
fmt.Println(f())
}

6.匿名函数同样被称之为闭包（函数式语言的术语）：它们被允许调用定义在其它环境下的变量。闭包可使得某个函数捕捉到一些外部状态，例如：函数被创建时的状态。另一种表示方式为：一个闭包继承了函数所声明时的作用域。这种状态（作用域内的变量）都被共享到闭包的环境中，因此这些变量可以在闭包中被操作，直到被销毁。

九、应用闭包：将函数作为返回值

1.示例：函数 Adder() 现在被赋值到变量 f 中（类型为 func(int) int ），三次调用函数 f 的过程中函数 Adder() 中变量 delta 的值分别为：1、20 和 300。我们可以看到，在多次调用中，变量 x 的值是被保留的，即 0 + 1 = 1 ，然后 1 + 20 = 21 ，最后 21 + 300 = 321 。闭包函数保存并积累其中的变量的值，不管外部函数退出与否，它都能够继续操作外部函数中的局部变量。

package main
import "fmt"
func main() {
	var f = Adder()
	fmt.Print(f(1), " - ")
	fmt.Print(f(20), " - ")
	fmt.Print(f(300))
}
func Adder() func(int) int {
	var x int
	return func(delta int) int {
		x += delta               //闭包的话一直执行闭包代码，直到闭包结束，其环境变量同理
		return x
	}
}

2.在闭包中使用到的变量可以是在闭包函数体内声明的，也可以是在外部函数声明的，闭包函数就能够被应用到整个集合的元素上，并修改它们的值。然后这些变量就可以用于表示或计算全局或平均值。

var g int
go func(i int) {
s := 0
for j := 0; j < i; j++ { s += j }
g = s
}(1000) // Passes argument 1000 to the function literal.

3.一个返回值为另一个函数的函数可以被称之为工厂函数，这在您需要创建一系列相似的函数的时候非常有用：书写一个工厂函数而不是针对每种情况都书写一个函数。下面的函数演示了如何动态返回追加后缀的函数：

func MakeAddSuffix(suffix string) func(string) string {
return func(name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
}
return name
}
}

现在，我们可以生成如下函数：
addBmp := MakeAddSuffix(".bmp")
addJpeg := MakeAddSuffix(".jpeg")
然后调用它们：
addBmp("file") // returns: file.bmp
addJpeg("file") // returns: file.jpeg
可以返回其它函数的函数和接受其它函数作为参数的函数均被称之为高阶函数，是函数式语言的特点。

十、 使用闭包调试

在分析和调试复杂的程序时，无数个函数在不同的代码文件中相互调用，如果这时候能够准确地知道哪个文件中的具体哪个函数正在执行，对于调试是十分有帮助的。可以使用 runtime 或 log 包中的特殊函数来实现这样的功能。包 runtime 中的函数 Caller() 提供了相应的信息，因此可以在需要的时候实现一个 where() 闭包函数来打印函数执行的位置：

where := func() {
_, file, line, _ := runtime.Caller(1)
log.Printf("%s:%d", file, line)
}
where()
// some code
where()
// some more code
where()

您也可以设置 log 包中的 flag 参数来实现：

log.SetFlags(log.Llongfile)
log.Print("")

或使用一个更加简短版本的 where 函数：

var where = log.Print
func func1() {
where()
... some code
where()
... some code
where()
}

十一、计算函数执行时间

计算执行消耗的时间是非常有意义的，尤其是在对比和基准测试中。最简单的一个办法就是在计算开始之前设置一个起始时候，再由计算结束时的结束时间，最后取出它们的差值，就是这个计算所消耗的时间。可以使用 time 包中的 Now() 和 Sub 函数：
 

start := time.Now()
longCalculation()
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)

十二、通过内存缓存来提升性能

当在进行大量的计算时，提升性能最直接有效的一种方式就是避免重复计算。通过在内存中缓存和重复利用相同计算的结果，称之为内存缓存。最明显的例子就是生成斐波那契数列的程序。我们要做就是将第 n 个数的值存在数组中索引为 n 的位置，然后在数组中查找是否已经计算过，如果没有找到，则再进行计算。

package main
import (
"fmt"
"time"
)
const LIM = 41
var fibs [LIM]uint64
func main() {
var result uint64 = 0
start := time.Now()
for i := 0; i < LIM; i++ {
result = fibonacci(i)
fmt.Printf("fibonacci(%d) is: %d\n", i, result)
}
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
}
func fibonacci(n int) (res uint64) {
// memoization: check if fibonacci(n) is already known in array:
if fibs[n] != 0 {
res = fibs[n]
return
}
if n <= 1 {
res = 1
} else {
res = fibonacci(n-1) + fibonacci(n-2)
}
fibs[n] = res
return
}

依照这个原则实现的，下面是计算到第 40 位数字的性能对比：
普通写法：4.730270 秒
内存缓存：0.001000 秒
内存缓存的优势显而易见，而且您还可以将它应用到其它类型的计算中，例如使用 map而不是数组或切片。