擴展向現(xiàn)有類、結構、枚舉或協(xié)議類型添加新功能。這包括擴展無法訪問原始源代碼的類型的能力(稱為回溯建模)。擴展類似于Objective-C中的類別。(與Objective-C類別不同，Swift擴展沒有名稱。)

Swift中的擴展可以:

• 添加計算實例屬性和計算類型屬性
• 定義實例方法和類型方法
• 提供新的初始值設定項
• 定義下標
• 定義并使用新的嵌套類型
• 使現(xiàn)有類型遵守協(xié)議

在Swift中，您甚至可以擴展協(xié)議以提供其需求的實現(xiàn)，或者添加符合類型可以利用的附加功能。有關詳細信息，請參見Protocol Extensions。

注意：擴展可以向類型添加新功能，但不能覆蓋現(xiàn)有功能。

Extension Syntax 拓展語法

使用extension關鍵字聲明擴展:

extension SomeType {
    // new functionality to add to SomeType goes here
}

擴展可以擴展現(xiàn)有類型，使其采用一個或多個協(xié)議。為了增加協(xié)議一致性，您可以像為類或結構編寫協(xié)議名一樣編寫協(xié)議名:

extension SomeType: SomeProtocol, AnotherProtocol {
    // implementation of protocol requirements goes here
}

擴展可用于擴展現(xiàn)有泛型類型，如在擴展泛型類型中所述。還可以擴展泛型類型，以有條件地添加功能，如在擴展中使用泛型Where子句所述。

如果您定義了一個擴展來向現(xiàn)有類型添加新功能，那么該新功能將在該類型的所有現(xiàn)有實例上可用，即使它們是在定義擴展之前創(chuàng)建的。

Computed Properties 計算屬性

擴展可以向現(xiàn)有類型添加計算實例屬性和計算類型屬性。這個例子向Swift內置的Double類型添加了5個計算實例屬性，為處理距離單位提供了基本支持:

extension Double {
    var km: Double { return self * 1_000.0 }
    var m: Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.28084 }
}
let oneInch = 25.4.mm
print("One inch is \(oneInch) meters")
// Prints "One inch is 0.0254 meters"
let threeFeet = 3.ft
print("Three feet is \(threeFeet) meters")
// Prints "Three feet is 0.914399970739201 meters"

這些計算的屬性表示雙值應該被視為長度的特定單位。雖然它們是作為計算屬性實現(xiàn)的，但是可以將這些屬性的名稱附加到帶有點語法的浮點文字值，以便使用該文字值執(zhí)行距離轉換。

在本例中，1.0表示“一米”。這就是為什么計算屬性m 返回self -表達式1.m被認為是1.0。

其他單位需要一些轉換來表示為以米為單位測量的值。1千米等于1000米，因此km computed屬性將值乘以1_000.00，以便轉換為以米表示的數(shù)字。類似地，一米有3.28084英尺，因此ft計算屬性將基礎的雙值除以3.28084，將其從英尺轉換為米。

這些屬性是只讀的計算屬性，為了簡潔起見，它們不使用get關鍵字來表示。它們的返回值類型為Double，可以在接受Double的數(shù)學計算中使用:

let aMarathon = 42.km + 195.m
print("A marathon is \(aMarathon) meters long")
// Prints "A marathon is 42195.0 meters long"

注意：擴展可以添加新的計算屬性，但不能添加存儲的屬性，也不能向現(xiàn)有屬性添加屬性觀察者。

Initializers 初始化或構造器

擴展可以向現(xiàn)有類型添加新的初始化器。這使您能夠擴展其他類型，以接受您自己的自定義類型作為初始化器參數(shù)，或者提供附加的初始化選項，這些選項不包含在類型的原始實現(xiàn)中。

擴展可以向類添加新的便利初始化器，但不能向類添加新的指定初始化器或反初始化器。指定的初始化器和反初始化器必須始終由原始類實現(xiàn)提供。

如果使用擴展向值類型添加初始化器，該值類型為其所有存儲屬性提供默認值，且不定義任何自定義初始化器，則可以從擴展的初始化器內調用該值類型的默認初始化器和成員式初始化器。如果您將初始化器編寫為值類型的原始實現(xiàn)的一部分(如值類型的初始化器委托中所述)，則不會出現(xiàn)這種情況。

如果使用擴展向在另一個模塊中聲明的結構添加初始化器，則新初始化器在從定義模塊調用初始化器之前不能訪問self。

