Swift的延迟求值特性

考虑这样的开发需求场景:
我们希望开发一个日志的组件, 日志通过一个LogLevel来控制是否输出相关的日志内容.
一开始, 我们简简单单的就开始这么做的:

import UIKit

enum LogLevel: Int{
    case Notice = 1
    case Debug
    case Warning
    case Error
    case Factor
}

func >(p1: LogLevel, p2: LogLevel) -> Bool {
    return p1.rawValue > p2.rawValue
}

let CurrentLevel = LogLevel.Warning

func logDebugMessage(message: String) {
    if LogLevel.Debug > CurrentLevel {
        print("DEBUG:\(message)")
    }
}

func complexLogMessage() -> String {
    print("Doing the calculation")
    return String.init(format:"This is a %@", "complex log message");
}

logDebugMessage(complexLogMessage())

当前的日志级别是Warning, 也就是说Warning以上的日志才输出. 因此, 如下日志就不应该以后日志输出logDebugMessage(complexLogMessage())
运行的结果也确实如我们所预计的那样. 然后, 如果你细心的观察控制台的输出, 你会发现complexLogMessage()函数是被执行完毕了的.
在生产环境下, 我们的日志格式化代价有时候是相当昂贵的, 尤其是当有大量的Debug日志的情况, 既然我们已经不希望输出Debug日志, 那么我们肯定也不希望这些日志信息的格式工作浪费了我们的CPU时间.
OC(C/C++)在实现这样的需求的时候, 往往需要使用各种宏来实现.

---

那么, Swift可以怎么做呢?
Swift可以使用@autoclosure修饰参数的特性
@autoclosure 让参数自动变成一个闭包, 从而使得对此参数的求值变成了只是对一个闭包变量的求值. 在函数体真正需要访问参数具体值的时候, 通过调用闭包来完成完成最终的参数求值.

func logDebugMessage(@autoclosure message:()->String) {
    if LogLevel.Debug > CurrentLevel {
        print("DEBUG:\(message())")
    }
}

这样, 我们那些代价昂贵而实际又没有用的函数调用就可以省略了.

注意到这个特性的好处是：我们并不需要对调用代码进行任何的修改，我们只是改变了内部的实现，就让我们的代码运行得更加高效了。

当然，如果我们不使用@autoclosure的话，稍微修改一下调用参数的形式也是可以的：

  logDebugMessage({complexLogMessage()})

就是手工把参数调用封装成一个闭包。

---

重点感概一下C++做不到的地方
回想一下C++的操作符&&、|| 的重载逻辑问题. 原生的&&、|| 是有"短路"判断的

以&&为例, 对于表达式false && someWork(), 由于false条件已经得知整体的表达式结果, 从而someWork()是不需要被执行的.

然而, 当在C++里重载&&、|| 的话, bool operation(bool p1, bool p2)由于重载是以函数形式定义的, 而函数参数的求值规则是参数的求值是在函数调用的时候发生的, 因此无论最终的判断结果如何, 两个参数都会被求值传递给函数.
据我了解, 这依然是C++里无解的一个问题 (这也是为什么大侠都劝告我们不要随便重载这些操作符).
*或者不介意丑陋的调用函数形式的话，使用C++11支持的lamdba表达式也还行。

---

另外一些缓求值的情况就是Swift的lazy属性了, 关于lazy属性, 几乎所有的教程都有讲解, 就不再啰嗦了.

---

还有一些缓求值的支持是针对集合的高阶函数操作的情况的, 比如Array.map方法, 可以在map前面加一个lazyarrObj.lazy.map

举例说明如下：

let arr = [1,2,3,4,5]
let doubleArr = arr.map { (r) -> Int in
    print("doing calculation")
    return r * 2
}
if doubleArr.last > 9{
    print("break the process")
}
else {
    print("double:\(doubleArr)")
}

这里我们对数组每个元素乘以2，而后的一个逻辑判定只访问最后一个元素就可以处理完毕了。
如果没有使用lazy特性，那么执行的结果是这样的：

doing calculation
doing calculation
doing calculation
doing calculation
doing calculation
break the process

而使用lazy的话：let doubleArr = arr.lazy.map {...}

doing calculation
break the process

嗯，只计算了一次。

lazy 属性是CollectionType的一个扩展属性，这个属性把原来的集合对象封装成一个LazyCollection类型的集合对象，LazyCollection类重新实现了map，filter，reduce等高阶函数的实现，使得这些高阶函数返回LazyMapCollection等集合类型。这个过程实际上并没有执行高阶函数里的函数参数，而是把函数函数再次缓存起来。
直到对这样的集合进行迭代的时候才真正开始执行函数对象的操作。这样，如果最终我们的迭代只针对部分元素进行就终止了的话，函数参数就只执行有限次，而不是全部执行。

需要注意的是：
lazy有时候也不一定就是完美的：

for _ in 1...2 {
    for dr in doubleArr {
        print("\(dr)")
    }
}

执行结果该如何理解？留给读者思考吧~