[关闭]
@aliasliyu4 2016-11-19T08:39:46.000000Z 字数 8504 阅读 4873

golang语言中的函数类型（翻译）

    多数的开发者对ruby，javascript，或者python这种暴露高阶函数的动态语言是熟悉的。对于这些具有脚本背景的开发者，这是很难转换成go的把那些概念，因为go的类型系统似乎就是一个阻碍。另外一面，这些问题也许是相反的，对于哪些具有静态类型背景，原生的面向对象语言比如c++，或者java，静态类型系统是少一些绊脚石的。但是高阶函数的使用也似乎缺少直观性。程序员对函数的经验，大部分的认知留下的印象可能是非常缺乏想象力的。但是非常有益的是，这篇文章至少会阐述如何去使用go的类型系统中有关functions的概念。

    这这篇文章中，我们将看几个函数类型在go中非常有用的例子。读者不需要假定是一个经验老道的go开发者，只要大概的一些关于go的知识，在理解这篇文章上就会变的非常有用。

匿名函数和闭包

    马上，go支持匿名函数和闭包，对我来说，go对匿名函数的支持是很容易让人联想起javascript对匿名函数的支持，但是它不是python的lambads（仅仅是一条语句）对匿名函数脆弱的支持，或者是ruby的套件那样有很多种方式去创建闭包（我不是ruby的粉丝，因此像这样 proc/block/lambda/Method 的事情对我来说是非常复杂）。不管怎么说，在go中声明匿名函数是非常的轻量：

  1. func(){
  2.     fmt.Println("hello")
  3. }
    匿名函数只是作为一个表达式,那是非常没有意义的，通常来说，你想的是它被存到一个变量中，插入到数据结构里，或者把它传递到另外的函数当中。常常看到以下这种类型的代码出现在go中：

  1. fn := func(){
  2.     fmt.Println("hello")
  3. }
    我们现在有一个变量fn，它是一个function；它的类型是func()。它能像其他的任何函数一样被调用，通过表达fn(),或者赋值给你感兴趣的其他func()。当然，因为我们有对闭包的支持，我们也能引用一些定义在函数作用域当中的数据。

  1. x := 5
  2. fn := func(){
  3.     fmt.Println("x is",x)
  4. }
  5. fn()
  6. x++
  7. fn()

以上代码片段的输出如下：

  1. x is 5
  2. x is 6

run that example here
到目前为止，这些看上去非常像javascript中我们看到的匿名函数一样，而不是静态类型所具有的独特。

函数集合

    当然，我们能够使用函数在所有我们能使用常规数据类型的地方。我们确实可以这样，创建一个函数切片，随机选取一个函数，然后执行它.我们定义了binFunc类型，它是一个二元一次函数，带有两个参数x,y，然后返回一个整数结果。对于这个例子来说这些都不是非常必要的。但是输入binFunc比一而再到处可以看到输入func(int,int) int 是更加方便的。

  1. type binFunc fun(int, int) int
  2. func main() {
  3.     // seed your random number generator.
  4.     rand.Seed(time.Now().Unix())
  6.     // create a slice of functions
  7.     fns := []binFunc{
  8.         func(x, y int) int { return x + y },
  9.         func(x, y int) int { return x - y },
  10.         func(x, y int) int { return x * y },
  11.         func(x, y int) int { return x / y },
  12.         func(x, y int) int { return x % y },
  13.     }
  15.     // pick one of those functions at random
  16.     fn := fns[rand.Intn(len(fns))]
  18.     // and execute it
  19.     x, y := 12, 5
  20.     fmt.Println(fn(x, y))
  21. }

（run this example）
当然，这个例子是很作的，但是它阐述了go的核心概念：函数是一等公民（first class）

函数字段

    同样的，我们可能感兴趣把function类型用在结构体的字段上。这样做允许我们对一个函数加上一些额外的信息，比如运行时可以获取的标签。

  1. type op struct {
  2.     name string
  3.     fn func(int, int) int
  4. }
  6. func main(){
  7.     // send your random  number generator
  8.     rand.Seed(time.Now().Unix())
  10.     //create a slice of ops
  11.     ops := []op{
  12.         {"add",func(x, y int) int {return x+y}},
  13.         {"sub",func(x, y int) int {return x-y}},
  14.         {"mul" func(x, y int) int {return x*y}},
  15.         {"div" func(x, y int) int {return x/y}},
  16.         {"mod" func(x, y int) int {return x%y}},
  17.     }
  19.     //pick one of these ops at random
  20.     o := ops[rand.Intn(len(ops))]
  21.     x, y := 12, 5
  22.     fmt.Println(o.name, x, y)
  23.     fmt.Println(o.fn(x, y))
  24. }

