如果你开始接触函数式编程，你一定听说过高阶函数。在维基百科它的中文解释是这样的：

在数学和计算机科学中，高阶函数是至少满足下列一个条件的函数：

    接受一个或多个函数作为输入
    输出一个函数

看起来它就是Objc语言中入参或者返回值为block的block或函数，在swift语言中即为入参或者返回值为函数的函数。那么他们在实际的开发过程中究竟起着什么作用呢？我们将从入参、返回值和综合使用三部分来看这个问题：

函数作为入参

函数作为入参似乎无论在Objc时代还是在Swift时代都是司空见惯的事情，例如AFNetworking就是用两个入参block分别回调成功与失败。swift中更是加了一个尾闭包的语法（最后一个参数为函数，可以不写括号或者写到括号外面直接跟随方法名），例如下面这样：

[1,2,3].forEach{ item i
   print(item);
}

我们可以将参数为函数的函数分为两类，escaping函数入参和noescape函数入参，区别在于这个入参的函数是在执行过程内被调用还是在执行过程外被调用。执行过程外被调用的一般用于callback用途，例如：

Alamofire.request("https://httpbin.org/get").responseJSON{
   response  in 
 print(response.request)
 print(response.response)
 print(response.data)
 print(response.result)
 if let JSON = response.result.value{
     print("JSON: \(JSON)")
 }
}

这个response的入参函数就作为网络请求回来的一个callback，并不会在执行responseJSON这个函数的时候被调用。另外我们来观察forEach的代码，可以推断入参的函数一定会在forEach函数的执行过程中执行，执行完forEach函数后，作为入参的函数就没有利用意义了，这类就是noescape函数。

callback的用法大家应该比较熟悉了，介绍大家noescape入参的一些用法：

1。自由构造器

看过GoF设计模式的，不知道是否还记得构造器模式，Android中的构造器模式类似如下：

new AlertDialog.Builder(this)
        .setIcon(R.drawable.find_daycycle_icon)
        .setTitle("提醒")
        .create()
        .show();

如果你想要做成这样的代码，你需要将setIcon、setTitle、create等方法都实现成返回this才行。这样就无法直接利用无返回值的setter了。
为什么需要这样的方式呢？如果你同时有如下需求：

1、构造一个对象需要很多的参数
2、这些参数里面很多有默认值
3、这些参数对应的属性未来不希望被修改

那么用这样的模式就可以直观且精巧的展示构建过程。
如果使用noescape入参函数还可以更简单的构造出这种代码，只需要传入一个参数为builder的对象就可以了，如下：

class SomeBuilder{
    var property1：Int
    var property2:Bool
    var property3:String
    init(){
// default value 默认值
         property1 = 0
         property2 = true
         property3 = "some string"
   }
}

class SomeObj{
   private var property1:Int
   private var property2:Bool
   private var property3:String
   init(_ builderBlock:(SomeBuilder)->void){
      let someBuilder = SomeBuilder()
       builderBlock(someBuilder)  // noescape 入参的使用
       property1 = someBuilder.property1
       property2 = someBuilder.property2
       property3 = someBuilder.property3
   } 
}

// 调用
let someOjb = SomeObj{  builder in
    builder.property1 = 100
    builder.property2 = true
    buileer.property3 = "ni hao"
}

2.自动配对操作

很多时候，我们开发过程中都会遇到必须匹配的才能正常工作的API，例如打开文件和关闭文件、进入edit模式推出edit模式等。虽然swift语言给我们defer这样的语法糖避免大家忘记配对操作，但是代码看起来还不是那么顺眼

func updateTableView1(){
   self.tableView.beginUpdates()
   self.tableView.insertRows(at:[IndexPath(row:2,section:0), with:.fade])
   self.tableView.deleteRows(at:[IndexPath(row:5,section:0)], with:.fade)
self.tableView.endUpdates()  // 容易漏掉或者上面出现异常
}

