函数也可以赋值给变量,存储在数组、切片、映射中,也可作为参数传递给函数或作为函数返回值进行返回
通过函数类型,我们也可以定义一些集合类型,比如切片的映射的
函数类型的意义:
函数类型可以把函数作为参数传递到其他的函数中
1 函数类型
函数类型:由参数的数量和他的类型,还有返回值的数量和类型组成
package main
import "fmt"
func add(a, b int) int {
return a + b
}
func main() {
c := add
fmt.Printf("%T\n", c)
}
通过输出我们可以看到,函数本身也是一个类型
1.1 定义函数类型
package main
import "fmt"
func main() {
// 定义函数类型
var f func(int, int) int
fmt.Printf("%T\n", f)
}
这个函数类型的 f 有什么用呢,我们就可以将 add 函数赋值给 f,f 就可以调用 add 函数中的形参和返回值
package main
import "fmt"
func add(a, b int) int {
return a + b
}
func main() {
// 定义函数类型
var f func(int, int) int
// 将 add 函数赋值给 f
f = add
fmt.Printf("type = %T\nvalue = %v\n", f, f(1, 2))
}
也可以这样赋值
package main
import "fmt"
func add(a, b int) int {
return a + b
}
func main() {
// 定义函数类型
var f func(int, int) int = add
fmt.Printf("type = %T\nvalue = %v\n", f, f(1, 2))
}
1.1.1 定义函数切片
package main
import "fmt"
func add(a, b int) int {
return a + b
}
func mul(a, b int) int {
return a * b
}
func main() {
// 定义函数切片
var fs []func(int, int) int
// append 追加 add 和 mul 函数
fs = append(fs, add, mul)
// for-range 变量 fs ,由于 fs 是一个切片,所以 fs 的元素就是对应的每个函数
// 将 fs 的元素赋值给 f
for _, f := range fs {
// 给 f 这个函数传递 2,3
// 第一次调用 add 函数
// 第二次调用 mul 函数
fmt.Println(f(2, 3))
}
}
1.1.2 声明&调用参数类型为函数的函数
函数类型
func(参数类型列表) 返回值类型列表
传递一个函数到另一个函数中的时候,形参函数的类型、返回值与传递函数的类型、返回值要相同
函数形参的定义不需要定义名字,只需要定义函数的类型
package main
import "fmt"
// print 函数形参为 fmts 函数类型为 func(string) string
// args 可变参数的 string 类型
func print(fmts func(string) string, args ...string) {
// 遍历 args 取出对应的值
for i, v := range args {
// 再将 args 的值取出来传递给 fmts 函数
fmt.Println(i, fmts(v))
}
}
// 定义 star 函数类型维 func(string) string
func star(txt string) string {
return "*" + txt + "*"
}
func main() {
// 定义 names 切片
names := []string{"zz", "kk", "17"}
// 调用 print 函数,传入 start 函数和 names 切片解包后的值
// star 传给 fmts 函数
// names... 传递给 args
print(star, names...)
}
1.1.3 函数返回值是一个函数类型
作为返回值的时候,需要返回的函数类型和返回值相等
package main
import (
"fmt"
"math/rand"
"time"
)
func sayHi() {
fmt.Println("Hi")
}
func sayHello() {
fmt.Println("hello")
}
// 返回值为 func() 函数
func genFunc() func() {
// 随机数取模 2 == 0 时候 return sayHi ,否则 return sayHello
if rand.Int()%2 == 0 {
return sayHi
} else {
return sayHello
}
}
func main() {
// 种子
rand.Seed(time.Now().UnixNano())
f := genFunc()
f()
}
范例二:
package main
import "fmt"
// 定义返回值为 func(int, int) int
func test(srt string) func(int, int) int {
fmt.Print(srt)
return intr
}
func intr(a, b int) int {
return a + b
}
func main() {
// f 为 func(int, int) int
f := test("值等于:")
fmt.Println(f(1, 2))
}
范例三:
package main
import "fmt"
func print(fmts func(string) string, args ...string) func(int, int) int {
for i, v := range args {
fmt.Println(i, fmts(v))
}
return intr
}
func star(txt string) string {
return "♥" + txt + "♥"
}
func intr(a, b int) int {
fmt.Println("intr 函数结果:")
return a + b
}
func main() {
names := []string{"77", "拦截", "zz"}
// 返回值函数赋值给 res = func(int, int) int
// 并且 print 函数里面的代码也会执行
res := print(star, names...)
// 输出的时候给 res 赋值 1,2
fmt.Println(res(1, 2))
}
通过调用函数,实现字符分割
package main
import (
"fmt"
"strings"
)
// 定义 函数 aFields 类型为 func(rune) bool
func aFields(split rune) bool {
if split == 'a' {
return true
} else {
return false
}
}
func main() {
// 输出 strings.FieldsFunc 函数,第一个参数为 string ,第二个参数必须为 func(rune) bool
fmt.Printf("%q\n", strings.FieldsFunc("abcdef", aFields))
}
把 a 进行分割
当然这个代码还能够优化
很多时候代码会写得很长,但是我们只需要一句话就可以将代码写完
package main
import (
"fmt"
"strings"
)
func aFields(split rune) bool {
// 由于返回值为 bool 类型,所以这里直接 split == a 默认就为 真,否则为 false
return split == 'a'
}
func main() {
fmt.Printf("%q\n", strings.FieldsFunc("abcdef", aFields))
}
也可以简写成匿名函数
package main
import (
"fmt"
"strings"
)
func main() {
fmt.Printf("%q\n", strings.FieldsFunc("abcdef",
func(split rune) bool {
return split == 'a'
}))
}
1.2 匿名函数
不需要定义名字的函数叫做匿名函数,常用做帮助函数在局部代码块中使用或作为其他函数的参数
匿名函数是没有名字得,一般用来赋值给变量的,只能使用在函数内部
1.2.1 匿名函数定义
很多时候我们定义完了函数只需要使用一次,不具有代码的复用性,当我们临时使用的时候就可以使用 匿名函数
package main
import "fmt"
func main() {
// 定义一个 c 类型为 func()
c := func() {
}
fmt.Printf("%T\n", c)
}
通过输出我们会发现 c 是一个 func()
类型
匿名函数赋值和使用
package main
import "fmt"
func main() {
// 定义函数,变量为 c
c := func() {
fmt.Println("我是匿名函数")
}
// 使用 c 函数
c()
fmt.Printf("%T\n", c)
}
使用范例二
package main
import "fmt"
func print(fmts func(string) string, args ...string) {
for i, v := range args {
fmt.Println(i, fmts(v))
}
}
func main() {
names := []string{"77", "kk", "zz"}
// 定义 star 匿名函数,类型为 func(string) string
// star 标识符只能在 main 函数内部使用
star := func(txt string) string {
return "*" + txt + "*"
}
// 传递给 print 函数
print(star, names...)
}
简写直接函数传递
package main
import "fmt"
func print(fmts func(string) string, args ...string) {
for i, v := range args {
fmt.Println(i, fmts(v))
}
}
func main() {
names := []string{"77", "kk", "zz"}
// 传递给 print 函数
// 直接传递 函数 func(s string) string { return "*" + s + "*" }
print(func(s string) string {
return "*" + s + "*"
}, names...)
}
1.2.3 函数直接调用
匿名函数直接使用
package main
import "fmt"
func main() {
// 由于这个变量没有使用变量来接收,所以需要使用 () 自我调用
func() {
fmt.Println("我是匿名函数")
}() // 后面加上 () 表示直接调用
}
1.3 闭包
匿名函数有叫闭包, 是指在函数内定义的匿名函数引用外部函数的变量,只要匿名函数继续使用则外部函数赋值的变量不被自动销毁
如果使用不严谨的话会导致内存泄漏
addBase
: 函数执行完以后,这个 addBase
函数中的 base
应该释放掉,函数内部引用函数外部的变量,使函数外部的变量生命周期发生了变化这就是闭包
变量生命周期:指的是变量生成的时候到死亡的时间
package main
import "fmt"
// 生成一个函数
// 定义 addBase(int) func(int) int
// 返回值函数 num + base
func addBase(base int) func(int) int {
// 在函数内部引用函数外部的变量
// 当我们内部的函数返回的时候内,其实外部的这个 base 变量不能及时销毁
// 所以我们在返回函数里面就要添加 base 变量
return func(num int) int {
return base + num
}
}
func main() {
// add2 = func(int) int
add2 := addBase(2)
fmt.Printf("%T\n", add2)
fmt.Println(add2(10))
}