function也能被存在map中，所以你也可以用map[string]binFunc做一些跟上面这个例子相似的事情。

递归函数类型

    另外关于函数类型有趣的概念是它允许我们定义递归函数类型，他是一种操作自己本身的函数类型。就是说它既是函数的参数也是函数的返回值。使用这个技术你能做很多事情如果设计这样的函数是困难的，因此为了说明清楚，我已经设计了一种执行“随机步”的递归函数。是的，这是一个经过完整设计的例子，我们将看到一个walk函数，它具有一个整形指针参数，并且返回walk函数。

  1. type walkFn func(*int) walkFn

这个函数的预期是去增加这个指针所指向的值。然后返回一个函数描述了下一步要执行的内容。以下的walkEqual是一个有效的walkfn函数的实例：

  1. func walkEqual(i *int) walkFn{
  2.     *i += rand.Intn(7) - 3
  3. }

这个函数运行起来的效果会是i所指向的整数会随机的+-3，然后函数的返回值是它自己。我们将会在下面执行这个随机函数。

当然，这是非常有趣的。让我们嵌套两个以上的函数，walkForward和walkBackward,这个会保证我们往前走（正数）的方向，和往后走（负数）的方向。每一个函数都会执行它自己，然后随机返回两者中的一个。我们开启一个小的但是完整的叫做pickRandom的函数。它将随机的选择一个作为输入函数，并且返回它。

  1. func pickRandom(fns ...walkFn) walkFn {
  2.     return fns[rand.Intn(len(fns))]
  3. }
  5.  然后我们定义的三个walk函数，如下所示：
  6. package main
  8. import (
  9.     "fmt"
  10.     "math/rand"
  11.     "time"
  12. )
  14. type walkFn func(*int) walkFn
  16. func pickRandom(fns ...walkFn) walkFn {
  17.     return fns[rand.Intn(len(fns))]
  18. }
  20. func walKEqual(i *int) walkFn {
  21.     *i += rand.Intn(7) - 3
  22.     return pickRandom(walkForward, walkBackward)
  23. }
  25. func walkForward(i *int) walkFn {
  26.     *i += rand.Intn(6)
  27.     return pickRandom(walKEqual, walkBackward)
  28. }
  30. func walkBackward(i *int) walkFn {
  31.     *i += -rand.Intn(6)
  32.     return pickRandom(walKEqual, walkForward)
  33. }
  35. func main() {
  36.     // time is frozen on playground, so this is actually always
  37.     // the same.  The behavior is different when run locally.
  38.     rand.Seed(time.Now().Unix())
  39.     fn, progress := walKEqual, 0
  40.     for i := 0; i < 20; i++ {
  41.         fn = fn(&progress)
  42.         fmt.Println(progress)
  43.     }
  44. }
  46. random output:
  47.     2
  48.     1
  49.     6
  50.     6
  51.     7
  52.     2
  53.     6
  54.     2
  55.     7
  56.     6
  57.     8
  58.     11
  59.     13
  60.     13
  61.     11
  62.     16
  63.     15
  64.     17
  65.     22
  66.     17

以上这个例子是不太合理的设计，因此我们要做的是关注递归函数的机制，在标准库中，这个技术被用在text／template中生成lexer。

函数类型作为接口的值

    在go中函数类型可以有方法，这是很难去看到的，首先，为什么这是有用的。这里有两个方面的影响对于函数类型在go能有方法的事实。第一：因为任意类型能有防范就能满足接口，在go中函数类型也可能封装成有效的接口类型，第二：在go中方法既可以是指针或者值接收者，我们能使用函数指针的方法切换这个函数之乡的方法调用的上下文。这样说是有点让人兴奋的，所以让我们看两个事实。
    首先，最明显的做法是，使得一个函数类型满足一个接口是选择一个接口只有一个方法。实现它是简单的。让我们定义一个add function就想我们上面做过的，但是我们也给它一个Error() string方法，在go中任何类型具有Error() string方法就是有效的error类型，所以我们的函数既是一个function也是一个error。你可以运行这个没什么用处的例子在你的终端上：

  1. package main
  3. import(
  4.     "fmt"
  5. )
  7. type binFunc func(int, int) int
  9. func add(x, y int) int {return x+y}
  11. func (f binFunc) Error() string {return "binFunc error"}
  13. func main() {
  14.     var err error
  15.     err = binFunc(add)
  16.     fmt.Println(err)
  17. }

