编程范式 --- 面向协议编程（Protocol Oriented Programming，简称POP）

面向协议编程（Protocol Oriented Programming，简称POP）

是Swift的一种编程范式，Apple于2015年WWDC踢出

在Swift的标准库中，能见到大量POP的影子

同时，Swift也是一门面向对象的编程语言（Objec Oriented Programming，简称OOP）

在Swift开发中，OOP和POP是相辅相成的，任何一方并不能取代另一方

P- OP能弥补OOP一些设计上的不足

回顾OOP

OOP的三大特性：封装、继承、多态
继承的经典使用场合：
当多个类（比如A、B、C类）具有很多共性时，可以将这些共性抽取到一个父类中（比如D类），最后A、B、C类继承D类

OOP的不足

但是有些问题，使用OOP并不能很好解决，比如：
如何将BVC、DVC的公共方法run抽取出来？

class BVC: UIViewController {

    func run() {

        print("run")

    }

}

class DVC: UITableViewController {

    func run() {

        print("run")

    }

}

基于OOP想到的一些解决方案？

POP的解决方案

protocol Runnable {

    func run()

}

extension Runnable {

    func run() {

        print("run")

    }

}

class BVC: UIViewController, Runnable {}

class DVC: UIViewController, Runnable {}

再举例

POP的注意点

优先考虑创建协议，而不是父类（基类）
优先考虑值类型（struct、enum），而不是引用类型（class）
巧用协议的扩展功能
不要为了面向协议而使用协议

利用协议实现前缀效果

struct My {

    var string: String

    init(_ string: String) {

        self.string = string

    }

    var numberCount: Int {

        var count = 0

        for c in string where("0"..."9").contains(c) {

            count += 1

        }

        return count

    }

}

extension String {

    var my: My { return My(self) }

}

print("123kkk".my.numberCount) // 3

泛型优化 - 不用添加n多个不同类型的存储属性

struct My<Base> {

    var base: Base

    init(_ base: Base) {

        self.base = base

    }

}

扩展优化 - 给具体类型扩展实例方法和实例属性

extension My where Base == String {

    var numberCount: Int {

        var count = 0

        for c in base where("0"..."9").contains(c) {

            count += 1

        }

        return count

    }

}

扩展类型方法和属性

class Person {}

extension Person {

    var my: My<Person> { My(self) }

    static var my: My<Person>.Type { My(Person).self }

}

extension My where Base == Person { // 需要给对应子类扩充的话使用冒号，例如：Base: Person

    func run() {

        print("run")

    }

    static func test() {

        print("test")

    }

}

Person().my.run()

Person.my.test()

协议优化 - 不用给每一个类型扩展前缀属性

protocol MyCompatible {}

extension MyCompatible {

    var my: My<Self> { My(self) }

    static my: My<Self>.Type { My<Self>.self }

}

class String {}

extension String: MyCompatible {}

最终版本

/// 前缀类型

struct My<Base> {

    var base: Base

    init(_ base: Base) {

        self.base = base;

    }

}

/// 利用协议扩展前缀属性

protocol MyCompatible {}

extension MyCompatible {

    var my: My<Self> {

        set {}    // *** 为了扩充mutating方法，所以不能写只读属性

        get { My(self) }

     }

    static var my: My<Self>.Type {

        set {}    // *** 为了扩充mutating方法，所以不能写只读属性

        get { My<Self>.self }

     }

}

/// 给字符串扩展功能

// 让String拥有my前缀属性

extension String : MyCompatible {}

// 给String前缀扩展功能

extension My where Base == String {

    var numberCount: Int {

        var count = 0

        for c in base where("0"..."9").contains(c) {

            count += 1

        }

        return count

    }

    mutating func run() {}

    static func test() {}

}

var str = "666"

str.my.run()

String.my.test()

Base的补充

扩展可以扩充子类class

class Person {}

class Student: Person {}

extension Person: MyCompatible {}

extension My where Base: Person {

    func run() {}

    static func test() {}

}

Person.my.test()

Student.my.test()

let p = Person()

p.my.run()

let s = Student()

s.my.run()

扩展可以遵守共同协议
同时给String、NSString和NSMutableString扩展功能

extension String: MyCompatible {}

extension NSString: MyCompatible {}

extension My where Base: ExpressibleByStringLiteral {

    var numberCount: Int {

        var count = 0

        for c in (base as! String) where("0"..."9").contains(c) {

            count += 1

        }

        return count

    }

    mutating func run() {}

    static func test() {}

}

var str1 = "123xxx"

var str2: NSString = "123xxx"

var str3: NSMutableString = "123xxx"

print(str1.my.numbserCount)

print(str2.my.numbserCount)

print(str3.my.numbserCount)

利用协议实现类型判断

func isArray(_ value: Any) -> Bool {

    // value is Array<Any>

    value is [Any]

}

print(isArray([1, 2]))            // true

print(isArray(["1", 2]))          // true

print(isArray(NSArray()))         // true

print(isArray(NSMutableArray()))  // true

print(isArray("12312421"))        // false

protocol ArrayType {}

extension Array: ArrayType {}

extension NSArray: ArrayType {}

func isArrayType(_ type: AnyType) -> Bool { type is ArrayType.Type }

isArrayType([Int].self)

isArrayType([Any].self)

isArrayType(NSArray.self)

isArrayType(NSMuatbleArray.self)