下面的示例定義了一個自定義矩形結構來表示幾何矩形。該示例還定義了兩個支持結構Size和Point，它們都為所有屬性提供0.0的默認值:

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
}

由于Rect結構為其所有屬性提供默認值，因此它自動接收一個默認初始化器和一個成員級初始化器，如默認初始化器中所述。這些初始化器可用于創(chuàng)建新的Rect實例:

let defaultRect = Rect()
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
   size: Size(width: 5.0, height: 5.0))

您可以擴展Rect結構，以提供一個額外的初始化器，該初始化器采用特定的中心點和大小:

extension Rect {
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

這個新的初始化器首先根據(jù)提供的中心點和大小值計算適當?shù)脑c。初始化器然后調用結構的自動成員初始化器init(origin:size:)，它在適當?shù)膶傩灾写鎯π碌膐rigin和size值:

let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
                      size: Size(width: 3.0, height: 3.0))
// centerRect's origin is (2.5, 2.5) and its size is (3.0, 3.0)

如果您使用擴展提供了一個新的初始化器，您仍然需要確保初始化器完成后，每個實例都已完全初始化。

Methods 方法

擴展可以向現(xiàn)有類型添加新的實例方法和類型方法。下面的例子向Int類型添加了一個新的實例方法repeat:

extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0..<self {
            task()
        }
    }
}

repetitions(task:) 方法帶有一個函數(shù)類型 () -> Void 的參數(shù),
這個函數(shù)沒有參數(shù)，也沒有返回值。

定義了這個擴展之后，您可以對任意整數(shù)調用repeat (task:)方法來執(zhí)行一個任務，執(zhí)行多次:

3.repetitions {
    print("Hello!")
}
// Hello!
// Hello!
// Hello!

Mutating Instance Methods 修改實例方法

使用擴展添加的實例方法還可以修改(modify或mutate)實例本身。修改self或其屬性的結構和枚舉方法必須將實例方法標記為變異mutating，就像對原始實現(xiàn)中的方法進行變異一樣。

下面的例子為Swift的Int類型添加了一個名為square的新變異方法，它對原始值進行了平方:

extension Int {
    mutating func square() {
        self = self * self
    }
}
var someInt = 3
someInt.square()
// someInt is now 9

Subscripts 下標

擴展可以向現(xiàn)有類型添加新的下標。這個例子向Swift的內置Int類型添加了一個整型下標。下標[n]從數(shù)字的右邊返回十進制數(shù)字n:

• 123456789[0] returns 9
• 123456789[1] returns 8
  代碼如下：

extension Int {
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex {
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}
746381295[0]
// returns 5
746381295[1]
// returns 9
746381295[2]
// returns 2
746381295[8]
// returns 7

如果Int值沒有足夠的數(shù)字來滿足所請求的索引，下標實現(xiàn)將返回0，就像在數(shù)字的左邊填充了0一樣:

746381295[9]
// returns 0, as if you had requested:
0746381295[9]

Nested Types 嵌套類型

擴展可以向現(xiàn)有類、結構和枚舉添加新的嵌套類型:

extension 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
        }
    }
}

這個例子向Int類型添加了一個新的嵌套枚舉。具體來說，它表示數(shù)字是負數(shù)、零還是正數(shù)。

本例還向Int添加了一個新的實例計算屬性kind，它返回該整數(shù)的適當?shù)膋ind枚舉情況。

嵌套枚舉現(xiàn)在可以與任何Int值一起使用:

func printIntegerKinds(_ numbers: [Int]) {
    for number in numbers {
        switch number.kind {
        case .negative:
            print("- ", terminator: "")
        case .zero:
            print("0 ", terminator: "")
        case .positive:
            print("+ ", terminator: "")
        }
    }
    print("")
}
printIntegerKinds([3, 19, -27, 0, -6, 0, 7])
// Prints "+ + - 0 - 0 + "

這個函數(shù)printintegertypes(_:)接受一個Int值的輸入數(shù)組，并依次迭代這些值。對于數(shù)組中的每個整數(shù)，函數(shù)將考慮該整數(shù)的kind計算屬性，并打印適當?shù)拿枋觥?/p>

number.kind已經(jīng)是Int.Kind類型的了。因此，所有Int.Kind case值都可以在switch語句中以簡寫形式編寫，例如.negative而不是Int.Kind.negative。

<<返回目錄