扩展 (Extension)
概述
Swift 中的扩展，有点类似于 OC 中的分类（Category）。
- 扩展可以为枚举、结构体、类、协议添加新增功能。
- 可以添加方法、计算属性、下标、（便捷）初始化器、嵌套类型、协议等等。
- 扩展不能办到的事情：
- 不能覆盖原有的功能。
- 不能添加存储属性，不能向已有的属性添加属性观察器。
- 不能添加父类。
- 不能添加指定初始化器，不能添加反初始化器。
- oc里面的分类是可以修改原有的存储结构，而swift中是不能影响之前的内存结构。
- 为啥不能增加存储属性，是因为如果增加存储属性的话，会影响原有的内存结构，扩展是不能影响原有的内存结构的。
- 不能添加父类，因为涉及继承，也有可能会改变原有的存储结构，也是不允许的。
- deinit只能写在类里面，不能写在扩展里面，且只能有一个
- 不能添加指定初始化器，指定初始化器只能有一个，也要写在类里面
例子
例子1 --单位的扩展
extension Double {
var km: Double { self * 1_000.0 }
var m: Double { self }
var dm: Double { self / 10.0 }
var cm: Double { self / 100.0 }
var mm: Double { self / 1_000.0 }
}
例子2 --Array 扩展（安全下标访问）
extension Array {
subscript(nullable idx: Int) -> Element? {
if idx >= startIndex && idx < endIndex {
return self[idx]
}
return nil
}
}
例子3 --Int 扩展（多种功能）
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
}
}
例子4
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 {
left.age == right.age && left.name == right.name
}
convenience init() {
self.init(age: 0, name: "")
}
}
- 指定初始化器不能放在扩展里面
- required 初始化器也不能写在扩展中
- 扩展里面可以放便捷初始化器
例子5
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)
上面的例子讲了一个问题就是如果下面的方法放在结构体里面，那么前面p1,p2,p3,p4后面初始化方法就没有，这是结构体的特点，想有自己的初始化器，又想好系统生成，可以和这个方法放在扩展里面，就想这个例子5这样的。
init(_ point: Point) {
self.init(x: point.x, y: point.y)
}
例子6
如果一个类型已经实现了协议的所有要求，但是还没有声明它遵守了这个协议，可以通过扩展来让它遵守这个协议
protocol TestProtocol {
func test()
}
class TestClass {
func test() {
print("test")
}
}
// 因为已经实现了，不需要再去实现了
extension TestClass : TestProtocol {}
例子7
编写一个函数，判断一个整数是否为奇数？
func isOdd<T: BinaryInteger>(_ i: T) -> Bool {
i % 2 != 0
}
extension BinaryInteger {
func isOdd() -> Bool { self % 2 != 0 }
}
两种实现方式：全局泛型函数，或扩展 BinaryInteger 协议添加实例方法。 这里其实主要讲一个问题就是
例子8
- 扩展可以给协议提供默认实现，也间接实现“可选协议”的效果
- 扩展可以给协议扩充「协议中从未声明过的方法」
protocol TestProtocol {
func test1()
}
extension TestProtocol {
func test1() {
print("TestProtocol test1")
}
func test2() {
print("TestProtocol test2")
}
}
首先说可以看test1方法在扩展里面实现了，那么别的类在使用这个协议的时候就可以不实现这个方法，因为扩展已经实现了
其次再看一点可以看到我们可以给协议补充方法，比方说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 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
上面例子的输出需要重点讲解一下，不带协议的这个情况首先看到的是肯定是先调用类本身的方法 后面的这种情况，可以这样想，test1方法协议已经实现了，所以会掉自身的这个方法，肯定是调类里面的方法，而test2协议里面没有定义，就不一定实现了，就去调扩展里面的方法。
例子9
class Stack<E> {
var elements = [E]()
func push(_ element: E) {
elements.append(element)
}
func pop() -> E { elements.removeLast() }
func size() -> Int { elements.count }
}
// 扩展中依然可以使用原类型中的泛型类型
extension Stack {
func top() -> E { elements.last! }
}
// 符合条件才扩展
extension Stack : Equatable where E : Equatable {
static func == (left: Stack, right: Stack) -> Bool {
left.elements == right.elements
}
}
- 扩展中依然可以使用原类型中的泛型类型，就是说原来类里面有啥泛型，这里可以继续用
- 如果你想限制满足符合条件才扩展可以使用where
