函数是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