Go基础知识点(六) | 青训营笔记

这是我参与「第五届青训营 」笔记创作活动的第8天.

匿名函数:

Go语言是支持函数式编程:

1. 将匿名函数作为另外一个函数的参数,回调函数;

2.将匿名函数作为另外一个函数的返回值,可以形成闭包结构.

import "fmt"

func main() {
   f1()
   f2 := f1
   f2()
   //匿名函数
   f3 := func() {
      fmt.Println("我是f3函数")
   }
   f3()
   //匿名函数自己调用自己
   func() {
      fmt.Println("我是f4函数")
   }()
   func(a, b int) {
      fmt.Println(a, b)
      fmt.Println("我是f5函数")
   }(1, 2)
   r1 := func(a, b int) int {

      fmt.Println("我是f6函数")
      return a + b
   }(3, 4)
   fmt.Println(r1)
}
func f1() {
   fmt.Println("我是f1函数")
}

回调函数:

根据Go语言的数据类型的特点,可以将一个函数作为另外一个函数的参数.

func1() func2()

将func1函数作为func2这个函数的参数

func2函数:就叫做高阶函数,接受了一个函数作为参数的函数.

func1函数:就叫做回调函数,作为另外一个函数的参数.

import "fmt"

func main() {
   r := add2(1, 2)
   fmt.Println(r)
   r2 := oper(3, 4, add2)
   fmt.Println(r2)
   r3 := oper(3, 4, sub)
   fmt.Println(r3)
   r4 := oper(10, 5, func(a, b int) int {
      if b == 0 {
         fmt.Println("除数不能为0")
         return 0
      }
      return a / b
   })
   fmt.Println(r4)
}
func oper(a, b int, fun func(int, int) int) int {
   r1 := fun(a, b)
   return r1
}
func add2(a, b int) int {
   return a + b
}
func sub(a, b int) int {
   return a - b
}

闭包结构:

一个外层函数中,有内层函数,该内层函数中,会操作外层函数的局部变量.

并且该外层函数的返回值就是这个内层函数.

这个内层函数和外层函数的局部变量,统称为闭包结构.

局部变量的生命周期就会发生变化,正常的局部变量会随着函数的调用而创建,随着函数的结束而销毁.

但是闭包结构中的闭包函数的局部变量并不会随着外层函数的结束而销毁,因为内层函数还在继续使用.

import "fmt"

func main() {
   r1 := increment()
   fmt.Println(r1) //0xda9a20
   v1 := r1()
   fmt.Println(v1)   //1
   fmt.Println(r1()) //2
   fmt.Println(r1()) //3
   fmt.Println(r1()) //4
   r2 := increment()
   v2 := r2()
   fmt.Println(v2)   //1
   fmt.Println(r1()) //5
   fmt.Println(r2()) //3
   fmt.Println(r2()) //4
}
func increment() func() int {
   i := 0
   //定义一个匿名函数,给变量自增并返回
   fun := func() int {
      i++
      return i
   }
   return fun
}
**```**