号外！！号外！！
在拉勾网上搜索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())
}
}引用：
http://keshavabharadwaj.com/2016/03/31/closure_golang/
