Golang 函数
创建函数
package main
import "fmt"
//有参数，有返回值
func demo(a int, s string) (int, string) {
return a * a, s + s
}
//有参数，没有返回值
func test(a int) {
fmt.Println(a)
}
//不需要参数，有返回值
func example() string {
return "this is a str be returned"
}
func main() {
x := 10
str := "bye "
x, str = demo(x, str)
fmt.Println(x, str) //100 bye bye
y := 99
test(y) //99
//有返回值，但不接收返回值
example()
//接收返回值
s := example()
fmt.Println(s) //this is a str be returned
}
可变参数
如果一个函数的参数个数是可变的，那么可以在定义函数时，在参数列表的最后一个参数类型之前加上...
package main
import "fmt"
func sum(num ...int) int {
res := 0
for _, v := range num {
res += v
}
return res
}
func multi_params(a string, x int, y ...int) {
fmt.Println("第一个参数:", a)
fmt.Println("第二个参数:", x)
fmt.Println("可变参数:", y)
}
func main() {
tot := sum(1, 2, 3, 4, 5)
fmt.Println(tot) //15
multi_params("hello", 99, 1, 2, 3, 4)
//第一个参数: hello
//第二个参数: 99
//可变参数: [1 2 3 4]
}
函数多返回值
package main
import "fmt"
//返回值可直接写返回值的类型，如果是单个返回值，可省略返回值的括号
//参数列表中，如果参数类型都相同，可以只在最后写一次类型
func swap(a, b int) (int, int) {
return b, a
}
//可以指定返回值的名称，这个名称只是为了方便理解，并没有什么用
func compute(a int, b int) (sum, sub int) {
return a + b, a - b
}
func main() {
a := 10
b := 20
a, b = swap(a, b)
fmt.Println(a, b) //20 10
x, y := compute(10, 5)
fmt.Println(x, y) //15 5
}
错误处理 defer
defer后面的函数在Go程序设计语言中被称为延迟函数，为什么叫延迟呢？因为这个defer函数的存在于一个函数之中（包括main函数），defer函数执行的时机是在 包含他的那个函数（上一层函数）将要执行完之前的最后一步，即函数最后一条语句执行完了，然后在执行这个defer函数，如果同一个函数内部有多个defer的函数，那么，这些个defer函数的执行顺序按照栈的后进先出，最后定义的defer函数最先执行，最先定义的defer函数最后执行。
先看一个简单的例子：
package main
import "fmt"
func main(){
defer func(){
fmt.Println("run last")
}()
//注意defer的函数后面一定要加圆括号，不然就是定义函数，而不会执行函数
fmt.Println("run first")
}
在上面这个例子中，包含defer函数的 函数是main函数，所以在main()函数执行完毕之后（不能说main函数执行完毕，应该说已经顺序执行完除了defer函数以外的所有语句），才执行defer函数，所以运行结果如下：
run first run last
然后看下面这个例子：
package main
import "fmt"
func test(){
fmt.Println("One")
defer func(){
fmt.Println("two")
}()
defer func(){
fmt.Println("three")
}()
}
func main(){
test()
fmt.Println("run first")
}
上面这个例子中test函数包含在main()中，test函数中包含两个延迟函数，所以正常语句执行完之后，应该先执行第二个延迟函数，然后执行第一个延迟函数，然后test函数执行完毕后，在顺序执行test函数后面的语句。
One three two run first
再看一个例子：
package main
import "fmt"
func test(){
fmt.Println("One")
defer func(){
fmt.Println("two")
}()
defer func(){
fmt.Println("three")
}()
}
func main(){
defer test() #与上面一个例子的区别，这里test函数是延迟函数
fmt.Println("run first")
}
因为test函数此时作为延迟函数，那么test函数在main函数中最后执行，执行test的时候，因为test中又有延迟函数，仍旧遵守上面的顺序，所以执行的结果如下：
run first One three two
延迟函数类似于其他面向对象语言中的析构函数，只是很类似，不要混为一谈。延迟通常用来做一些收尾工作，给他的主子擦屁股，比如关闭打开的文件，或者一些连接状态，亦或者清楚一些数据。。。。。
defer的注意事项
package main
import "fmt"
func main() {
i := 0
defer fmt.Println("调用defer1,i=", i)
defer func() {
fmt.Println("调用defere2,i=", i)
}()
for i = 0; i < 5; i++ {
fmt.Print(" ", i)
}
fmt.Println()
}
// 0 1 2 3 4
//调用defere2,i= 5
//调用defer1,i= 0
上面第一个defer中的i，其实是在循环开始之前，就已经将i的值传递给fmt.Println了。
类似于下面这个写法
i := 0
defer func(x int) {
fmt.Println("调用defer1,i=", x)
}(i)
函数变量
package main
import "fmt"
//定义新的类型，为函数类型，后面是函数签名
type handler func(int, int) int
func main() {
foo := func(a, b int) (sum int) {
return a + b
}
fmt.Println(foo(3, 5)) //8
demo := foo
fmt.Println(demo(3, 3)) //6
var test handler
test = demo
fmt.Println(test(4, 4))
}
闭包
即函数（外部函数）中再定义一个函数（内部函数），并且将内部函数返回，对，返回一个函数，内部函数就叫做闭包。在内部函数中可以调用外部函数中的变量。并且在外部函数调用完之后，外部函数中定义的局部变量并不会立即销毁。
package main
import "fmt"
//外部函数需要参数 a int,b int
//返回值为一个函数，该函数需要一个参数int型的time倍数 ，并返回一个int型的值
func demo(a, b int) func(time int) int {
sum := a + b //求和
return func(t int) int {
return sum * t
}
}
func main() {
foo := demo(3, 5)
//此时foo是一个函数
fmt.Println(foo) //0x10936b0 指向内部函数的地址
fmt.Println(foo(4)) //32
}
第二个例子
package main
import "fmt"
func demo() func() int {
cnt := 0
return func() int {
cnt++
return cnt
}
}
func main() {
foo := demo()
//调用demo之后，demo函数内部的局部变量并不会立即销毁，会一直保存
fmt.Println(foo()) //1
fmt.Println(foo()) //2
}
