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

最新推荐文章于 2023-04-29 22:56:42 发布

a26579424

最新推荐文章于 2023-04-29 22:56:42 发布

阅读量243

点赞数

文章标签： swift

原文链接：http://www.cnblogs.com/FBiOSBlog/p/7593321.html

版权

高阶函数

在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。

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

转载于:https://www.cnblogs.com/FBiOSBlog/p/7593321.html