func updateTableView2(){
    self.tableView.beginUpdates()
    defer {
        self.tableView.endUpdates()  
    }  
   self.tableView.insertRows(at:[IndexPath(row:2, section:0)],with:.fade)
   self.tableView.deleteRows(at:[IndexPath(row:5,section:0)],with:.fade)
}

利用noescape入参，我们可以将要操作的过程封装起来，使得上层看起来更规整

extension UITableView {
func updateCells(updateBlock:(UITableView)->void){
    beginUpdates()
    defer {
        endUpdates()
    }
    updateBlock(self)
}
}

func updateTableView(){
    // 使用
    self.tableView.updateCells {
      tableView.insertRows(at:[IndexPath(row:2,section:0)],with:.fade)
      tableView.deleteRows(at:[IndexPath(row:5,section:0)],with:.fade) 
   }
}

函数作为返回值

在大家的日常开发中，函数作为返回值的情况想必是少之又少。不过，如果能简单利用起来，就会让代码一下子清爽很多。
首先没有争议的就是我们有很多的API都是需要函数作为入参的，无论是上一节提到过的escaping入参还是noescape入参。所以很多的时候，大家写代码重复了率会很高，例如：

let array = [1, 3, 55, 47, 92, 77, 801]
let array1 = array.filter{ $0 > 2*2}
let array2 = array.filter{ $0 > 3*3}
let array3 = array.filter{ $0 > 4*4}
let array4 = array.filter{ $0 > 5*5}

一段从数组中找到大于莫个数平方的代码，如果不封装，看起来应该是这样的。为了简化，通常会封装成如下的两个样子：

func biggerThanPowWith(array:[Int], value:Int) -> [Int] {
     return array.filter{ $0 > value * value}
}

let array1 = biggerThanPowWith(array:array, value:2)
let array2 = biggerThanPowWith(array:array, value:3)
let array3 = biggerThanPowWith(array:array, value:4)
let array4 = biggerThanPowWith(array:array, value:5)

如果用高阶函数的返回值函数，可以做成这样一个高阶函数：

// 一个返回(Int)->Bool的函数
func biggerThanPow2With(value:Int)->(Int)->Bool{
    return {$0 > value * value}
}
let array1 = array.filter(biggerThanPow2With(value: 3))  let array2 = array.filter(biggerThanPow2With(value: 4))  let array3 = array.filter(biggerThanPow2With(value: 2))  let array4 = array.filter(biggerThanPow2With(value: 5))

你一定会说，两者看起来没啥区别。所以这里面需要讲一下使用高阶返回函数的几点好处

1.不需要wrapper函数也不需要打开原始类

如同上面的简单封装，其实就是一个wrapper函数，把array作为入参带入进来。这样写代码和看代码的时候就稍微不爽一点，毕竟大家都喜欢OOP嘛。如果要OOP，那就势必要对原始类进行扩展，一种方式是加extension，或者直接给类加一个新的方法。

2.阅读代码的时候一目了然

使用简单封装的时候，看代码的人就不知道内部使用了fileter这个函数，必须要查看孕妈才能知道。但是是用高阶函数的时候，一下子就知道了系统库的filter函数。

3.更容易复用

这也是最关键的一点，更细粒度的高阶函数，可以更方便的复用，例如我们知道Set也是有filter这个方法的，复用起来就是这样：

let set = Set<Int>(arrayLiteral:1, 3, 7, 9, 17, 55, 47, 92, 77, 801)
let set1 = set.filter(biggerThanPow2With(value:3))
let set2 = set.filter(biggerThanPow2With(value:10))

回忆一下上面简单的封装，是不是就无法重用了呢？

类似的返回函数的高阶函数还可以有很多例子，列入上面说过的builder，例如每次都需要定制成特殊的样子，但是某个字段不同，就可以利用高阶函数很容易打造出来：

