Swift learning part 20 - 扩展

扩展可以为一个已有的类、结构体、枚举或者协议添加新功能。它还具有在不访问被扩展类型的原始源代码的情况下完成扩展的能力（即 逆向建模 ）。扩展和 Objective-C 中的分类类似。但是，与 Objective-C 不同的是，Swift 的扩展没有名字。

Swift 中的扩展可以：

添加计算型实例属性和计算型类型属性
定义实例方法和类型方法
提供新的构造器
定义下标
定义和使用新的嵌套类型
使一个已有类型遵循某个协议

在 Swift 中，你甚至可以扩展协议以提供其需要的实现，或者添加额外功能给遵循的类型所使用。

注意：扩展可以为一个类型添加新的功能，但是不能重写已有的功能。

扩展的语法

使用关键字 extension 来声明扩展：

extension SomeType {
    // 为 SomeType 添加的新功能写到这里
}

可以通过扩展来扩展一个已有类型，使其遵循一个或多个协议。在这种情况下，无论是类还是结构体，协议名称的书写方式完全一样：

extension SomeType: SomeProtocol, AnotherProctocol {
    // 协议所需的实现写到这里
}

注意：
通过扩展为一个已有类型添加新功能，新功能对该类型所有已有实例都可用，即使这些实例是在这个扩展定义之前创建的。

计算型属性

扩展可以为已有类型添加计算型实例属性和计算型类型属性。

这个例子给 Swift 内建的 Double 类型添加了五个计算型实例属性，从而提供与距离单位相关工作的基本支持：

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") 
// 打印 “One inch is 0.0254 meters”

let threeFeet = 3.ft
print("Three feet is \(threeFeet) meters") 
// 打印 “Three feet is 0.914399970739201 meters”

这些计算型属性表达式的含义是把一个 Double 值看做是某单位下的长度值，通过点语法来使用实现距离转换。

定义马拉松比赛的距离：

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

注意：扩展可以添加新的计算型属性，但是不可以添加存储型属性，也不可以为已有属性添加属性观察器。

构造器

扩展可以为已有类型添加新的构造器。这可以扩展其它类型，将定制类型作为其构造器参数，或者提供该类型的原始实现中未提供的额外初始化选项。

扩展能为类添加新的便利构造器，但是它们不能为类添加新的指定构造器或析构器。指定构造器和析构器必须总是由原始的类实现来提供。

如果你使用扩展为一个值类型添加构造器，同时该值类型的原始实现中未定义任何定制的构造器，且所有存储属性提供了默认值，那么我们就可以在扩展中的构造器里调用默认构造器和逐一成员构造器。

如果你使用扩展给另一个模块中定义的结构体添加构造器，那么新的构造器直到定义模块中使用一个构造器之前，不能访问 self。

下面的例子定义了一个用于描述几何矩形的结构体 Rect。这个例子同时定义了两个辅助结构体 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 未提供定制的构造器，因此它会获得一个逐一成员构造器。又因为它为所有存储型属性提供了默认值，它又会获得一个默认构造器。

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

let centerRect = Rect(center: Point(x: 4.0, y: 4.0), size: Size(width: 3.0, height: 3.0))
// centerRect 的 origin 是 (2.5, 2.5) 并且它的 size 是 (3.0, 3.0)

注意：如果你使用扩展提供了一个新的构造器，你依旧有责任确保构造过程能够让实例完全初始化。

方法

扩展可以为已有类型添加新的实例方法和类型方法。

在下面的例子中，给 Int 类型添加了一个新的实例方法叫做 repetitions：

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

这个 repetitions(task:) 方法接受一个 () -> Void 类型的参数，它表示一个没有参数没有返回值的方法。

定义该扩展之后，你就可以对任意整数调用 repetitions(task:) 方法，将闭包中的任务执行整数对应的次数。

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

可以使用尾随闭包让调用更加简洁：

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

可变实例方法

通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改 self 或其属性的方法必须将该实例方法标注为 mutating。

下面的例子为 Swift 的 Int 类型添加了一个名为 square 的可变方法，用于计算原始值的平方值：

extension Int {
    mutating func square() {
        self = self * self
    }
}
var someInt = 3
someInt.square() // someInt 的值现在是 9

下标

扩展可以为已有类型添加新的下标。

这个例子为 Swift 内建类型 Int 添加了一个整型下标。该下标 [n] 返回十进制数字从右向左数的第 n 个数字。

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

如果该 Int 值没有足够的位数，即下标越界，那么上述下标实现会返回 0，犹如在数字左边自动补 0：

print(746381295[9]) // 打印 0
// 即等同于：
print(0746381295[9]) // 打印 0

嵌套类型

扩展可以为已有的类、结构体和枚举添加新的嵌套类型。

下面例子给 Int 添加了一个新的嵌套枚举。这个枚举叫做 Kind，表示特定整数所代表的数字类型。具体来说，它表示数字是负的、零的还是正的。这个例子同样给 Int 添加了一个新的计算型实例属性，叫做 kind，它返回被操作整数所对应的 Kind 枚举 case 分支。

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

方法 printIntegerKinds(_?，使用一个 Int 类型的数组作为输入，然后依次迭代这些值。对于数组中的每一个整数，方法会检查它的 kind 计算型属性，然后打印适当的描述。

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]) 
// 打印 “+ + - 0 - 0 + ”

注意：由于已知 number.kind 是 Int.Kind 类型，因此在 switch 语句中，Int.Kind 中的所有成员值都可以使用简写形式，例如使用 . Negative 而不是 Int.Kind.Negative。