Go笔记(十)：函数

1、函数

　　函数一般用于执行某一特定的任务，go函数有三个要素：函数名称、返回类型、参数。

2、函数特性

　　1、go中不允许函数重载(overload)，不允许函数同名;

　　2、go中函数不能嵌套函数，但可以嵌套匿名函数;

　　3、函数可作为参数传递给另一个函数;

　　4、函数的返回值可以是一个函数;

　　5、函数调用的时候，如果有参数传递给函数，则先拷贝参数的副本，再将副本传递给函数。

3、函数的声明

func function_name( [parameter list] ) [return_types] {
   // 函数体
}

　　function_name：函数名称，必选

　　[parameter list]：参数，可选

　　[return_types]：返回类型，可选

　　func：关键字，用来声明函数，必选

1、无参、无返回类型的函数

　　main函数也是一个无参、无返回类型的函数

package main

import "fmt"

// 无参 无返回值的函数
func demo() {
   fmt.Printf("demo() 无参数无返回值")
}

// 函数
func main() {
   demo()
}

　　执行结果如下：

 

2、有参、有返回类型的函数

　　在go函数中，可以不设置返回变量名。

package main

import "fmt"

// 获取两数的最大值
func getMaxValue(a int, b int) (max int) {
   if a >= b {
      max = a
   } else {
      max = b
   }
   return max
}

// go函数可不设置返回变量
func getMinValue(a int, b int) int {
   if a <= b {
      return a
   } else {
      return b
   }
}

// 函数
func main() {

   maxValue := getMaxValue(4, 6)
   fmt.Printf("getMaxValue(4, 6)  --> 最大值：%v\n", maxValue)

   minValue := getMinValue(4, 6)
   fmt.Printf("getMinValue(4, 6)  --> 最小值：%v\n", minValue)

}

　　执行结果如下：

  

3、go函数返回值可以有多个

package main

import "fmt"

// go函数可以有多个返回值
func getInfo() (string, string) {
   return "zs", "China"
}

// 返回值
func main() {

   name, addr := getInfo()
   fmt.Printf("getInfo() --> name = %v, addr = %v\n", name, addr)

}

　　执行结果如下：

  

4、函数的参数

1、参数必须指定数据类型

package main

import "fmt"

// 形参列表
func sub(a int, b int) int {
   return a - b
}

// 参数
func main() {
   // 实参列表
   subValue := sub(4, 6)
   fmt.Printf("sub(4， 6) --> subValue = %v\n", subValue)
}

　　执行结果如下：

2、参数传递

2.1、值传递

　　值传递，传递给函数的是该值拷贝后的副本，函数内部访问、修改的也是这个副本，不影响调用函数外部的值。

package main

import (
   "fmt"
)

// 值传递, 函数内修改的是副本内容
func transferValue(num int) {
   num = 4
}

// 值传递
func main() {
   // 值传递
   var num = 6
   transferValue(num)
   fmt.Printf("transferValue(num) --> num = %v\n", num)
}

　　执行结果如下：

 

2.2、引用传递

　　引用传递，map、slice、interface、channel等数据类型是指针类型，此类型的值传递拷贝的是指针，拷贝后的参数仍然指向底层数据结构，修改后会影响外部数据结构的值。

package main

import (
   "fmt"
)

// 引用传递
func transferArr(slice01 []int) {
   slice01[0] = 100
}

func transferMap(map01 map[string]string) {
   map01["name"] = "jack"
}

// 引用传递
func main() {

   // 切片传递
   slice := []int{1, 2, 3}
   transferArr(slice)
   fmt.Printf("slice: %v\n", slice)
   // map传递
   map01 := map[string]string{
      "name": "timi",
      "age": "18",
   }
   transferMap(map01)
   fmt.Printf("map01: %v\n", map01)
}

　　执行结果如下：

  

3、变长参数

　　go中变长参数的声明需要在参数类型前加上 ... ， 例如 (params ...int)，示例如下：

package main

import (
   "fmt"
)

// 变长参数
func variableArgs(params ...int) int {
   sum := 0
   for _, v := range params {
      sum += v
   }
   return sum
}