func builderWithdifferentProp3(prop3:String) -> (SomeBuilder) -> void {
      return {
         builder.prop1 = 15
         builder.prop2 = true
         builder.prop3 = prop3
       }
}
let someobj1 = SomeObj.init(builderWithdifferentProp3(prop3:"a"))
let someobj3 = SomeObj.init(builderWithdifferentProp3(prop3:"b"))
let someobj2 = SomeObj.init(builderWithdifferentProp3(prop3:"c"))

入参函数 && 返回值函数 （ 符合使用）

这样的一个函数看起来会很恐怖，swift会声明成func someFunc<A, B, C, D>(_ a:(A)->B) ->(C)->D,Object-c会声明成-(id (^{)(id)someFunc:(id(})(id))block)。让我们先从一个小的例子来讲起，回忆一下我们刚刚做的biggerThanPow2With这个函数，如果我们要一个notBiggerThanPow2With怎么办呢？你知道我一定不会再写一个。所以我告诉你我会这样写：

func not<T>(_ origin_func:@escapeing (T) - Bool) -> (T) -> Bool {
     return {!origin_func($0)}
}
let array5 = array.filter(not(biggerThanPow2With(value:9)))

并不需要一个notBiggerThanPow2With函数，我们只需要实现一个not就可以了。它的入参是一个(T)->Bool,返回值也是(T)->Bool,只需要在执行block内部的时候用一个取反就可以了。这样不单可以解决刚才的问题，还可以解决任何(T)->Bool类型函数的取反问题，比如我们有一个odd(_ : int)方法来过滤奇数，那我们就可以用even =not(odd)得到一个过滤偶数的函数了。

func odd(_ value:Int) -> Bool {
    return value%2 == 1
}
let array6 = array.filter(odd)
let array7 = array.filter(not(odd))

let even = not(odd)
let array8 = array.filter(even)

大家可以看上面的biggerThanPow2With时我们讨论过的，如果biggerThanPow2With不是一个返回函数的高阶函数，那它就不太容易用not函数来加工了。

综上，如果一个入参和返回值都是函数的函数就是这样的一个转换函数，它能够让我们用更少的代码组合出更多的函数。另外需要注意一下，如果返回的函数里面闭包了入参的函数，那么入参函数就是escapeing入参了。

下面再展示给大家两个函数，一个交换参数的函数exchangeParam，另一个是柯里化函数currying：

func exchangeParam<A, B, C>(_ block:@escaping (A,B)->C) -> (B,A)->C{
      return {block($1,$0)}
}

func currying<A,B,C>(_ block:@escaping(A,B)->C, _ value:A) -> (B)->C{
  return {block(value,$0)}
}

第一个函数exchangeParam是交换一个函数的两个参数，第二个函数currying是给一个带两个参数的函数和一个参数，返回一个带一个参数的函数。那这两个函数究竟有什么用途呢？看一下下面的例子：

let array9 = array.filter(currying(exchangeParam(>),9))

swift语言里面 > 是一个入参(a,b)的函数，所以>(5,3) == true。我们使用exchangeParam交换参数就变成了(b,a),这时exchangeParam(>)(5,3)就等于false了。
而currying函数又把参数b固定为一个常量9，所以currying(exchangeParam(>),9)就是大于9的函数意思。

这个例子里就利用了全部的预制函数和通用函数，没有借助任何的命令与业务函数声明实现了一个从数组中过滤大于9的子数组的需求。试想一下，如果我们没有更多的使用这样的高阶函数，代码中是不是很多的逻辑可以更容易的互相结合，而这就是函数式编程的魅力。

总结

高阶函数的引入，无论是从函数式编程还是从非函数式编程都带给我们代码一定程度的简化，使得我们的API更加简易可用，复用更充分。然而文本的列子不过只是冰山一角，更多的内容还是需要不断的尝试和创新，也可以通过学习更多的函数式编程范式来加深理解。