以上这个例子真的是没什么用处，我们不得不去执行类型转换，转换类型是func(int, int) int的add函数成binFunc。这个看上去像是繁重的性能损耗在go运行时，但是如果有另外一个有效的方式把 func(int, int) int转换成实现error：

  1. type loudBinFunc func(int, int) int
  3. func (f loudBinFunc) Error() string{
  4.     return "THIS ERROR IS A LOT LOUDER"
  5. }
    如果binFunc和loudBinFunc都定义了，运行时就不会知道如何去转换我们的add函数。及时接口只有一个有效的实现被给定的类型，运行时也不会自动的执行转换。它看上去是烦恼的，但是也使得写出没有bug的代码变的更容易。在标准库的net／http包中，我们能看到使用函数类型的实现接口的例子，http.Handler类型被用在标准库中注册http.handlers的接口。

  1. type Handler interface{
  2.     ServerHTTP(ResponseWriter, *Request)
  3. }
    这里还有一种http.HandlerFunc类型，它只是包装了func（http.ResponseWriter, *http.Request）以满足http,Handler。这就使得我们可以用一个函数或者一个结构体去作为一个web的handler。最终的结果是我们同时获得了http.Handler和http.HandleFunc函数，使得写web的handler是更加的方便。
    现在我们知道如何建立函数的方法从而允许我们去实现一个接口，我将展示一点难懂用法也是被证明非常有用的，让我们截取一些在json文档中的函数，在标准库的encoding/json包是一般的方法用来编码和解码json文档。这个包是简历在接口的基础之上，它定义了一个json.Unmarshaler接口，用来去反序列化json文档：

  1. type Unmarshaler interface{
  2.     UnmarshalJSON([]bye) error
  3. }
    如果你定义了这个方法，  encoding/json包就会使用它去解析json数据，另外，它也试图去弄清楚自己要做什么（一般都是正确的），让我们拿出binFunc的例子，但是这次，我么要贴一些二元函数在json文档中，我们开始是老的binFunc定义：

  1. type binFunc func(int, int) int

因为函数本身没有任何持久化的数据，我们需要一个地方去注册名字。我们用map[string]binFunc去储存和我们函数相关的名字：

  1. var fnRegistry = map[string]binFunc{
  2.     "add": func(x, y int) int { return x + y },
  3.     "sub": func(x, y int) int { return x - y },
  4.     "mul": func(x, y int) int { return x * y },
  5.     "div": func(x, y int) int { return x / y },
  6.     "mod": func(x, y int) int { return x % y },
  7. }
    在go中，如果我们试图用不存在的key从map中获得value，这种操作将返回一个“0”值。对于一个函数类型，零值就意味着nil，我们只要做一个测试，赋一个nil去看我们将得到什么，现在我们要在binFunc类型上实现UnmarshalJSON方法。因为我们想要现在调用这个函数的看到一些不一样的。用指针类型实现UnmarshalJSON,并且因为我们知道我们想要一个字符串，我们只要托载一些存在的反序列化去兼容标准的json包。
    有了这些定义，我们就能从json文档中反序列化到binFunc。接下来就是一个相对完整的例子。

  1. package main
  3. import(
  4.     "encoding/json"
  5.     "fmt"
  6.     "log"
  7.     "math/rand"
  8.     "time"
  9. )
  11. var jsonDoc = []byte(`["add", "sub", "mul", "div"]`)
  13. var registry = map[string]binFunc{
  14.     "add": func(x, y int) int { return x+y},
  15.     "sub": func(x, y int) int { return x-y},
  16.     "mul": func(x, y int) int { return x*y},
  17.     "div": func(x, y int) int { return x/y},
  18. }
  20. type binFunc func(int, int) int
  22. //实现了下面这个方法就可以自己反序列化自己
  23. func (fn *binFunc) UnmarshalJSON(b []byte) error{
  24.     var name string
  25.     if err := json.Umarshal(b, &name); err != nil {
  26.         return err
  27.     }
  29.     // get the function out of our function registry
  30.     found := registry[name]
  31.     if found == nil {
  32.         // return a descriptive error if we can't find the function
  33.         return fmt.Errorf("unknow function in (*binFunc)UnmarshalJSON: %s", name)
  34.     }
  35.     // dereference the pointer receiver, so that the changes are visible to the caller
  36.     *fn = found
  37.     return nil
  38. }
  40. func main() {
  41.     rand.Seed(time.Now().Unix()) 
  42.     var fns []binFunc
  43.     if err := json.Unmarshal(jsonDoc, &fns); err != nil {
  44.         log.Fatal(err)
  45.     }
  46.     fn := fns[rand.Intn(len(fns))]
  47.     x := fn(12, 5)
  48.     fmt.Println(x)
  49. }

