go的函数定义、递归、延迟、匿名、高阶、闭包

package main
 
import "fmt"
 
func main() {
  f1()
  f2("hello")
  f3(18, "hello")
  num1 := f4(2, 3)
  fmt.Println(num1)
  num2, num3 := f5(2, 3)
  fmt.Println(num2, num3)
  //  多个返回值，只接收一个
  num4, _ := f5(5, 6)
  fmt.Println(num4)
  getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
}
 
//无参无返回值函数
func f1() {
  fmt.Println("无参无返回值函数")
}
 
// 有一个参数的函数
func f2(str string) {
  fmt.Println(str)
}
 
//有两个参数的函数
func f3(num int, str string) {
  fmt.Println(num, str)
}
 
//有一个返回值的函数
func f4(num1, num2 int) int {
  return num1 + num2
}
 
//有多个返回值的函数
func f5(num1, num2 int) (int, int) {
  return num1 + num2, num1 - num2
}
 
//可变参数函数
func getSum(nums ...int) {
  var sum int
  for _, num := range nums {
    sum += num
  }
  fmt.Println(sum)
}

package main
 
import "fmt"
 
//引用传递
 
func main() {
  fmt.Println(getSumT(5))
}
func getSumT(n int) int {
  if n == 1 {
    return 1
  } else {
    return getSumT(n-1) + n
  }
}

15

package main
 
import "fmt"
 
//defer延迟执行，逆序执行
//场景 io关闭操作
 
func main() {
  f("1")
  f("2")
  defer f("3")
  f("4")
}
func f(str string) {
  fmt.Println(str)
}

package main
 
import "fmt"
 
//函数是一种数据类型、引用类型
 
func main() {
  //打印类型
  fmt.Printf("%T\n", f10)
  //定义函数变量
  var f11 func(string2 string)
  f11 = f10
  fmt.Println(f10)
  fmt.Println(f11)
  f11("abc")
 
}
func f10(str string) {
  fmt.Println(str)
}

package main
 
import "fmt"
 
//匿名函数
 
func main() {
  f21()
  //函数本身是一个地址
  f0 := f21
  f0()
  f3 := func() {
    fmt.Println("匿名函数")
  }
  f3()
  //匿名函数
  func(a, b int) {
    fmt.Println(a, b, "匿名函数")
  }(1, 2)
}
func f21() {
  fmt.Println("hello,func!")
}

package main
 
import "fmt"
 
//高阶函数
 
func main() {
  //高阶函数，参数为函数
  fmt.Println(oper(3, 3, add))
  //高阶函数，参数为匿名函数
  num := oper(5, 5, func(a int, b int) int {
    return a * b
  })
  fmt.Println(num)
}
func add(a, b int) int {
  return a + b
}
 
//函数参数为函数
func oper(a, b int, f func(int, int) int) int {
  return f(a, b)
}

 
 package main
 
import "fmt"
 
//高阶函数
 
func main() {
  r1 := increment()
  fmt.Println(r1())
  fmt.Println(r1())
  fmt.Println(r1())
  fmt.Println(r1())
}
 
//闭包
func increment() func() int {
  //  局部变量i
  i := 0
  //  定义个匿名函数
  fun := func() int {
    i++
    return i
  }
  return fun
}

package fn_test
 
import (
  "fmt"
  "math/rand"
  "testing"
  "time"
)
 
//多返回值
func returnMultiValues() (int, int) {
  return rand.Intn(10), rand.Intn(20)
}
 
//返回一个函数的运行时间
func timeSpent(inner func(op int) int) func(op int) int {
  return func(n int) int {
    start := time.Now()
    ret := inner(n)
    fmt.Println("time spent", time.Since(start).Seconds())
    return ret
  }
}
 
func slowFun(op int) int {
  time.Sleep(time.Second * 1)
  return op
}
func TestFn(t *testing.T) {
  a, b := returnMultiValues()
  t.Log(a, b)
  num := timeSpent(slowFun)(5)
  t.Log(num)
}
 
//定义求和函数
func Sum(ops ...int) int {
  s := 0
  for _, op := range ops {
    s += op
  }
  return s
}
 
//延迟执行函数
func TestDefer(t *testing.T) {
  //清理资源，释放资源
  defer func() {
    t.Log("clear resources")
  }()
  t.Log("Started")
  //抛出异常
  panic("Fatal error")
}
func TestVarParam(t *testing.T) {
  t.Log(Sum(1, 2, 3, 4))
  t.Log(Sum(1, 2, 3, 4, 5))
}