一个高阶函数应该具备下面至少一个特点：

  • 将一个或者多个函数作为形参
  • 返回一个函数作为其结果

首先明确一件事情：函数名也是一个变量 

  1. package main
  3. import (
  4.    "fmt"
  5.    "reflect"
  6. )
  8. func addCal(x, y int) int {
  9.    return x + y
  10. }
  12. func main() {
  13.    a := addCal
  14.    a(2, 3)
  15.    fmt.Println(a) // 0x10a3120
  16.    fmt.Println(addCal) // 0x10a3120
  17.    fmt.Println(reflect.TypeOf(addCal)) // func(int, int) int
  18. }

结论：函数参数是一个变量，所以，函数名当然可以作为一个参数传入函数体，也可以作为一个返回值。

1、函数参数

  1. func timer(f func()) {   // 形参定义是函数类型 
  2.    timeBefore := time.Now().Unix()
  3.    f()
  4.    timeAfter := time.Now().Unix()
  5.    fmt.Println("运行时间：", timeAfter-timeBefore)
  6. }
  8. func foo() {
  9.    fmt.Println("foo function... start")
  10.    time.Sleep(time.Second * 2)
  11.    fmt.Println("foo function... end")
  12. }
  14. func bar() {
  15.    fmt.Println("bar function... start")
  16.    time.Sleep(time.Second * 2)
  17.    fmt.Println("bar function... end")
  18. }
  20. func main() {
  22.    timer(foo)  // 传入 foo 函数名
  23.    timer(bar) // 传入 bar函数名
  25. }

注意如果函数参数也有参数该怎么写呐？ 

  1. func add(x, y int) int {
  2.    return x + y
  3. }
  5. func mul(x, y int) int {
  6.    return x * y
  7. }
  9. // 函数参数必须跟需要传入的函数一样
  10. func cal(f func(x, y int) int, x, y int) int {
  11.    return f(x, y)
  12. }
  14. func main() {
  15.    ret1 := cal(add, 12, 3)
  16.    fmt.Println(ret1)
  17.    ret2 := cal(mul, 12, 3)
  18.    fmt.Println(ret2)
  19. }

2、函数返回值

  1. package main
  3. import "fmt"
  5. func foo() func() {  // 返回一个函数类型
  6.    inner := func() {    // 函数里面只能嵌套匿名函数
  7.       fmt.Println("函数inner执行")
  8.    }
  10.    return inner
  11. }
  13. func main() {
  14.    a := foo()   // 返回的匿名函数的地址传给 a
  15.    a() // 执行匿名函数逻辑
  16. }