an anonymous function (also known under the names of a lambda function, a function literal, or a closure), for example: func(x, y int) int { return x + y } Such a function cannot stand on its own (the surrounding function. A closure is a function that captures some external state—for example, the state of the function in which it is created. Another way to formulate this is: a closure inherits the scope declared. That state (those variables) is then shared between the surrounding function and the closure, and the variables survive as long as they are accessible; see the following examples in §6.9. Closures

}(conn) } return <-ch } Monday, October 18, 2010 Principles redux 42 Concurrency and closure examples: Simple - stacks just work; goroutines too cheap to meter Orthogonal - concurrency orthogonal orthogonal to rest of language - orthogonality of functions make closures easy Succinct - go f() - closure syntax clear Safe - no stack overflows - garbage collection avoids many concurrency problems

combination of communication and synchronization is a powerful tool. {Closure, channel} pairs are a nice way to pass work around. The closure says what to do; the channel lets the answer flow directly back

Performance / API friendly GopherLua 交互开销 线程 安全 VM线程开 销 学习 成本 嵌入式Lua虚拟机 Gopherlua VM Pool Closure 隔离 即写即用 One VM One Service, Write Once Run Anywhere 微服务划分 Intervene 干预 Measure 评估 User 用户

模块化设计-复用原则 REP 发布等同原则 (Release/Reuse Equivalency Principle) 软件复用的最小粒度应等同于其发布的最小粒度。 CCP 共同闭包原则 (Common Closure Principle) 为了相同目的而同时修改的类，应该放在同一个模块中。 对大部分应用程序而言，可维护性的重要性远远大于可复 用性，由同一个原因引起的代码修改，最好在同一个模块 中，如

check(err) m, _, err := image.Decode(f) check(err) v := func(n string) int { // helper closure i, _ := strconv.Atoi(r.FormValue(n)) return i } m = moustache(m, v("x"),

is: regexp: concatenation { '|' concatenation } concatenation: { closure } closure: term [ '*' | '+' | '?' ] term: '^' '$' '.' character exit cleanly without disturbing the others. There's no need to do anything else in the deferred closure; calling recover handles the condition completely. Because recover always returns nil unless called each iteration of the loop uses the same instance of the variable v, so each closure shares that single variable. When the closure runs, it prints the value of v at the time fmt.Println is executed, but v

return a + b } } 输出： Call Add2 for 3 gives: 5 The result is: 5 下例为一个略微不同的实现（function_closure.go）： package main import "fmt" func main() { var f = Adder() fmt.Print(f(1), " - ") 或者等待两个协程完成，每一个都会对切片s的一部分进行排序，片段如下： done := make(chan bool) // doSort is a lambda function, so a closure which knows the channel done: doSort := func(s []int){ sort(s) done <- true } i := pivot(s)

内置了映射（map）和切片（slice）类型。 支持多态（polymorphism）。 使用接口（interface）来实现裝盒（value boxing）和反射（reflection）。 支持指针。 支持函数闭包（closure）。 支持方法。 支持延迟函数调用（defer）。 支持类型内嵌（type embedding）。 支持类型推断（type deduction or type inference）。 内存安全。 23 | }() // 不需传递实参。 24 | } 注意，上例中的最后一个匿名函数处于变量x和y的作用域内，所以在它的函 数体内可以直接使用这两个变量。 这样的函数称为闭包（closure）。事实上， Go中的所有的自定义函数（包括声明的函数和匿名函数）都可以被视为闭 包。 这就是为什么Go中的函数使用起来和动态语言中的函数一样灵活。 在后面的文章中，我们将了解到一个匿名函数可以被赋值给某个函数类型的 以后多次调用此匿名函数。 1| package main 2| 3| import "fmt" 4| 5| func main() { 6| // 此函数返回一个函数类型的结果，亦即闭包（closure）。 7| isMultipleOfX := func (x int) func(int) bool { 8| return func(n int) bool { 9|

内置了映射（map）和切片（slice）类型。 支持多态（polymorphism）。 使用接口（interface）来实现裝盒（value boxing）和反射（reflection）。 支持指针。 支持函数闭包（closure）。 支持方法。 支持延迟函数调用（defer）。 支持类型内嵌（type embedding）。 支持类型推断（type deduction or type inference）。 内存安全。 x*x + y*y = 25 }() // 不需传递实参。 } 注意，上例中的最后一个匿名函数处于变量x和y的作用域内，所以在它的函数 体内可以直接使用这两个变量。 这样的函数称为闭包（closure）。事实上，Go 中的所有的自定义函数（包括声明的函数和匿名函数）都可以被视为闭包。 这 就是为什么Go中的函数使用起来和动态语言中的函数一样灵活。 在后面的文章中，我们将了解到一个匿名函数可以被赋值给某个函数类型的 函数类型的变量，从而可以在 以后多次调用此匿名函数。 package main import "fmt" func main() { // 此函数返回一个函数类型的结果，亦即闭包（closure）。 isMultipleOfX := func (x int) func(int) bool { return func(n int) bool { return