Go编程模式 - 6-映射、归约与过滤

func MapUpCase(arr []string, fn func(s string) string) []string {
 var newArray = []string{}
 for _, it := range arr {
  newArray = append(newArray, fn(it))
 }
 return newArray
}

func MapLen(arr []string, fn func(s string) int) []int {
 var newArray = []int{}
 for _, it := range arr {
  newArray = append(newArray, fn(it))
 }
 return newArray
}

func Reduce(arr []string, fn func(s string) int) int {
 sum := 0
 for _, it := range arr {
  sum += fn(it)
 }
 return sum
}

func Filter(arr []string, fn func(n string) bool) []string {
 var newArray = []string{}
 for _, it := range arr {
  if fn(it) {
   newArray = append(newArray, it)
  }
 }
 return newArray
}

func main() {
 var list = []string{"Hao", "Chen", "MegaEase"}

 // 元素一对一映射 string->string
 x := MapUpCase(list, func(s string) string {
  return strings.ToUpper(s)
 })
 fmt.Printf("%v\n", x)
 // [HAO CHEN MEGAEASE]

 // 元素一对一映射 string->int
 y := MapLen(list, func(s string) int {
  return len(s)
 })
 fmt.Printf("%v\n", y)
 // [3 4 8]

 // 归约：多个元素->一个元素
 z := Reduce(list, func(s string) int {
  return len(s)
 })
 fmt.Printf("%v\n", z)
 // 15

 // 过滤：过滤不满足条件的元素
 f := Filter(list, func(s string) bool {
  return len(s) > 3
 })
 fmt.Printf("%v\n", f)
 // [Chen MegaEase]
}

func TransformInPlace(slice, function interface{}) interface{} {
 return transform(slice, function, true)
}

// map的转换函数，slice为切片，function为对应的函数，inPlace表示是否原地处理
func transform(slice, function interface{}, inPlace bool) interface{} {
 // 类型判断，必须为切片
 sliceInType := reflect.ValueOf(slice)
 if sliceInType.Kind() != reflect.Slice {
  panic("transform: not slice")
 }

 // 函数的签名判断，即函数的入参必须和slice里的元素一致
 fn := reflect.ValueOf(function)
 elemType := sliceInType.Type().Elem()
 if !verifyFuncSignature(fn, elemType, nil) {
  panic("trasform: function must be of type func(" + sliceInType.Type().Elem().String() + ") outputElemType")
 }

 // 如果是原地，则直接处理函数，结果会保存到入参中（这时入参一般为指针）
 // 如果非原地，那就需要新建一个切片，用来保存结果
 sliceOutType := sliceInType
 if !inPlace {
  sliceOutType = reflect.MakeSlice(reflect.SliceOf(fn.Type().Out(0)), sliceInType.Len(), sliceInType.Len())
 }
 for i := 0; i < sliceInType.Len(); i++ {
  sliceOutType.Index(i).Set(fn.Call([]reflect.Value{sliceInType.Index(i)})[0])
 }
 return sliceOutType.Interface()

}

func verifyFuncSignature(fn reflect.Value, types ...reflect.Type) bool {
 // 类型判断
 if fn.Kind() != reflect.Func {
  return false
 }

 // 入参数量和函数签名一致，出参必须只有一个
 if (fn.Type().NumIn() != len(types)-1) || (fn.Type().NumOut() != 1) {
  return false
 }

 // 每个函数入参的类型校验
 for i := 0; i < len(types)-1; i++ {
  if fn.Type().In(i) != types[i] {
   return false
  }
 }

 // 出参类型的校验
 outType := types[len(types)-1]
 if outType != nil && fn.Type().Out(0) != outType {
  return false
 }
 return true
}