// 函数
func main() {

   // 可变参数1，2，3
   sum01 := variableArgs(1, 2, 3)
   fmt.Printf("sum01: %v\n", sum01)
   // 可变参数1，4，5，6
   sum02 := variableArgs(1, 4, 5, 6)
   fmt.Printf("sum02: %v\n", sum02)
}

　　执行结果如下：

  

5、函数类型与函数变量

　　go中，可以使用type关键字定义函数类型变量，声明的变量可以被赋值函数，语法格式如下：

type fun func(int, int) int

　　示例代码如下：

package main

import (
   "fmt"
)

// 求和函数
func add(a int, b int) int {
   return a + b
}

// 函数
func main() {

   // 声明函数类型
   type varfunc func(int, int) int
   // 声明函数变量
   var vf varfunc
   // 函数变量赋值，赋予的函数必须与函数变量的类型有相同的参数类型与返回值
   vf = add
   // 函数变量使用
   sumValue := vf(1, 2)
   fmt.Printf("sumValue: %v\n", sumValue)
}

　　执行结果如下：

  

6、函数参数与函数返回值

　　go中的函数，可作为函数的参数，传递给另外一个函数，也可以作为另外一个函数的返回值返回

6.1、函数作为参数

package main

import (
   "fmt"
)

// 函数作为参数
func sayHello(name string) {
   fmt.Printf("Hello, %s\n", name)
}
func paramByFunc(name string, f func(string)) {
   f(name)
}

// 函数
func main() {
   
   // 函数作为参数
   paramByFunc("timi", sayHello)
}

　　执行结果如下：

  

6.2、函数作为返回值

package main

import (
   "fmt"
)

// 求和函数
func add(a int, b int) int {
   return a + b
}

// 相减函数
func sub(a int, b int) int {
   return a - b
}

// 函数作为返回值
func returnValueByFunc(methodName string) func(int, int) int {
   switch methodName {
      case "add":
         return add
      case "sub":
         return sub
      default:
         return nil
   }
}

// 函数
func main() {

   // 函数作为返回值
   sumFunc := returnValueByFunc("add")
   sumResult := sumFunc(3, 4)
   fmt.Printf("sumResult: %v\n", sumResult)
}

　　执行结果如下：

 

7、匿名函数

　　go语言函数不能嵌套，但可在函数内部定义匿名函数。匿名函数是指 没有名称的函数，语法如下：

func ( [parameter list] ) ([return_types])

　　[parameter list]：参数列表，可以有多个，也可以没有；

　　[return_types]：函数返回列表，可由多个，也可以没有。

示例代码如下：

package main

import (
   "fmt"
)

// 匿名函数
func anonymousFunc() {
   // 声明函数类型
   type concatFunc func(string, string) string
   // 声明函数变量
   var cf concatFunc
   // 声明匿名函数，并赋值给函数变量
   cf = func(param1 string, param2 string) string {
      return param1 + " " + param2
   }
   res := cf("hello", "timi")
   fmt.Printf("anonymousFunc -> res: %v\n", res)

    // 自身调用 匿名函数
    sumResult := func(a int, b int) int {
        return a + b
    }(4, 5)
    fmt.Printf("anonymousFunc -> sumResult: %v\n", sumResult)
}

// 函数
func main() {
   // 匿名函数
   anonymousFunc()
}

　　执行结果如下：

8、闭包

　　闭包是可以包含自由变量的代码块。闭包 = 函数 + 引用外部作用域变量

　　示例代码如下：

package main

import (
   "fmt"
   "strings"
)

