聊一聊Swift拓展

Extensions向现有类、结构、枚举或协议类型添加新功能。这包括扩展无法访问原始源代码的类型的能力(称为 回溯建模 )。扩展类似于Objective-C中的类别（categories）。(与Objective-C类别不同，Swift扩展没有名称。)

Swift中的扩展可以:

• 添加计算实例属性和计算类型属性

• 定义实例方法和类型方法

• 提供新的初始值设定项

• 定义下标

• 定义并使用新的嵌套类型

• 使现有类型符合协议

在Swift中，您甚至可以扩展协议以提供其需求的实现，或者添加符合类型可以利用的附加功能。有关详细信息，请参见协议扩展。

请注意
扩展可以向类型添加新功能，但不能覆盖现有功能。
复制代码

拓展语法

使用extension关键字声明扩展:

extension SomeType {
    // new functionality to add to SomeType goes here
}
复制代码

扩展可以扩展现有类型，使其采用一个或多个协议。为了增加协议一致性，您可以像为类或结构编写协议名一样编写协议名:

extension SomeType: SomeProtocol, AnotherProtocol { 
    // implementation of protocol requirements goes here
}
复制代码

以这种方式添加协议一致性在使用扩展添加协议一致性中进行了描述。

扩展可用于扩展现有泛型类型，如在扩展泛型类型中所述。还可以扩展泛型类型，以有条件地添加功能，如在扩展中使用泛型Where子句所述。

请注意
如果您定义了一个扩展来向现有类型添加新功能，那么该新功能将在该类型的所有现有实例上可用，即使它们是在定义扩展之前创建的。
复制代码

计算属性

扩展可以向现有类型添加计算实例属性和计算类型属性。这个例子向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"
复制代码

这些计算的属性表示Double应该被视为长度的特定单位。虽然它们是作为计算属性实现的，但是可以将这些属性的名称附加到带有点语法的浮点文字值，以便使用该文字值执行距离转换。

在本例中，Double1.0表示“一米”。这就是为什么m 计算属性返回self -表达式1.m被认为是计算1.0的Double值。

其他单位需要一些转换来表示为以米为单位测量的值。1千米等于1000米，因此km 计算属性将值乘以1_000.00，以便转换为以米表示的数字。类似地，一米有3.28084英尺，因此ft计算属性将基础的，Double除以3.28084，将其从英尺转换为米。

这些属性是只读的计算属性，为了简洁起见，它们不使用get关键字来表示。它们的返回值类型为Double，可以在接受Double的数学计算中使用:

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

请注意
扩展可以添加新的计算属性，但不能添加存储的属性，也不能向现有属性添加属性观察者。
复制代码

初始化器

扩展可以向现有类型添加新的初始化器。这使您能够扩展其他类型，以接受您自己的自定义类型作为初始化器参数，或者提供附加的初始化选项，这些选项不包含在类型的原始实现中。

扩展可以向类添加新的便利初始化器，但不能向类添加新的指定初始化器或析构器。指定的初始化器和析构器必须始终由原始类实现提供。

如果使用扩展向值类型添加初始化器，该值类型为其所有存储属性提供默认值，且没有定义任何自定义初始化器，则可以从扩展的初始化器内调用该值类型的默认初始化器和成员式初始化器。如果您将初始化器编写为值类型的原始实现的一部分(如值类型的初始化器委托中所述)，则不会出现这种情况。

如果使用扩展向在另一个模块中声明的结构添加初始化器，则新初始化器在从定义模块调用初始化器之前不能访问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结构为其所有属性提供默认值，因此它自动接收一个默认初始化器和一个成员级初始化器，如默认初始化器中所述。这些初始化器可用于创建新的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)
    }
}
复制代码

这个新的初始化器首先根据提供的中心点和大小值计算适当的原点。初始化器然后调用结构的自动成员初始化器init(origin:size:)，它在适当的属性中存储新的origin和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)
复制代码

请注意

如果您使用扩展提供了一个新的初始化器，您仍然需要确保初始化器完成后，每个实例都已完全初始化。
复制代码

方法

扩展可以向现有类型添加新的实例方法和类型方法。下面的例子向Int类型添加了一个新的实例方法repetitions:

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

repetitions(task:)方法接受类型为()-> Void的单个参数，该参数表明一个函数没有参数且无返回值。

定义了这个扩展之后，您可以对任意整数调用repetitions(task:)方法来多次执行一个任务:

3.repetitions {
    print("Hello!")
}
// Hello!
// Hello!
// Hello!
复制代码

可变的实例方法

使用扩展添加的实例方法还可以修改(或改变)实例本身。修改self或其属性的结构和枚举方法必须将实例方法标记为mutating，就像来自原始实现中的可变方法一样。

下面的例子为Swift的Int类型添加了一个名为square的新可变方法，它对原始值进行了平方:

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

下标

扩展可以向现有类型添加新的下标。这个例子向Swift的内置Int类型添加了一个整型下标。下标[n]从数字的右边返回十进制数字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值没有足够的位来满足所请求的索引，下标实现将返回0，就像在数字的左边填充了0一样:

746381295[9]
// returns 0, as if you had requested:
0746381295[9]
复制代码

嵌套类型

扩展可以向现有类、结构和枚举添加新的嵌套类型:

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类型添加了一个新的嵌套枚举。具体来说，它表示数字是负数、零还是正数。

本例还向Int添加了一个新的计算实例属性kind，它返回该整数的适当的kind枚举情况。

嵌套枚举现在可以与任何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 + "
复制代码

这个函数printintegertypes(_:)接受一个Int值的输入数组，并依次迭代这些值。对于数组中的每个整数，函数将考虑该整数的kind 计算属性，并打印适当的描述。

请注意
number.kind已经是Int.Kind类型的了。因此，所有Int.Kind case值都可以在switch语句中以简写形式编写，例如.negative而不是
Int.Kind.negative。
复制代码

[文章源地址Swift5] docs.swift.org/swift-book/…