Swift面向协议

利用协议实现前缀效果

• 1. 定义一个结构体Lee<Base>，用于生成计算属性

      struct Lee<Base> {
          let base: Base
          
          init(_ base: Base) {
              self.base = base
          }
      }
     

  • 2. 定义一个协议 LeeCompatible

    protocol LeeCompatible { }
    

  • 3. 给协议 LeeCompatible扩展Lee<Base>计算属性 var lee: Lee<Self>

     extension LeeCompatible {
         var lee: Lee<Self> {
             get { Lee(self) }
             set {}
         }
         static var lee: Lee<Self>.Type {
             get { Lee<Self>.self }
             set { }
         }
     }
    

  • 4. 给某一个具体的类型（String）使用该协议

      extension String: LeeCompatible { }
    

  • 5.给定义的指定Lee<Base>中的Base具体类型，同时扩展该类具体要使用的方法或计算属性

       extension Lee where Base == String {
           var numberCount: Int {
               var count = 0
               let strs = ("0"..."9")
               for c in base where strs.contains(String(c)) {
                   count += 1
               }
               return count
           }
       }
    

  • 6.使用定义好的前缀

       func testLee() {
          let count = "asdf123".lee.numberCount
       }
    

  • 优点：可以在给类型扩展属性和方法时，多本类的方法不会干扰，或者名称重合，比如在在String中有一个numberCount的计算属性，通过该方式来给String扩展一个numberCount的计算属性，不会对String本类中的numberCount的产生影响

  struct Lee<Base> {
      let base: Base
      
      init(_ base: Base) {
          self.base = base
      }
  }

  protocol LeeCompatible { }

  extension LeeCompatible {
      var lee: Lee<Self> {
          get { Lee(self) }
          set {}
      }
      static var lee: Lee<Self>.Type {
          get { Lee<Self>.self }
          set { }
      }
  }

  extension String: LeeCompatible { }

  extension Lee where Base == String {
      var numberCount: Int {
          var count = 0
          let strs = ("0"..."9")
          for c in base where strs.contains(String(c)) {
              count += 1
          }
          return count
      }
  }

  extension Lee where Base: ExpressibleByStringLiteral {
      var numberCount: Int {
          var count = 0
          let strs = ("0"..."9")
          for c in (base as! String) where strs.contains(String(c)) {
              count += 1
          }
          return count
      }
  }

  func testLee() {
     let count = "asdf123".lee.numberCount
      print(count)
      LeePerson.lee.test()
      LeeStudent.lee.test()
      
      let p = LeePerson()
      p.lee.run()
      
      let s = LeeStudent()
      s.lee.run()
  }

  class LeePerson { }
  class LeeStudent: LeePerson {}
  extension LeePerson: LeeCompatible { }

  extension Lee where Base: LeePerson {
      func run() {}
      static func test() {}
  }

利用协议实现类型判断

     protocol ArrayType { }
     extension Array: ArrayType { }
     extension NSArray: ArrayType { }

     func isArrayType(_ type: Any.Type) -> Bool {
         return type is ArrayType.Type
     }
     isArrayType([Int].self)
     isArrayType([Any].self)
     isArrayType(NSArray.self)
     isArrayType(NSMutableArray.self)