// 闭包
// 获取序列号
func getSequence() func() int {
   i := 0
   return func() int {
      i += 1
      return i
   }
}
// 变量nextNumber是一个函数，并且引用了外部作用域中的i变量，此时nextNumber就是一个闭包。
// 在nextNumber的生命周期内，变量i一致有效
func closePackDemo() {
   /* nextNumber 为一个函数，函数 i 为 0 */
   nextNumber := getSequence()

   /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())

   /* 创建新的函数 nextNumber1，并查看结果 */
   nextNumberNew := getSequence()
   fmt.Println(nextNumberNew())
   fmt.Println(nextNumberNew())
}
// 添加后缀
func appendSuffix(suffix string) func(string) string {
   return func(name string) string {
      if !strings.HasSuffix(name, suffix) {
         return name + suffix
      }
      return name
   }
}
func closePackDemo2() {
   // 初始化外部作用域变量 suffix
   jpgFunc := appendSuffix(".jpg")
   txtFunc := appendSuffix(".txt")
   // 引用外部作用域的suffix，jpgFunc、txtFunc是一个闭包
   fmt.Printf("jpgFunc(\"test\"): %v\n", jpgFunc("img"))
   fmt.Printf("txtFunc(\"新建文件夹\"): %v\n", txtFunc("新建文件夹"))
}
// 获取计算参数结果
func cal(base int) (func(int) int, func(int) int) {
   add := func(i int) int {
      base += i
      return base
   }
   sub := func(i int) int {
      base -= i
      return base
   }
   return add, sub
}
func closePackDemo3() {
   fun01, fun02 := cal(5)
   // 5 + 1 、 5 + 1 - 2
   fmt.Println(fun01(1), fun02(2))
   // 5 + 1 - 2 + 10、  5 + 1 - 2 + 10 - 6
   fmt.Println(fun01(10), fun02(6))
   // 重置生命周期
   fun03, fun04 := cal(10)
   fmt.Println(fun03(1), fun04(2))
}

// 函数
func main() {

   // 闭包
  closePackDemo()
  fmt.Println("======================")
  closePackDemo2()
  fmt.Println("======================")
  closePackDemo3()
}

　　执行结果如下：

  

9、递归

递归：函数内部调用函数自身

　　·递归是函数调用自身;

　　·必须先定义函数退出条件，若无退出条件，递归将成为死循环;

　　·go语言递归函数很可能会产生一大堆goroutine，也可能会出现栈空间内存溢出问题。

 

package main

import (
   "fmt"
   "strings"
)

// 递归
// 斐波那契数列  F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2
func fibonacci(n int) int {
   if n == 0 {
      return 0
   }
   if n == 1 || n == 2 {
      return 1
   }
   return fibonacci(n-1) + fibonacci(n-2)
}
// 阶乘 n * (n-1) *...* 1
func factorial(n int) int {
   if n == 1 {
      return 1
   }
   return n * factorial(n-1)
}

// 函数
func main() {

   // 递归应用
   fibonacci := fibonacci(5)
   factorial := factorial(5)
   fmt.Printf("fibonacci: %v, factorial: %v\n", fibonacci, factorial)
}

　　执行结果如下：

10、defer语句

　　defer语句会将其后跟随的语句进行延迟处理。延迟处理的语句按defer定义的逆序进行执行。先被defer的语句后执行，后被defer的语句先执行。有点像栈的先进后出，defer最先定义的语句最后执行。

-> defer特性

　　1、关键字 defer 用于注册延迟调用

　　2、调用直到 return 前才被执行，可以用来做资源清理

　　3、多个defer语句，按先进后出的方式执行

　　4、defer语句中的变量，在defer声明时就已决定。

package main

import (
   "fmt"
   "strings"
)

// defer延迟处理，常用于
//    1、关闭文件句柄
//    2、释放锁资源
//    3.数据库连接释放
func deferFunc() {
   fmt.Println("start...")
   // 关键字 defer 用于注册延迟调用
   // 多个defer语句，按先进后出的方式执行
   defer fmt.Println("run01...")
   defer fmt.Println("run02...")
   defer fmt.Println("run03...")
   fmt.Println("end...")
}

// 函数
func main() {

   // defer延迟执行
   deferFunc()
}

　　执行结果如下：

  

11、init函数

　　init初始化函数，先于main函数执行。

1、init函数主要特点

　　1、init函数先于main函数自动执行，不能被其他函数调用;

　　2、init函数没有输入参数、返回值;

　　3、每个包可以有多个init函数;包的每个源文件也可以有多个init函数;

　　4、不同包的init函数按照包导入的依赖关系决定执行顺序

2、初始化顺序

　　变量初始化 -> init() -> main

package main

import "fmt"

// 初始化顺序： 变量初始化 -> init() -> main()
// init函数
func init() {
    fmt.Println("init()...")
}

// 变量初始化
var num int = getNum()
func getNum() int {
    fmt.Println("var...")
    return 100
}

// main函数
func main() {
    fmt.Println("main...")
}

　　执行结果如下：