扩展(Extension)

• Swift中的扩展,有点类似OC中的分类Categoary
• 扩展可以为枚举 结构体 类 协议添加新功能
  可以添加方法,计算属性,下标,(便捷)初始化器,嵌套类型,协议等等
  -扩展不能办到的事情
  1.不能覆盖原有的功能
  2.不能添加存储属性,不能向已有的属性添加属性观察器
  3.不能添加父类
  4.不能添加指定初始化器,不能添加反初始化器

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

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

• 数组边界检查

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

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 {
        return 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) {
        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)

协议

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

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

extension TestClass : TestProtocol {}

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

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

extension BinaryInteger {
    func isOdd() -> Bool {
       return 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中实现了原协议中的所有方法.且协议扩展中又协议方法的实现和扩展方法的默认实现.

• 1.如果使用class类型创建class实例.实例调用的方法是class里面定义的方法实现
• 2.如果使用protocol类型创建class实例,那么实例调用的方法实现是:
  2.1原协议中的方法在class中的实现
  2.2不在原协议中,而在协议extension中的方法调用的实现是extension中的实现

protocol TestProtocol {
    func test1()
}
extension  TestProtocol {
    func test1() {
        print("TestProtocol test1")
    }
    func test2() {
        print("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 {
       return elements.removeLast()
    }
    func size() -> Int {
       return elements.count
    }
}

//扩展中依然可以使用原类型中的泛型类型
extension Stack {
    func top() -> E {
        return elements.last!
    }
}
//符合条件才扩展
extension Stack: Equatable where E : Equatable {
    static func ==(left: Stack, right: Stack) -> Bool {
       return left.elements == right.elements
    }
}