函数和channel

最后这个模式在go中是非常的特别的，而且这是你用channel组合函数发生的结果。完整的解释go的并发模型超出本文的范围。但是如果不想要雨里雾里对此，我推荐阅读这篇文章the concurrency section in effective go,如果还有时间，看看这个非常棒的google io，go concurrency patterns,从先前的观点，一些关于go的知识还是要假设存在的。

    因为channel是go的原语，并且我们能用其他的类型组成channel，我们甚至能用function组成channel，因为函数可以匿名，并且函数也可以闭包，用这个三个属性我们就可以组合成匿名闭包channel，对于这个channel类型的定义，可以让我们很容易意识到：chan func().保持住这篇文章的主题，让我们创建一个切片函数，但我们会让每一个函数都闭包：

  1. x := 10
  2. fns := []func(){
  3.     func() { x += 1 },
  4.     func() { x -= 1 },
  5.     func() { x *= 2 },
  6.     func() { x /= 2 },
  7.     func() { x *= x },
  8. }
    我们也捕捉我们之前看到过的代码片段，并且给出一种随机获取函数的机制：

  1. func pickFunc(fns ...func()) func() {
  2.     return fns[rand.Intn(len(fns))]
  3. }
    接下来，我们定义一个func（）类型的channel：

  1. c := make(chan func())
    并且我们定义了一个拿它自己当参数的函数channel的函数，数量描述了需要写入这个channel的函数的个数，然后就是一组候选函数。
    在这个函数开始的时候，我们用defer close(c)确保我们在生产完数据之后关闭channel。在这里我们只使用常规的for循环，使用pickFunc随机获取一个函数，然后将我们给到的function写入channel，在接收端，我们使用range去读取channel中的值，取到值之后就立刻执行这个函数，通过在每一次读取值之后添加休眠函数，我们可以为任意闭包函数实现速率控制。

  1. for fn := range c {
  2.     fn()
  3.     fmt.Println(x)
  4.     time.Sleep(delay)
  5. }

将这些放在一起，我们得到了下面的程序：

  1. package main
  3. import(
  4.     "fmt"
  5.     "math/rand"
  6.     "time"
  7. )
  8. var delay = 200*time.Millisecond
  10. func pickFunc(fns ...func()) func(){
  11.     return fns[rand.Intn(len(fns))]
  12. }
  14. func produce(c chan func(), n int, fns ...func()){
  15.     defer close(c)
  16.     for i := 0; i < n; i++ {
  17.         c <- pickFunc(fns...)
  18.     }
  19. }
  21. func main() {
  22.     // time is varibal
  23.     rand.Seed(time.Now().Unix())
  25.     x := 10
  26.     fns := []func(){
  27.         func() {x +=1},
  28.         func() {x +=1},
  29.         func() {x *=2},
  30.         func() {x /=2},
  31.         func() {x *=x},
  32.     }
  34.     c := make(chan func())
  36.     go produce(c, 10, fns...)
  38.     for fn := range c {
  39.         fn()
  40.         fmt.Println(x)
  41.         time.Sleep(delay)
  42.     }
  43. }
  45. random output:
  46.     20
  47.     10
  48.     11
  49.     22
  50.     44
  51.     1936
  52.     1937
  53.     1938
  54.     3755844
  55.     3755845
    或者你也可以

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "time"
  7. )
  9. var delay = 200 * time.Millisecond
  11. func pickFunc(fns ...binFunc) binFunc {
  12.     return fns[rand.Intn(len(fns))]
  13. }
  15. func produce(c chan binFunc, n int, fns ...binFunc) {
  16.     defer close(c)
  17.     for i := 0; i < n; i++ {
  18.         c <- pickFunc(fns...)
  19.     }
  20. }
  22. type binFunc func(int, int) int
  24. func main() {
  25.     // time is varibal
  26.     rand.Seed(time.Now().Unix())
  27.     x := 10
  28.     y := 2
  29.     fns := []binFunc{
  30.         func(x, y int) int { return x + y },
  31.         func(x, y int) int { return x + y },
  32.         func(x, y int) int { return x + y },
  33.         func(x, y int) int { return x + y },
  34.         func(x, y int) int { return x + y },
  35.     }
  36.     c := make(chan binFunc)
  38.     go produce(c, 10, fns...)
  40.     for fn := range c {
  41.         fn(x, y)
  42.         fmt.Println(x)
  43.         time.Sleep(delay)
  44.     }
  45. }

完结
原文链接： golang function type

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注