Swift(學習)：擴展（Extension，計算屬性，下標，方法，嵌套類型，協議，初始化，泛型）

擴展（Extension）

• Swift中的擴展，有點類似於OC中的分類(Category) 
• 擴展可以爲枚舉、結構體、類、協議添加新功能
• 可以添加方法、計算屬性、下標、(便捷)初始化器、嵌套類型、協議等等
• 擴展不能辦到的事情:要注意擴展不能改變原有類的內存結構

1. 不能覆蓋原有的功能 
2. 不能添加存儲屬性，不能向已有的屬性添加屬性觀察器 （添加存儲屬性會改變原有類的內存結構）
3. 不能添加父類 （由於有可能會繼承父類的存儲屬性，會改變內存結構，所以也不行）
4. 不能添加指定初始化器，不能添加反初始化器，因爲它們只能寫在原有類裏面，所以不能寫在擴展裏
5. ...

---

計算屬性、下標、方法、嵌套類型

• Extension添加計算屬性

• Extension添加下標

下面的例子是爲了防止數組越界：

var arr: Array<Int> = [10, 20, 30]
print(arr.startIndex) //0
print(arr.endIndex) //3 endIndex表示最後一位元素的下一位

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

print(arr[nullable: 1] ?? 0)  //20

• Extension添加嵌套類型

extension Int {
    func repeatitions(task: () -> Void) {
        for _ in 0..<self {task()}
    }
    
    mutating func square() -> Int {
        self = self * self;
        return self
    }
   //Int中嵌套了一個新的枚舉類型
    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
    }
}

3.repeatitions {
    print(1)
}// 1  1  1

var b = 10
print(b.square()) // 100

var c = -10
print(c.kind) // negative

var d = 456
print(d[1]) //5 d[1]表示取十位數字 d[0]爲6

---

協議、初始化

• extension添加協議

 添加Equatable協議和便捷初始化器

• extension添加初始化器

如果希望自定義初始化器的同時，編譯器也能夠生成默認初始化器，可以在擴展中編寫自定義初始化器

•  required初始化器也不能寫在擴展中

 

---

協議

• 如果一個類型已經實現了協議的所有要求，但是還沒有聲明它遵守了這個協議 ,可以通過擴展來讓它遵守這個協議

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

extension TestClass : TestProtocal { }

•  編寫一個函數，判斷一個整數是否爲奇數?

 UInt和Int都屬於BinaryInteger類型

• 擴展可以給協議提供默認實現，也間接實現『可選協議』的效果 
•  擴展可以給協議擴充『協議中從未聲明過的方法』

protocol TestProtocal {
    func test1()
}

extension TestProtocal {
    func test1() {
        print("TestProtocal test1")
    }
    func test2() {
        print("TestProtocal test2")
    }
}

class TestClass: TestProtocal { }

var cls = TestClass()
cls.test1() //TestProtocal test1
cls.test2() //TestProtocal test2

var cls2: TestProtocal = TestClass()
cls2.test1() //TestProtocal test1
cls2.test2() //TestProtocal test2

class TestClass1: TestProtocal {
    func test1() { print("TestClass test1")}
    func test2() { print("TestClass test2")}
}
var cls3 = TestClass1()
cls3.test1() //TestClass test1
cls3.test2() //TestClass test2

var cls4: TestProtocal = TestClass1()
cls4.test1() //TestClass test1
cls4.test2() //TestProtocal test2 這裏是因爲遵守TestProsal協議，並且TestProsal協議裏沒有test2方法，編譯器就會默認遵守協議的類的實例裏沒有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
    }
}

var sta1 = Stack<Int>()
sta1.push(10)
sta1.push(20)
sta1.push(30)

var sta2 = Stack<Int>()
sta2.push(10)
sta2.push(20)
sta2.push(30)

print(sta1 == sta2) //true