Go语言学习——匿名函数、闭包

匿名函数

匿名函数的定义格式:

func(参数)(返回值){
函数体
}

没有名字的函数

package main

import "fmt"

// 匿名函数

// var f1 = func (x, y int) {
// fmt.Println(x + y)

// }

func main(){
// f1(10, 20)
// 函数内部没有办法声明带名字的函数
// 匿名函数
f1 := func (x, y int) {
fmt.Println(x + y)
}
f1(10, 20)

// 如果只是调用一次的函数，还可以简写成立即执行函数
func (x, y int) {
fmt.Println(x + y)
fmt.Println("Hello world")
} (10, 20)
}

闭包

闭包=函数+引用环境

package main

import "fmt"

// 闭包

func f1(f func()) {
fmt.Println("this is f1")
f()
}

func f2(x, y int) {
fmt.Println("this is f2")
fmt.Println(x + y)
}

// 定义一个函数对f2进行包装
func f3() func() {
tmp := func () {
fmt.Println("Hello")
}
return tmp
}

func test(x int) {
tmp := func () {
fmt.Println(x) // 先在自己这里面找
}
tmp()
}

func test2(x func (int, int), m, n int) {
tmp := func () {
x (m, n)
}
tmp() // x(m, n)
}

func test3(x func(int, int), m, n int) {
x (m, n)
}

func test4(x func (int, int), m, n int) func() {
tmp := func () {
x (m, n)
}
return tmp
}

func main(){
test(100)
test2(f2, 100, 200)
test3(f2, 100, 200)
ret := test4(f2, 100, 200)
ret()
}

一个函数除了用到它内部定义的语句之外还可以引用它外部的变量

package main

import "fmt"

// 闭包

func f1(f func()) {
fmt.Println("this is f1")
f()
}

func f2(x, y int) {
fmt.Println("this is f2")
fmt.Println(x + y)
}

// 要求：
// f1(f2)
func f3(f func(int, int), x, y int) func() {
tmp := func () {
// fmt.Println(x + y)
// f2()
f(x, y)
}
return tmp
}

// 定义一个函数对f2进行包装
// func f3() func() {
// tmp := func () {
// fmt.Println("Hello")
// }
// return tmp
// }

// func test(x int) {
// tmp := func () {
// fmt.Println(x) // 先在自己这里面找
// }
// tmp()
// }

// func test2(x func (int, int), m, n int) {
// tmp := func () {
// x (m, n)
// }
// tmp() // x(m, n)
// }

// func test3(x func(int, int), m, n int) {
// x (m, n)
// }

// func test4(x func (int, int), m, n int) func() {
// tmp := func () {
// x (m, n)
// }
// return tmp
// }

func main(){
// test(100)
// test2(f2, 100, 200)
// test3(f2, 100, 200)
// ret := test4(f2, 100, 200)
// ret()

ret := f3(f2, 100, 200) // 把原来需要传递两个int 类型的参数包装成一个不需要传参的函数
fmt.Printf("%T\n", ret)
f1(ret)
}

闭包 = 函数 + 外部变量的引用

package main

import "fmt"

// 闭包是什么
// 闭包是一个函数，这个函数包含了它外部作用域的一个变量

// 底层的原理：
// 1. 函数可以作为返回值
// 2. 函数内部查找变量的顺序，先在自己内部找，找不到往外层找

func adder(x int) func(int) int {
// var x int
// var x = 100
return func(y int) int {
x += y
return x
}
}
func main() {
// ret := adder()
ret := adder(100)
ret2 := ret(200)
fmt.Println(ret2)

// var f = adder()
// fmt.Println(f(10)) //10
// fmt.Println(f(20)) //30
// fmt.Println(f(30)) //60

// f1 := adder()
// fmt.Println(f1(40)) //40
// fmt.Println(f1(50)) //90
}

闭包例子

package main

import (
"fmt"
"strings"
)

// 闭包

func makeSuffixFunc(suffix string) func(string) string {
return func(name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
}
return name
}
}

func main() {
jpgFunc := makeSuffixFunc(".jpg")
txtFunc := makeSuffixFunc(".txt")
fmt.Println(jpgFunc("test")) //test.jpg
fmt.Println(jpgFunc("test1.jpg")) //test1.jpg
fmt.Println(txtFunc("test")) //test.txt
fmt.Println(txtFunc("test2.txt")) //test2.txt
}package main

import (
"fmt"
"strings"
)

// 闭包

func makeSuffixFunc(suffix string) func(string) string {
return func(name string) string {
if !strings.HasSuffix(name, suffix) {
return name + suffix
}
return name
}
}

func main() {
jpgFunc := makeSuffixFunc(".jpg")
txtFunc := makeSuffixFunc(".txt")
fmt.Println(jpgFunc("test")) //test.jpg
fmt.Println(jpgFunc("test1.jpg")) //test1.jpg
fmt.Println(txtFunc("test")) //test.txt
fmt.Println(txtFunc("test2.txt")) //test2.txt
}

闭包=函数+引用环境

package main

import "fmt"

// 关键字 函数名(参数)(返回值){}
func calc(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 main() {
f1, f2 := calc(10)
// 修改的是同一个base
fmt.Println(f1(1), f2(2)) //11 9
fmt.Println(f1(3), f2(4)) //12 8
fmt.Println(f1(5), f2(6)) //13 7
}