1、函数介绍

函数是基本的代码块，每一个程序都包含很多的函数。
编写多个函数的主要目的是将一个需要很多行代码的复杂问题分解为一系列简单的任务（函数）来解决。而且，同一个任务（函数）可以被调用多次，有助于代码重用。
当函数执行到代码块最后一行（} 之前）或者 return 语句的时候会退出，其中 return 语句可以带有零个或多个参数；这些参数将作为返回值供调用者使用。
Go 里面有三种类型的函数：

  - 普通函数
  - 匿名函数
  - 方法（Methods）

2、普通函数

函数能够接收参数供自己使用，也可以返回零个或多个值。
在函数块里面，return 之后的语句都不会执行。如果一个函数需要返回值，那么这个函数里面的每一个代码分支都要有 return 语句。

func Demo1(a int) bool{
    if a>0{
        return true
    }
    return false
}
func Demo2(a int) bool, string{
    if a>0{
        return true, 'a>0'
    }
    return false, 'a<=0'
}
func main() {
    res1 := Demo1(1)
    fmt.Println("res1 = ", res1)
    res2, msg2 := Demo2(-1)
    fmt.Println("res2 = ", res2)
    fmt.Println("msg2 = ", msg2)
    // 空白符"_"用来匹配一些不需要的值，然后丢弃掉
    res3, _ := Demo2(0)
    fmt.Println("res3 = ", res3)
}

2.1、变参函数

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

func Greeting(prefix string, whos ...string) {
    if len(a)>0 {
        for _, who := range whos {
            fmt.Println(prefix, who)
        }
    }
}
func main() {
    Greeting("hello:", "Joe", "Anna", "Eileen")
}

2.2、defer关键字

关键字 defer 允许我们推迟到当前函数返回之前（或任意位置执行 return 语句之后）一刻才执行某个语句或函数。用法类似于面向对象编程语言 Java 和 C# 的 finally 语句块，它一般用于释放某些已分配的资源。
当有多个 defer 行为被注册时，它们会以逆序执行（类似栈，即后进先出）：

func trace(s string)   { fmt.Println("entering:", s) }
func untrace(s string) { fmt.Println("leaving:", s) }
func a() {
    trace("a")
    defer untrace("a")
    fmt.Println("in a")
}
func b() {
    trace("b")
    defer untrace("b")
    fmt.Println("in b")
    a()
}
func main() {
    b()
}
//输出
entering: b
in b
entering: a
in a
leaving: a
leaving: b

2.3、Go内置函数

Go 语言拥有一些不需要进行导入操作就可以使用的内置函数。

名称	说明
close	用于管道通信
len、cap	len 用于返回某个类型的长度或数量（字符串、数组、切片、map 和管道）；cap 是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
new、make	new 和 make 均是用于分配内存：new 用于值类型和用户定义的类型，如自定义结构，make 用于内置引用类型（切片、map 和管道）。它们的用法就像是函数，但是将类型作为参数：new(type)、make(type)。new(T) 分配类型 T 的零值并返回其地址，也就是指向类型 T 的指针。它也可以被用于基本类型：`v := new(int)`。make(T) 返回类型 T 的初始化之后的值，因此它比 new 进行更多的工作，new() 是一个函数，不要忘记它的括号
copy、append	用于复制和连接切片
panic、recover	两者均用于错误处理机制
print、println	底层打印函数，在部署环境中建议使用 fmt 包
complex、real imag	用于创建和操作复数

2.4、递归函数

当一个函数在其函数体内调用自身，则称之为递归。

func main() {
    result := 0
    for i := 0; i <= 10; 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.5、回调函数

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

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)
}

3、匿名函数

当我们不希望给函数起名字的时候，可以使用匿名函数，例如：func(x, y int) int { return x + y }。
这样的一个函数不能够独立存在（编译器会返回错误：non-declaration statement outside function body），但可以被赋值于某个变量，即保存函数的地址到变量中：fplus := func(x, y int) int { return x + y }，然后通过变量名对函数进行调用：fplus(3,4)。
当然，您也可以直接对匿名函数进行调用：func(x, y int) int { return x + y } (3, 4)。

func() {
    sum := 0
    for i := 1; i <= 1e6; i++ {
        sum += i
    }
}()
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)
    }
}

3.1、闭包函数

func main() {
    // make an Add2 function, give it a name p2, and call it:
    p2 := Add2()
    fmt.Printf("Call Add2 for 3 gives: %v\n", p2(3))
    // make a special Adder function, a gets value 3:
    TwoAdder := Adder(2)
    fmt.Printf("The result is: %v\n", TwoAdder(3))
}
func Add2() func(b int) int {
    return func(b int) int {
        return b + 2
    }
}
func Adder(a int) func(b int) int {
    return func(b int) int {
        return a + b
    }
}