Go中的函数
函数是Go里面的核心设计，它通过关键字func来申明，他的格式如下
func funcname(input1 type1, input2 type2) (output1 type1, output2 type2) {
//这里是处理逻辑代码
//返回多个值
return value1, value2
}
函数有以下特征：
- 关键字func用来申明一个函数funcname，匿名函数可以没有funcname。
- 函数可以有一个或者多个参数，每个参数后面带有类型，通过,分隔
- 函数可以返回多个值
- 上面返回值申明了两个变量output1和output2，如果你不想申明也可以，直接就两个类型
- 如果只有一个返回值且不申明返回值变量，那么你可以省略用以包括返回值的括号
- 如果没有返回值，那么就直接省略最后的返回信息
函数作为值、类型
在Go中函数也是一种变量，我们可以通过type来定义他，他的类型就是所有拥有相同的参数，相同的返回值的一种类型 type type_name func(input1 inputType1 [, input2 inputType2 [, ...]) (result1 resultType1 [, ...])
函数作为类型到底有什么好处呢？那就是可以把这个类型的函数当做值来传递，请看下面的例子。
package main
import "fmt"
type test_int func(int) bool //申明了一个函数类型
func isOdd(integer int) bool {
if integer%2 == 0 {
return false
}
return true
}
func isEven(integer int) bool {
if integer%2 == 0 {
return true
}
return false
}
//申明的函数类型在这个地方当做了一个参数
func filter(slice []int, f test_int) []int {
var result []int
for _, value := range slice {
if f(value) {
result = append(result, value)
}
}
return result
}
func main(){
slice := []int {1, 2, 3, 4, 5, 7}
fmt.Println("slice = ", slice)
odd := filter(slice, isOdd) //函数当做值来传递了
fmt.Println("Odd elements of slice are: ", odd)
even := filter(slice, isEven)//函数当做值来传递了
fmt.Println("Even elements of slice are: ", even)
}
函数当做值和类型在我们写一些通用接口的时候非常有用，通过上面例子我们看到test_int这个类型是一个函数类型，然后两个filter函数的参数和返回值与test_int类型是一样的，但是我们可以实现很多种的逻辑，这样使得我们的程序变得非常的灵活。
函数返回值是函数的情况
技术参考： http://www.cnblogs.com/cool-xing/archive/2012/05/19/2509176.html
假如你拥有一份吃过寿司的人的清单, 你是否能够根据人名确定他是否在清单上? 这是个很简单的问题, 你只需遍历清单. 嗯, 如果你go的功底很弱, 不知道怎么遍历清单那怎么办? 没关系, 我会给你提供一个刷选器:
func Screen(patients []string) func(string) bool {
// 定义匿名函数并返回
return func(name string) bool {
for _, soul := range patients {
if soul == name {
return true
}
}
return false
}
}
Screen方法会将刷选的函数返回给调用方, 这样你就可以不用懂怎么去遍历清单了, 你只需调用我返回给你的函数就可以:
// 吃过寿司的人的清单
those_who_bought_sushi := []string{"Anand", "JoJo", "Jin", "Mon", "Peter", "Sachin"}
// 得到刷选器函数
bought_sushi := Screen(those_who_bought_sushi)
// 调用刷选器函数就可以知道某人是否在清单上
fmt.Println(bought_sushi("Anand")) // true
fmt.Println(bought_sushi("Alex")) // false
闭包
地球人都知道：函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。go语言中函数可以作为另一个函数的参数或返回值，可以赋给一个变量。函数可以嵌套定义（使用匿名函数），即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题。如：
package main
import "fmt"
func ExFunc(n int) func() {
sum:=n
return func () { //把匿名函数作为值赋给变量a (Go 不允许函数嵌套。
//然而你可以利用匿名函数实现函数嵌套)
fmt.Println(sum+1) //调用本函数外的变量
} //这里没有()匿名函数不会马上执行
}
func main() {
myFunc:=ExFunc(10)
myFunc() // 11
myAnotherFunc:=ExFunc(20)
myAnotherFunc() //21
myFunc() //11
myAnotherFunc() //21
}
这里执行结果:
11
21
11
21
在这段程序中，匿名函数是函数ExFunc的内嵌函数，并且是ExFunc函数的返回值。我们注意到一个问题：这里的匿名内嵌函数中引用到外层函数中的局部变量sum，Go会这么处理这个问题呢？先让我们来看看这段代码的运行结果。当我们调用分别由不同的参数调用ExFunc函数得到的函数时（myFunc()，myAnotherFunc()），得到的结果是隔离的，也就是说每次调用ExFunc函数后都将生成并保存一个新的局部变量sum。其实这里ExFunc函数返回的就是闭包。
按照命令式语言的规则，ExFunc函数只是返回了内嵌函数InsFunc的地址，在执行InsFunc函数时将会由于在其作用域内找不到sum变量而出错。而在函数式语言中，当内嵌函数体内引用到体外的变量时，将会把定义时涉及到的引用环境和函数体打包成一个整体（闭包）返回。现在给出引用环境的定义就容易理解了：引用环境是指在程序执行中的某个点所有处于活跃状态的约束（一个变量的名字和其所代表的对象之间的联系）所组成的集合。闭包的使用和正常的函数调用没有区别。
由于闭包把函数和运行时的引用环境打包成为一个新的整体，所以就解决了函数编程中的嵌套所引发的问题。如上述代码段中，当每次调用ExFunc函数时都将返回一个新的闭包实例，这些实例之间是隔离的，分别包含调用时不同的引用环境现场。不同于函数，闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。
闭包函数是把创建时，引用到的外部数据复制了一份，与函数一起组成了一个整体。
闭包函数出现的条件：
1.被嵌套的函数引用到非本函数的外部数据，而且这外部数据不是“全局变量”
2.函数被独立了出来(被父函数返回或赋值给其它函数或变量了)
回来看闭包的定义：闭包是什么，闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)。
对象是附有行为的数据，而闭包是附有数据的行为
参考： http://www.cnblogs.com/Jifangliang/archive/2008/08/05/1260602.html
http://blog.sina.com.cn/s/blog_487109d101018fcx.html
package main
import "fmt"
func ExFunc(n int) func() {
sum := n
a := func() {
sum++ //在这里对外部数据加1
fmt.Println(sum)
}
return a
}
func main() {
myFunc := ExFunc(10)
myFunc()
myAnotherFunc := ExFunc(20)
myAnotherFunc()
myFunc()
myAnotherFunc() //这里得出的结果是22，由此可以证明两点
//1.闭包中对外部数据的修改，外部不可见
//2.外部数据的值被保存到新建的静态变量中
}
试验
看下面几种情况，对比执行结果
package main
import"fmt"
func main(){
var j int=5
a:=func()func(){
var i int=10
fmt.Printf("\neeee:%d\n",j)
return func(){
fmt.Printf("i,j:%d,%d\n",i,j)
}
}()
a()
j*=2
a()
}
执行结果：
eeee:5
i,j:10,5
i,j:10,10
exit code 0, process exited normally.
例子二
package main
import"fmt"
func main(){
var j int=5
a:=func()func(){
var i int=10
fmt.Printf("\neeee:%d\n",j)
return func(){
fmt.Printf("i,j:%d,%d\n",i,j)
}
}
a()
j*=2
a()
}
执行结果：
eeee:5
eeee:10
exit code 0, process exited normally.
例子三
package main
import"fmt"
func main(){
var j int=5
a:=func() func(){
var i int=10
fmt.Printf("\neeee:%d\n",j)
return func(){
fmt.Printf("i,j:%d,%d\n",i,j)
}
}
a()()
j*=2
a()()
}
执行结果：
eeee:5
i,j:10,5
eeee:10
i,j:10,10
exit code 0, process exited normally.
参考资料：
https://github.com/astaxie/build-web-application-with-golang/blob/master/02.3.md