Swift 面向协议编程

在 WWDC 2015上，苹果发布了 Swift 2.0 版本，这是自 Swift 发布以来进行的第二次重大改版，这次改进推出了很多新特性来帮助我等程序员写出更优雅的代码。

在这些新特性里面，最让人兴奋的莫过于协议扩展(protocol extensions)了。在第一版的 Swift 当中，我们可以使用扩展来为类(class)、结构体(struct)以及枚举(enum)增加新功能。在新版的 Swift 2.0 当中，我们也可以对协议(protocol)进行扩展了。

这乍看起来好像只是一个很小的改变，事实上，协议扩展的功能是相当强大的，它甚至能改变我们编写代码的方式。在本教程中，你不仅可以学习到创建和使用协议扩展的方法，同时还可以体会到这项新技术和面向协议编程范式给你带来的新视野。

同时还能看到 Swift 开发小组是如何使用协议扩展来对 Swift 的标准库进行改进，以及它将会对我们编写代码带来怎样的影响。

从这里开始（Getting Started）

我们先从新建一个playground开始。打开 Xcode 7 选择File\New\Playground...并命名为SwiftProtocols。可以选择任意的平台，因为本教程中的代码是与平台无关的。选择保存的位置后点击Next，最后点击Create。

打开playground后，添加如下代码：

protocol Bird {
    var name: String { get }
    var canFly: Bool { get }
}

protocol Flyable {
    var airspeedVelocity: Double { get }
}

这里定义了一个简单的Bird协议，它拥有name和canFly两个属性，同时还定义了一个拥有airspeedVelocity属性的Flyable协议。

在没有协议的远古时期，我们可能会将Flyable定义为一个基类，然后使用继承的方式来定义Bird以及其它会飞的东西，比如飞机之类的。然而这里并不用这么做，所有一切都是从协议开始的。

当我们接下来开始定义具体类型的时候，你将会看到这种方法将会使我们的整个系统更加灵活。

定义遵守协议的类型

在代码区底部增加如下的结构体定义：

struct FlappyBird: Bird,Flyable {
  let name: String
  let flappyAmplitude: Double
  let flappyFrequency: Double
  let canFly = true
  var airspeedVelocity: Double {
    return 3 * flappyFrequency * flappyAmplitude
  } 
}

这里定义了一个新的结构体Flappybird，这个结构体遵守了Bird和Flyable协议。它的airspeedVelocity属性的值是通过flappyFrequency和flappyAmplitue计算出来的。作为一只愤怒的小鸟，它的canFly当然是返回true的 :]。

接着，再定义两个结构体：

struct Penguin: Bird {
    let name: String
    let canFly = false
}

struct SwiftBird: Bird,Flyable {
   var name: String { return "Swift \(version)" }
   let version: Double
   let canFly = true

   // Swift 速度超群!
   var airspeedVelocity: Double { return 2000.0 }
}

企鹅(Penguin)是一种鸟(Bird)，不过它是不能飞的。啊哈，应该庆幸我们没有采用继承的方法，使用继承会让所有的子类都拥有飞的能力。雨燕(SwiftBird)不仅能飞，它还拥有超快的速度！

我们可以发现，上面的代码里面有一些冗余。尽管我们已经有了Flyable的信息，但是我们还是得为每个Bird类型指定canFly属性来表明它是否可以飞行。

拥有默认实现的扩展协议

对于协议扩展，我们可以为它指定默认的实现。在定义Bird协议的下方增加如下代码：

extension Bird where Self: Flyable {
    // Flyable birds can fly!
    var canFly: Bool { return true }
}

这里通过对Bird协议进行扩展，为它增加了默认行为。当一个类同时遵守Flyable协议时，它的canFly属性就默认返回true。即是说，所有遵守Flyable协议的鸟类都不必再显式指定它是否可以飞行了。

Swift 1.2 将where判断语法增加到了 if-let 绑定中，而 Swift 2.0 更进一步地将这个语法带到了协议扩展中。

