[Swift5.1] 18-扩展

扩展（Extension）

• Swift中的扩展，有点类似于OC中的分类（Category）

• 扩展可以为枚举、结构体、类、协议添加新功能。
  可以添加方法、计算属性、下标、（便捷）初始化器、嵌套类型、协议等等。

• 扩展不能办到的事情:
  不能覆盖原有的功能
  不能添加存储属性，不能向已有的属性添加属性观察器
  不能添加父类
  不能添加指定初始化器，不能添加反初始化器
  ...

计算属性、下标、方法、嵌套类型

1)添加计算属性

extension Double {
    var km: Double { self * 1_000.0 }
    var m: Double { self }
    var dm: Double { self / 10.0 }
    var cm: Double { self / 100.0 }
    var mm: Double { self / 1_000.0 }
}

2)添加下标

extension Array {
    subscript(nullable idx: Int) -> Element? {
        if (startIndex..<endIndex).contains(idx) {
            return self[idx]
        }
        return nil
    }
}

3)添加嵌套类型

extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0..<self { task() }
    }
    mutating func square() -> Int {
        self = self * self
        return self
    }
    enum Kind { case negative, zero, positive }
    var kind: Kind {
        switch self {
        case 0:
            return .zero
        case let x where x > 0: return .positive
        default: return .negative
        }
    }
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex { decimalBase *= 10 }
        return (self / decimalBase) % 10
    }
}

协议、初始化器

• 类扩展协议

class Person {
    var age: Int
    var name: String
    init(age: Int, name:String) {
        self.age = age
        self.name = name
    }
}

extension Person: Equatable {
    static func == (left:Person, right: Person) ->Bool{
        left.age == right.age && left.name == right.name
    }
    convenience init() {
        self.init(age:0, name: "")
    }
}

• 结构体扩展 初始化器

struct Point{
    var x: Int = 0
    var y: Int = 0
}

extension Point {
    init(_ point: Point) {
        init(_ point: Point){
            self.init(x:point.x, y:point.y)
        }
    }
}
var p1 = Point()
var p2 = Point(x: 10)
var p3 = Point(y: 20)
var p4 = Point(x: 10, y:20)
var p5 = Point(p4)  //扩展的初始化器

总结:

• 如果希望自定义初始化器的同时，编译器也能够生成默认初始化器
• 可以在扩展中编写自定义初始化器
• required初始化器, 也不能写在扩展中

扩展协议

• 如果一个类型已经实现了协议的所有要求，但是还没有声明它遵守了这个协议
• 可以通过扩展来让它遵守这个协议

protocol TestProtocol {
    func test()
}
class TestClass {
    func test() {
        print("test")
    }
}
extension TestClass : TestProtocol {}

• 编写一个函数，判断一个整数是否为奇数？

func isOdd<T: BinaryInteger>(_ i: T) -> Bool {
    i % 2 != 0
}

extension BinaryInteger {
    func isOdd() -> Bool { self % 2 != 0 }
}

扩展协议细节

• 扩展可以给协议提供默认实现，也间接实现可选协议的效果
• 扩展可以给协议扩充协议中从未声明过的方法

protocol TestProtocol {
    func test1()
}
extension TestProtocol {
    func test1() {
        print("TestProtocol test1")
    }
    func test2() {
        print("TestProtocol test2")
    }
}

class TestClass : TestProtocol {}
var cls = TestClass()
cls.test1() // TestProtocol test1
cls.test2() // TestProtocol test2
var cls2: TestProtocol = TestClass()
cls2.test1() // TestProtocol test1
cls2.test2() // TestProtocol test2

• 类遵守协议,实现协议方法.

class TestClass : TestProtocol {
    func test1() { print("TestClass test1") }
    func test2() { print("TestClass test2") }
}
var cls = TestClass()
cls.test1() // TestClass test1
cls.test2() // TestClass test2

var cls2: TestProtocol = TestClass() //结果分析看总结
cls2.test1() // TestClass test1
cls2.test2() // TestProtocol test2

总结:

• 如果调用方法是在协议声明中的, 编译器优先去实例中查找.
• 如果调用方法是在协议声明中没有, 同时对象定义为协议类型,编译器会认为实例中没有该方法, 会直接去协议中查找.

扩展泛型

• 扩展中依然可以使用原类型中的泛型类型.

class Stack<E> {
    var elements = [E]()
    func push(_ element: E) {
        elements.append(element)
    }
    func pop() -> E { elements.removeLast() }
    func size() -> Int { elements.count }
}
// 扩展中依然可以使用原类型中的泛型类型
extension Stack {
    func top() -> E { elements.last! }
}
// 符合条件才扩展
extension Stack : Equatable where E : Equatable {
    static func == (left: Stack, right: Stack) -> Bool {
        left.elements == right.elements
    }
}