Swift 同构与异构

1、数据源中的同构与异构

• 对于 Swift 的集合数据来说，有同构和异构之分。

  • 如果你需要讨论一群鸟类或者一批飞机，那么这样的数据是同构的，比如包含鸟类的数组 [Bird] 和包含飞机的数组 [Airplane]。
  • 有时候你想探讨的是这些空中家伙的共性 “飞翔”，因此你的数据源可能同时包含 Bird 和 Airplane，这样的数据源叫做异构数据。

1.1 使用协议构建异构数据

• 协议是描述一个事物属性的最小力度划分，Swift 协议的一个重要作用就是构建异构数据，数组的定义是泛型的，当你把协议作为类型去初始化一个数组的时候，实际是为数组中的成员的泛型定义增加了一层协议的约束。

• 使用协议实现数据的异构除了功能划分更明确、粒度更小之外，还有一个好处是运行的效率要高于使用类的继承实现的数据异构。Swift 作为一门强类型语言，继承的安全性检查规则比较复杂，运行时的类型转换（特指父类与子类的转换）并不高，而协议不会保存数据，协议的实现只需要参考上下文，所以在运行速度上更胜一筹。使用协议实现异构，者也是苹果官方推荐的写法。

• 使用协议构建异构数据

  // 创建协议
  
  protocol CanFly {
      func fly()
  }
  
  // 创建异构数据源类型
  
  struct Bird: CanFly {
  
      var name = ""
  
      func fly() {
          print("bird fly")
      }
  }
  
  struct Airplane: CanFly {
  
      var company = ""
  
      func fly() {
          print("airplane fly")
      }
  }
  

  // 创建异构的数组
  
  let flyArray: [CanFly] = [          // 指定数据上下文类型
  
      Bird(name: "maque"),
      Airplane(company: "zhongguodongfanghangkong")
  ]
  
  for f in flyArray {
      f.fly()                         // 依次输出：bird fly     airplane fly
  }
  

  • 由于异构数组可能存在多层共性，所以此时使用类型推断时编译器是无法确定 flyArray 的类型的，你需要明确指定异构数组的上下文，这里指定数据源为 [CanFly] 类型的数组，此时向数组中传入的所有成员类型都必须是遵守 CanFly 协议的类型实例。
  • 异构数据源中的所有数据都可以调用数据类型上下文中的协议所声明的成员。

1.2 使用协议动态方法构建

• 上例中方法 fly 定义在协议的声明中，所以是一个动态的方法，会完全被协议遵守者重写，无论你是否在协议扩展中给予 fly 方法默认实现，获得的协议方法都是被重写过的。

  // 创建协议
  
  protocol CanFly {
      func fly()
  }
  

  // 创建协议扩展
  
  extension CanFly {
      func fly() {
          print("can fly")
      }
  }
  

  // 创建异构数据源类型
  
  struct Bird: CanFly {
  
      var name = ""
  
      func fly() {
          print("bird fly")
      }
  }
  
  struct Airplane: CanFly {
  
      var company = ""
  
      func fly() {
          print("airplane fly")
      }
  }
  

  // 创建异构的数组
  
  let flyArray: [CanFly] = [          // 指定数据上下文类型
  
      Bird(name: "maque"),
      Airplane(company: "zhongguodongfanghangkong")
  ]
  
  for f in flyArray {                 // 获得的协议方法都是被重写过的
      f.fly()                         // 依次输出：bird fly     airplane fly
  }
  

1.3 使用协议静态方法构建

• 如果上例中方法 fly 定义在协议的扩展中，当上下文不为协议 CanFly 类型时，协议中定义的 fly 方法会完全被协议遵守者重写；当上下文为协议 CanFly 类型时，会完全使用默认实现。

  // 创建协议
  
  protocol CanFly {
  
  }
  

  // 创建协议扩展
  
  extension CanFly {
      func fly() {
          print("can fly")
      }
  }
  
  struct Bird: CanFly {
  
      var name = ""
  
      func fly() {
          print("bird fly")
      }
  }
  
  struct Airplane: CanFly {
  
      var company = ""
  
      func fly() {
          print("airplane fly")
      }
  }
  

  // 创建异构的数组
  
  let flyArray: [CanFly] = [          // 指定数据上下文类型
      Bird(name: "maque"),
      Airplane(company: "zhongguodongfanghangkong")
  ]
  
  for f in flyArray {                 // 获得的协议方法都是被重写过的
      f.fly()                         // 依次输出：can fly     can fly
  }
  

1.4 获取异构数据

• 从异构的数据源中还原真实的数据类型

  for f in flyArray {
  
      if let bird = f as? Bird {
          bird.fly()                                  // bird fly
      } else if let  airplane = f as? Airplane {
          airplane.fly()                              // airplane fly
      }
  }
  

• 只想确定异构的数据是某个类型的但是却不会用到数据本身

  for f in flyArray {
  
      if let bird = f as? Bird {
          bird.fly()                                  // bird fly
      } else if f is Airplane {
          print("airplane")                           // airplane
      }
  }
  

  • is 的功能等价于一个匿名的转换过程

  if let _ f as? Airplane {
      print("airplane")
  }
  

2、AnyObject

• AnyObject 的存在是为了兼容现有的 OC 和 iOS 的代码，但并不会经常使用它来构建自己的数据类型。

• 在 Swift 2.2 中，AnyObject 变成了一个协议，它既出现在桥接中，又经常被用作定义异构数据。

  @objc public procotol AnyObject {}
  

  • 不过作为一个协议，AnyObject 仍旧缺少足够的描述，你可以单纯的认为 AnyObject 是 OC 中 id 的桥接。

• 在 Swift 3.0 中，对 AnyObject 的功能进行了拆分，AnyObject 现在专门用来处理 OC 桥接，Any 用来定义异构数据。

• Storyboard 中会出现 AnyObject，还有在某些函数的参数中可以见到 AnyObject。

  func prepare(for segue: UIStoryboardSegue, sender: Any?)
  

3、Any

• 在 Swift 3.0 中，对 AnyObject 的功能进行了拆分，AnyObject 现在专门用来处理 OC 桥接，Any 用来定义异构数据。

3.1 Any 的使用

• 因为 Any 是一种未知类型的协议，所以不能向它发送任何消息，为了使用它需要把它转换成一种我们知道的类型。

  • 我们可以定义一个已知类型的变量，然后使用 变量 = AnyObject 转换后的东西。

• 和其它协议一样，处理 AnyObject 时可以使用 as?、as! 或者 is。

  @IBAction func appendDigit(sender: Any) {
  
      if let mysender = sender as? UIButton {
  
          // 再进行对按钮的操作，使用 mysender
      }
  }
  

3.2 Any 与 id 的对比

• 如果你的 Swift 代码中使用了 OC 的 API，OC 中的 id 在 Swift 中会被桥接成 Any，和 id 一样，声明成 Any 的对象可以使用不同的构造器进行初始化。

  var someObject: Any = UIColor.red
  someObject = NSDate()
  

  • 声明为 Any 的对象既可以成为一个颜色，又可以成为一个日期。

• 无论你的 someObject 当前是什么类型，都可以调用 swift 中的任意方法，编译器不会检查 someObject 的类型，someObject 的真实类型直到运行时才会揭晓。使用 Any 类型时编译会报错。

  var someObject: AnyObject = UIColor.red
  someObject = NSDate()
  
  someObject.withAlphaComponent(0.5)
  someObject.timeIntervalSinceNow
  someObject.append("abc")
  

• 为了写出更加安全的代码，推荐把 Any 类型转换成真正的类型使用，引入编译器的检查。