将FlappyBird和SwiftBird结构体定义中的let canFly = true语句删除。可以看到，playground可以顺利通过编译，因为扩展协议的默认实现已经帮你处理了这些琐事。

为何不使用基类？

或许你会发现，使用协议扩展和它的默认实现与使用基类，或者其它语言中的抽象类很相似，但是它有几个关键的优势：

因为一个类型可以遵守多个协议，所以它可以从各个协议中接收到不同的默认实现。与其它语言中所支持的多重继承不同（吐槽：说的就是C++吧），协议扩展不会为遵守它的类型增加额外的状态。
所有的类，结构体和枚举都可以遵守协议，而基类只能被类所继承。

换句说就是，协议拥有为值类型(value types)增加默认实现的能力，而不仅仅是类。

我们已经体验过了结构体的实战，接下来在playground的底部增加如下的枚举的定义：

enum UnladenSwallow: Bird,Flyable {
  case African
  case European
  case Unknown
  var name: String {
    switch self {
      case .African:
        return "African"
      case .European:
        return "European"
      case .Unknown:
        return "What do you mean? African or European?"
    }
  }
 
  var airspeedVelocity: Double {
    switch self {
      case .African:
        return 10.0
      case .European:
        return 9.9
      case .Unknown:
        fatalError("You are thrown from the bridge of death!")
    } 
  }
}

与其它值类型一样，你所需要做的就是定义一些属性，好让UnladenSwallow能够遵守这两个协议。因为这个枚举同时遵守了Flyable所以它也得到了canFly的默认实现。

你不会真的以为这篇教程只是为了演示一些小鸟的飞行把戏吧？
接下来，让我们看一些更有实战意义的代码。

扩展协议(Extending Protocols)

协议扩展最常用的约莫就是扩展外部协议了，不管这些协议来自 Swift 标准库还是来自第三方框架。

在playground的底部再增加如下代码：

extension CollectionType {
   func skip(skip: Int) -> [Generator.Element] {
     guard skip != 0 else { return [] }
     
     var index = self.startIndex
     var result: [Generator.Element] = []
     var i = 0
     repeat {
       if i % skip == 0 {
         result.append(self[index])
       }
       index = index.successor()
       i++
     } while (index != self.endIndex)

     return result
   }
}

这里对标准库中的CollectionType进行了扩展，定义了一个方法。这个方法会对一个集合类型中的元素以skip步进行跳跃，然后返回集合中没有被跳过的元素。

在 Swift 中，CollectionType协议被类似数组以及字典这样的集合类型所遵守。这意味着，现在你的整个 app 中，所有遵守CollectionType的类型都拥有这个方法了。接着在底部增加下面的代码：

let bunchaBirds: [Bird] =
  [UnladenSwallow.African,UnladenSwallow.European,UnladenSwallow.Unknown,Penguin(name: "King Penguin"),SwiftBird(version: 2.0),FlappyBird(name: "Felipe",flappyAmplitude: 3.0,flappyFrequency: 20.0)]

bunchaBirds.skip(3)

这里我们定义了一个数组，这个数组包含了大部分之前定义过的鸟类。因为数组类型遵守了CollectionType协议，所以，我们可以直接对这个数组使用skip方法。

扩展自己的协议（Extending Your Own Protocols）

跟为标准库增加方法同样令人兴奋的是，我们也可以为它增加默认行为。

修改鸟类的协议，使其遵守BooleanType协议：

