Swift 中的高阶函数和函数嵌套

Posted 2020-10-08 卢赋斌

高阶函数

在Swift中，函数可做为“一等公民”的存在，也就意味着，我们可以和使用 int 以及 String 一样，将函数当做 参数、值、类型来使用。

其中，将函数当作一个参数和值来使用可见下：

 typealias  addTwoInts = (Int,Int)->(Int)  
    
    var funcType = addTwoInts.self
    func aAddb(a:Int,b:Int) -> Int {
        return a+b
    }
    
    func addFunc(_ add:addTwoInts,_ a:Int,_ b:Int) -> Int {
        return add(a,b)
    }
//调用
     self.addFunc(aAddb, 5, 6)       //  print  -->   11     

调用函数 “ self.addFunc(aAddb, 5, 6) ” 时候，aAddb就是一个典型的“值”， 尽管它实际上是一个函数。 与此同时， 它还做为addFunc的参数来使用。

虽然这看起来多此一举，但实际这恰恰体现了高阶函数的特点，牺牲一点点代码的简短，将重点体现在逻辑的清晰上。

一、一个高阶函数的例子

我更喜欢叫下面的这个函数为高阶函数：

     var names:[String] = ["61","95","8","248","42"]  //一个包含字符串的数组
     names = names.sorted { (s1, s2) -> Bool in   return s1<s2  }
     print(names)     ----->    ["248", "42", "61", "8", "95"]         

这是一个排序函数。不要在意结果并没有按照数字的大小排序，那是因为这是字符串排序，规则将按照首个字母的asc值进行比较。

先看看这个函数的原型：

    public func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]

这个函数显然是将一个  (Element, Element) -> Bool 类型的函数做为他的参数。

一眼看过去，并不是那么好理解，来看下其内部的实现大概是这样的： 

extension Array{
    
    typealias  IncreasingOrder = (String,String) -> Bool
    
    mutating func mySorted(_ increasingOrder:IncreasingOrder) -> [String] {
        var newString:[String] = [String]()

        // 假设这里采用简单选择排序
        for n in 0..<self.count{
            var tamper:String = self[n] as! String
            for i in n+1..<self.count {  //
                var next:String = self[i] as! String
                guard !increasingOrder(tamper,next) else {
                    continue
                }
                swap(&tamper, &next)
                swap(&self[n], &self[i])
            }
            newString.append(tamper)
        }
        return newString
    }
}

调用： 

names = ["61","95","8","248","42"]
  names = names.mySorted { (s1, s2) -> Bool in
            return s1<s2
  }
  print(names)  ----->    ["248", "42", "61", "8", "95"]  

这里为了简便， 直接将Element替换成了String，针对String 类型来说，这个函数的功能和系统的Sotred的功能是一样的。 如果需要支持更多的类型，可能要使用到泛型，甚至是where的可选绑定。其实系统的排序已经实现可选绑定式的排序了：重载了sorted函数，根据Element的不同类型，推断是否需要进行可选绑定动作。

通过这个例子，可以看到，所谓的高阶函数，其实就是将一个函数做为另一个函数的参数的语法。这个语法的基础是Swift中的特性：函数的一等公民性质。

我们可以通过这种类型的语法，将类似的函数的内部代码实现隐藏，只根据参数函数的值定义如何执行内部代码。这中方式实现的代码的灵活度将大大的提高。这为在Swift 中写出使用一个函数替代多个同质化的函数提供了一种手段。 当然，做到这种效果可能还需要使用泛型编程。

 

函数嵌套

大部分情况下，遇到的所有功能都是全局函数，它们在全局范围内定义。如果在函数局部定义一个函数，则称为嵌套函数。

默认情况下，嵌套函数从外部世界隐藏，但在局部仍然可以正常低调用。一个闭包的函数也可以返回一个嵌套函数，以允许在其他范围内使用嵌套函数。

func chooseStepFunction(backward: Bool) -> (Int) -> Int {    //全局函数
    func stepForward(input: Int) -> Int { return input + 1 }     //嵌套函数 1
    func stepBackward(input: Int) -> Int { return input - 1 }    //嵌套函数 2
    return backward ? stepBackward : stepForward                 //返回一个函数
}

调用：

var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    print("\(currentValue)... ")     ---->  // -4...  // -3...// -2...// -1... 

 currentValue = moveNearerToZero(currentValue) } print("zero!") // zero!

嵌套函数的本质是返回一个函数，之前所说的将函数当作参数基于同一个特性 -- 函数是swift的 一等公民。

同样的道理，一个基本类型的既然能够做为局部的变量来存在，函数为什么不行呢？ 当然可以。这就是局部函数的由来，看来还是基于一等公民的身份啊。 函数嵌套将遵守与基本类型一样的原则，局部的函数，职能够在局部去访问，在外部是没有效果的。

如果我们将嵌套的函数匿名的话，也即是我们下面的这种形式：

  typealias  adds = (Int)->(Int)  
  func add(_ c:Int) -> adds {
        return { a in
           return a + c
        }
  }

调用：

let addStart = self.add(0)
let addTwo = addStart(2)
let addFive = addStart(5)
print(addTwo)         ----->   2
print(addFive)        ----->   5

在add函数中，定义了一个起始的数值： 0，返回一个adds类型的函数。 之后我们可以通过给adds类型的实例 addTwo和addFive传递相应的参数即可实现多个函数的套用。 

比如，如果我们在做一个以一个起始值做为加减的时候，这中用法就灵活很多，比如，如果我需要以 10做为初始值：

let add = self.add(10)
let addTwo = add(2)
let addFive = add(5)
print(addTwo)      ==> 12
print(addFive)     --> 15    

add已经是另一个函数了。

而实际上，这就函数嵌套的另一种使用，这有很多的叫法 ，我更愿意叫它 -- 柯里化。

柯里化

在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。

在一般函数中，并不能轻易做到柯里化，可能需要借助其他的方案，比如，将多个参数使用替换成一个struct或者class。

然而高阶函数和嵌套函数却可以很轻易的做到，并保证代码的逻辑清晰。然而为什么要使用柯里化，可以阅读这个文章。 私人觉得，柯里化的优势是去同质化的代码 以及 注重函数的实现减少参数的干扰，简洁提升逻辑。上面的例子刚好解释了柯里化的使用。