quot;
)
func main() {
f:=func(args string){
fmt.Println(args)
}
f("hello world")//hello world
//或
(func(args string){
fmt.Println(args)
})("hello world")//hello world
//或
func(args string) {
fmt.Println(args)
}("hello world") //hello world
}
程序返回:
hello world
hello world
hello world
基本上,匿名函数和命名函数用法上并无二致。
闭包(closure)
很多语言都有闭包的概念,简单理解就是函数的嵌套:
package main
import "fmt"
func main() {
a := Fun()
b:=a("hello ")
c:=a("hello ")
fmt.Println(b)//worldhello
fmt.Println(c)//worldhello hello
}
func Fun() func(string) string {
a := "world"
return func(args string) string {
a += args
return a
}
}
程序返回:
worldhello
worldhello hello
这里我们将方法作为参数传递到方法内部执行,这样内层的函数可以使用外层函数的所有变量,即使外层函数已经执行完毕。
延迟函数
延迟其实是延迟(defer)语句,延迟语句被用于执行一个函数调用,在这个函数之前,延迟语句返回:
package main
import "fmt"
func main() {
a := 1
b := 2
defer fmt.Println(b)
fmt.Println(a)
}
程序返回:
1
2
说白了就是一种倒装的形式,非延迟语句先执行,最后再执行延迟语句。
延迟也并不仅仅局限于函数内部语句,延迟一个方法调用也是可以的:
package main
import (
"fmt"
)
type person struct {
firstName string
lastName string
}
func (p person) fullName() {
fmt.Printf("%s %s", p.firstName, p.lastName)
}
func main() {
p := person{
firstName: "go lang",
lastName: "python",
}
defer p.fullName()
fmt.Printf("Welcome ")
}
程序返回:
Welcome go lang python
初始化函数
顾名思义,和Python中的魔法方法init一样,可以提前做一些初始化操作:
package main
import "fmt"
var a int = initVar()
func init() {
fmt.Println("init2")
}
func init() {
fmt.Println("init")
}
func initVar() int {
fmt.Println("init var...")
return 100
}
func main() {
fmt.Println("main...")
}
程序返回:
init var...
init2
init
这里的初始化顺序是:变量初始化->init()->main()
和Python不同的是,每个包可以有多个初始化函数。
结语
归根结底,函数可以被认为是Go lang中的一种数据类型,可以作为另一个函数的参数,也可以作为另一个函数的返回值,使用起来相当灵活,但我们也不能矫枉过正,毫无节制地用函数封装逻辑,造成过度封装的现象。