protocol Bird: BooleanType {

遵守BooleanType协议意味着所有Bird类型都要有一个boolValue属性，使得它能够像布尔值一样被使用。这是不是说我们得为所有的定义过的，还有将来要定义的Bird类型添加这个属性？

当然不是，使用协议扩展能让我们有更简便的方法。在Bird的定义下面添加如下代码：

extension BooleanType where Self: Bird {
  var boolValue: Bool {
    return self.canFly
  }
}

这个扩展可以让canFly属性来表示每个Bird类型的布尔值。

通过下面的代码来试验一下：

if UnladenSwallow.African {
  print("I can fly!")
} else {
  print("Guess I’ll just sit here :[")
}

可以看到控制台打印出了"I can fly!"。然而更值得注意的是，我们这里直接把UnladenSwallow.African丢到了 if 判断里面！

对 Swift 标准库的影响

我们已经看到了，使用协议扩展可以极大地增强了我们代码的功能和可定制性。你可能不知道的是，Swift 开发小组甚至使用了协议扩展对 Swift 标准库的写法进行了改进。

Swift 通过在标准库中增加了map、reduce和filter等方法，使它自身的函数式编程属性得到了大大的提升。

这些方法存在于不同的CollectionType成员中，比如Array：

// Counts the number of characters in the array
["frog","pants"].map { $0.length }.reduce(0) { $0 + $1 } // returns 9

对数组调用map方法返回了另一个数组，再对这个数组调用reduce方法，使其计算出整个数组中的字符数。

在这里，map和reduce是包含在Array当中的。如果我们按住command键点击map，就可以看到它的定义。

在 Swift 1.2 里，我们可以看到类似下面的定义：

// Swift 1.2
extension Array : _ArrayType {
    /// Return an `Array` containing the results of calling 
    /// `transform(x)` on each element `x` of `self`
    func map<U>(transform: (T) -> U) -> [U]
}

在这里map函数是作为Array的扩展被定义的。但是 Swift 的函数式函数不止是对Array，而是对所有的CollectionType都起作用，那么 Swift 1.2 是如何处理的呢？

如果对一个Range类型调用map函数，并且从那里跳到它的实现，我们可以看到如下的定义：

// Swift 1.2
extension Range {
    /// Return an array containing the results of calling 
    /// `transform(x)` on each element `x` of `self`. 
    func map<U>(transform: (T) -> U) -> [U]
}

可以发现，对于 Swift 1.2 来说，标准库中不同的CollectionType都需要重新实现map函数。
这是因为虽然Array与Range都遵守了CollectionType协议，但是由于结构体不能被继承，因此也就无法定义通用的实现。

这不仅仅是标准库实现上的一点细微差别，这实际上限制对 Swift 类型的使用。

下面这个范型函数接受一个Flyable类型的CollectionType，然后返回拥有最快速度(airspeedVelocity)的元素：

func topSpeed<T: CollectionType where T.GeneratorType: Flyable>(collection: T) -> Double {
  collection.map { $0.airspeedVelocity }.reduce { max($0,$1)}
}

在 Swift 1.2 当中没有协议扩展，因此这段代码会报错。reduce函数只存在预定义的一些类型中，并不能对任意的CollectionType起作用。

然而在 Swift 2.0 中使用了协议扩展，对于Array和Range的map函数都是这样定义的：

// Swift 2.0
extension CollectionType {
  /// Return an `Array` containing the results of mapping `transform`
  /// over `self`.
  ///
  /// - Complexity: O(N).
  func map<T>(@noescape transform: (Self.Generator.Element) -> T) -> [T]
}

虽然无法看到map方法的实现 -- 至少在 Swift 2.0 开源之前，但是我们可以知道所有的CollectionType都有一个map方法的默认实现。即是说，所有遵守CollectionType的类型，都能随机附赠一个map方法。

playground的最底部增加如下的泛型函数：

func topSpeed<T: CollectionType where T.Generator.Element == Flyable>(c: T) -> Double {
  return c.map { $0.airspeedVelocity }.reduce(0) { max($0,$1) }
}

可以对保存Flyable类型的集合调用reduce方法了。如果，你还对上面定义的鸟类中哪个速度最快持有疑惑的话，就可以使用这个函数来得到最终的答案了：

 let flyingBirds: [Flyable] = 
  [UnladenSwallow.African,SwiftBird(version: 2.0)]
 
topSpeed(flyingBirds) // 2000.0