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

1.函数的具体定义

  1. - 无参无返回值
  1. func printHello(){
  2.     fmt.Println("Hello")
  3. }
  1. - 有一个或多个参数的函数
  1. func main() {
  2.     //调用max函数并输出最大值
  3.     fmt.Println(max(100,200))
  4. }
  5. //返回最大值
  6. func max(num1 int,num2 int) int{
  7.     if num1>num2 {  //比较两个数大小
  8.         return num1
  9.     }else{
  10.         return num2
  11.     }
  13. }
  1. - 有一个或多个返回值的函数
  1. func main() {
  2.     fmt.Println(swap("100","200")) 
  3. }
  4. func swap(x,  y string) (string, string){
  5.     return y,x
  7. }
  1. func main() {
  2.     fun1(10,20) 
  3. }
  5. //求周长和面积
  6. func fun1(len,wid float64)(float64,float64){
  7.     //周长
  8.     zc := (len + wid)*2
  9.     fmt.Println("周长是：",zc)
  10.     //面积
  11.     mj := len * wid
  12.     fmt.Println("面积是：",mj)
  13.     return zc,mj
  14. }

2.可变参数

  1. - 一个函数的参数类型确定，个数不确定，可以使用可变参数
  1. func main() {
  2.     fmt.Println(fun1(3,3,3))
  3. }
  5. //求和,参数可变
  6. func fun1(num1 ...int) int {
  7.     sum := 0
  8.     //len(num1) 获取参数的长度
  9.     for i := 0; i < len(num1); i++ {
  10.         sum += num1[i]
  11.     }
  12.     return sum
  13. }

3.延迟函数：defer

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

  1. func main() {
  2.     defer fmt.Println("最后执行")
  3.     fmt.Println("最先执行")
  4.     defer fun1()
  5. }
  7. func fun1() {
  8.     fmt.Println("第二执行")
  9. }

4.匿名函数

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

  1. func main() {
  2.     func () {
  3.         fmt.Println("这是匿名函数")
  4.     }()
  5. }

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

  1. func main() {
  2.     func () {
  3.         fmt.Println("这是匿名函数")
  4.     }()
  6.     f1 :=func () {
  7.         fmt.Println("这是匿名函数")
  8.     }
  9.     f1()
  10. }

5.回调函数

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

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

  1. func main() {
  2.     //oper为高阶函数
  3.     oper(add)
  4. }
  6. func add(a,b int)int{
  7.     return a+b
  8. }
  10.     //回调函数：将函数作为另一个函数的参数
  11. func oper( fun func(int,int)int)int{
  12.     r:=fun(1,2)
  13.     fmt.Println(r)
  14.     return r
  15. }

6.闭包

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

局部变量的生命周期就会发生改变，正常的局部变量会随着函数的调用而创建，随着函数的结束而销毁但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用 go package main import "fmt" // 是一种特殊的结构：闭包结构，违反了程序正常的生命周期。合法的使用。程序允许的一种特殊结构，变量作用域升级了。 // 什么时候用闭包： js （xxxxxxx.html 引用大量的第三方库：10个js库，js库中很多变量名是冲突的） // js 很多框架都是闭包结构的，防止变量冲突，全局变量污染 // 我的代码里面的变量就不会和你代码里面的变量冲突了。解决一些变量作用域冲突的问题。 /* 闭包结构: 一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量并且该外层函数的返回值就是这个内层函数。 在闭包结构中：局部变量的生命周期就会发生改变， 正常的局部变量会随着函数的调用而创建，随着函数的结束而销毁 但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用. // 由于垃圾回收期不会将闭包中的变量销毁，可能会造成内存泄漏。 */ // 你的代码变量和你同事的变量冲突了，解决。 i 新建一个变量。 第三方库中的代码都是闭包结构实现的导出。 var i int = 10 func main() { r1 := increment() fmt.Println(r1) // 返回的是一个 increment() 内存函数，还没有执行 // -- 执行这个内层函数 // v1 := r1() fmt.Println(v1) v2 := r1() fmt.Println(v2) fmt.Println(r1()) fmt.Println(r1()) fmt.Println(r1()) // 你写的代码是对的，但是结果不对，你的变量被污染了 fmt.Println("--------------------------") // r2和r1指向同一个地址 r2 := increment() // 再次调用的时候 ，i = 0 v3 := r2() fmt.Println(v3) // 1 //因为我们内层还是用i，还存在引用，系统不会销货这个i，保护，单独作用r1 fmt.Println(r1()) // 6 // 这里的i 并没有随着 第二次创建就被销毁归0，而是在内层函数继续调用着。 fmt.Println(r2()) // 2 // r1 名字 ----> 内存地址 &r1 fmt.Printf("%p\n", &r1) fmt.Printf("%p\n", &r2) } // 自增函数 // increment() 函数返回值为 func() int 类型 func increment() func() int { // 外层函数，项目（很多的全局变量） // 定义一个局部变量 i := 0 // 在外层函数内部定义一个匿名函数，给变量自增并返回。 fun := func() int { i++ return i } return fun } 如果我们想使用闭包结构来解决全局变量污染的问题，那我们就可以写一个闭包结构来创建执行的函数。 通过这个闭包结构创建的函数内部的变量，都在这个函数中作用，不会和其他函数冲突。

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