Go 语言程序设计——过程式编程（6）

泛型函数

• Go 语言提供了多种代替方法来避免创建一些除了处理的数据类型不同外其他完全相同的函数
• 下面就是一个支持泛型的 Minimum() 函数的例子：

i := Minimum(4, 3, 8, 2, 9).(int)
fmt.Printf("%T %v\n", i, i)
f := Minimum(9.4, -5.4, 3.8, 17.0, -3.1, 0.0).(float64)
fmt.Printf("%T %v\n", f, f)
s := Minimum("K", "X", "B", "C", "CC", "CA", "D", "M").(string)
fmt.Printf("%T %v\n", s, s)

• 这个函数返回一个 interface{} 类型的值，我们使用一个非检查类型断言将值转换我们所期待的值

func Minimum(first interface{}, rest ...interface{}) interface{} {
  minimum := first
  for _, x := range rest {
    switch x := x.(type) {
    case int:
      if x < minimum.(int) {
        minimum = x
      }
    }
    case float64:
      if x < minimum.(float64) {
        minimum = x
      }
    }
    case string:
      if x < minimum.(string) {
        minimum = x
      }
    }
  }
  return minimum
}

• 使用 interface{} 作为参数的类型，这样我们可以传入任意类型的数据
• reflect.Value.Interface() 函数将它的值以 interface{} 类型提取出来

高阶函数

• 高阶函数就是将一个或者多个其他函数作为自己的函数，并在函数体内调用它们
• 简单的高阶函数例子：

func SliceIndex(limit int, predicate func(i int) bool) int {
  for i := 0; i < limit; i++ {
    if predicate(i) {
      return i
    }
  }
  return -1
}

• 高阶函数中也可以传入匿名函数，例子：

xs := []int{2, 4, 6, 8}
ys := []string{"C", "B", "K", "A"}
fmt.Println(
  SliceIndex(len(xs), func(i int) boot {return xs[i] == 5}),
  SliceIndex(len(xs), func(i int) boot {return xs[i] == 6}),
  SliceIndex(len(ys), func(i int) boot {return ys[i] == "Z"}),
  SliceIndex(len(ys), func(i int) boot {return ys[i] == "A"})
)

• 因为匿名函数是一个闭包，所以它们引用的 xs 和 ys 切片必须和这个函数被创建的地方在同一个作用域

纯记忆函数

• 纯记忆函数就是对同一组输入总是产生相同的结果，不存在任何副作用
• 如果一个纯函数执行时开销很大而且频繁的使用相同的参数进行调用，我们可以使用记忆功能来降低处理的开销
• 例子：

func Memoize(function memoizeFunction) memoizeFunction {
  cache := make(map[string]interface{})
  return func(x int, xs ...int) interface{} {
    key := fmt.Sprint(x)
    for _, i := range xs {
      key += fmt.Sprintf(", %d", i)
    }
    if value, found := cache[key]; found {
      return value
    }
    value := function(x, xs...)
    cache[key] = value
    return value
  }
 }