Go中的函数一些有趣的功能

ghj1976 · · 1584 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

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

 

本文来自:博客园

感谢作者:ghj1976

查看原文:Go中的函数一些有趣的功能

入群交流(和以上内容无关):Go中文网 QQ 交流群:729884609 或加微信入微信群:274768166 备注:入群;关注公众号:Go语言中文网

1584 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传