• 1.函数的具体定义
• 2.可变参数
• 3.延迟函数：defer
• 4.匿名函数
• 5.回调函数
• 6.闭包

- 函数是一段代码的集合
- go语言中至少有一个main函数
- 函数可能需要一个结果，也可能没有
- 函数的格式：
    * func func_name(参数1，参数2...) 返回类型{  return xxx }

1.函数的具体定义

- 无参无返回值

func printHello(){
    fmt.Println("Hello")
}

- 有一个或多个参数的函数

func main() {
    //调用max函数并输出最大值
    fmt.Println(max(100,200))
}
//返回最大值
func max(num1 int,num2 int) int{
    if num1>num2 {  //比较两个数大小
        return num1
    }else{
        return num2
    }
}

- 有一个或多个返回值的函数

func main() {
    fmt.Println(swap("100","200")) 
}
func swap(x,  y string) (string, string){
    return y,x
}

func main() {
    fun1(10,20) 
}
//求周长和面积
func fun1(len,wid float64)(float64,float64){
    //周长
    zc := (len + wid)*2
    fmt.Println("周长是：",zc)
    //面积
    mj := len * wid
    fmt.Println("面积是：",mj)
    return zc,mj
}

2.可变参数

- 一个函数的参数类型确定，个数不确定，可以使用可变参数

func main() {
    fmt.Println(fun1(3,3,3))
}
//求和,参数可变
func fun1(num1 ...int) int {
    sum := 0
    //len(num1) 获取参数的长度
    for i := 0; i < len(num1); i++ {
        sum += num1[i]
    }
    return sum
}

3.延迟函数：defer

defer:一个函数或者方法被延迟执行，执行到最后时，逆序执行

func main() {
    defer fmt.Println("最后执行")
    fmt.Println("最先执行")
    defer fun1()
}
func fun1() {
    fmt.Println("第二执行")
}

4.匿名函数

匿名函数：没有名字的函数

func main() {
    func () {
        fmt.Println("这是匿名函数")
    }()
}

将匿名函数赋值给其他变量，可多次调用

func main() {
    func () {
        fmt.Println("这是匿名函数")
    }()
    f1 :=func () {
        fmt.Println("这是匿名函数")
    }
    f1()
}

5.回调函数

  回调函数:将函数作为另一个函数的参数

高阶函数：接收另一个函数作为参数的函数

func main() {
    //oper为高阶函数
    oper(add)
}
func add(a,b int)int{
    return a+b
}
    //回调函数：将函数作为另一个函数的参数
func oper( fun func(int,int)int)int{
    r:=fun(1,2)
    fmt.Println(r)
    return r
}

6.闭包

一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量并且该外层函数的返回值就是这个内层函数。这个内层函数和外层函数的局部变量，统称为闭包结构。

闭包结果的返回值是一个函数。这个函数可以调用闭包结构中的变量。