Go實戰--Closures in golang(匿名函式、閉包)
號外!!號外!!
在拉勾網上搜索go的職位(北京):
2017年2月14日搜尋結果:119個
2017年6月19日搜尋結果:163個
2018年1月31日搜尋結果:268個
生命不止,繼續 go go go !!!
曾記得,某年某月某日,去快手面試。面試官的第一個問題就是:
面試官:“什麼是閉包,說一說對閉包的理解”
答:“lambda表示式,其他的不太清楚”
面試官:“lambda表示式是實現閉包的一種方式。”
面試官:“閉包的概念是從JavaScript中開始的”(正確與否,值得商榷)。
今天就聊聊golang中的閉包。
何為匿名函式
匿名函式的英文表示是:Anonymous functions
Functions with name are named functions!
說白了,匿名函式是指不需要定義函式名的一種函式實現方式,它並不是一個新概念,最早可以回溯到1958年的Lisp語言。
c++中的匿名函式:
auto a_lambda_func = [](int x)
js總的匿名函式:
function(argument1,argument2){
}
golang中匿名函式
定義匿名函式
func(x,y int) int {
return x + y
}
匿名函式作為返回值
func getPrintMessage() func(string) {
// returns an anonymous function
return func(message string) {
fmt.Println(message)
}
}
匿名函式付給變數
f := func() int {
...
}
返回多個匿名函式
func calc(x, y int) (func(int), func()) {
f1 := func(z int) int {
return (x + y) * z / 2
}
f2 := func() int {
return 2 * (x + y)
}
return f1, f2
}
完整程式碼:
package main
import "fmt"
func printMessage(message string) {
fmt.Println(message)
}
func getPrintMessage() func(string) {
// returns an anonymous function
return func(message string) {
fmt.Println(message)
}
}
func main() {
// named function
printMessage("Hello function!")
// anonymous function declared and called
func(message string) {
fmt.Println(message)
}("Hello anonymous function!")
// gets anonymous function and calls it
printfunc := getPrintMessage()
printfunc("Hello anonymous function using caller!")
}
輸出:
Hello function!
Hello anonymous function!
Hello anonymous function using caller!
何為閉包
關於閉包的概念,有些抽象。
WIKI:
In programming languages, closures (also lexical closures or function closures) are techniques for implementing lexically scoped name binding in languages with first-class functions.
A closure is a function value that references variables from outside its body.
個人理解:
閉包就是能夠讀取其他函式內部變數的函式。
只有函式內部的子函式才能讀取區域性變數,因此可以把閉包簡單理解成”定義在一個函式內部的函式”。
golang中使用閉包
package main
import "fmt"
func outer(name string) {
// variable in outer function
text := "Modified " + name
// foo is a inner function and has access to text variable, is a closure
// closures have access to variables even after exiting this block
foo := func() {
fmt.Println(text)
}
// calling the closure
foo()
}
func main() {
outer("hello")
}
返回閉包
package main
import "fmt"
func outer(name string) func() {
// variable
text := "Modified " + name
// closure. function has access to text even after exiting this block
foo := func() {
fmt.Println(text)
}
// return the closure
return foo
}
func main() {
// foo is a closure
foo := outer("hello")
// calling a closure
foo()
}
Closures and state
package main
import "fmt"
func counter(start int) (func() int, func()) {
// if the value gets mutated, the same is reflected in closure
ctr := func() int {
return start
}
incr := func() {
start++
}
// both ctr and incr have same reference to start
// closures are created, but are not called
return ctr, incr
}
func main() {
// ctr, incr and ctr1, incr1 are different
ctr, incr := counter(100)
ctr1, incr1 := counter(100)
fmt.Println("counter - ", ctr())
fmt.Println("counter1 - ", ctr1())
// incr by 1
incr()
fmt.Println("counter - ", ctr())
fmt.Println("counter1- ", ctr1())
// incr1 by 2
incr1()
incr1()
fmt.Println("counter - ", ctr())
fmt.Println("counter1- ", ctr1())
}
陷阱
package main
import "fmt"
func functions() []func() {
// pitfall of using loop variables
arr := []int{1, 2, 3, 4}
result := make([]func(), 0)
for i := range arr {
result = append(result, func() { fmt.Printf("index - %d, value - %d\n", i, arr[i]) })
}
return result
}
func main() {
fns := functions()
for f := range fns {
fns[f]()
}
}
輸出:
index - 3, value - 4
index - 3, value - 4
index - 3, value - 4
index - 3, value - 4
斐波拉切數列
package main
import "fmt"
// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
x, y := 0, 1
return func() int {
x, y = y, x+y
return x
}
}
func main() {
f := fibonacci()
for i := 0; i < 10; i++ {
fmt.Println(f())
}
}