扩展(Extension)
Swift 中的扩展,有点类似于OC中的分类(Category)
扩展可以分为枚举、结构体、类、协议添加新功能。
- 可以添加方法、计算属性、下标、便捷初始化器、嵌套类型、协议等等。
扩展不能办到的事:
- 不能覆盖原有的功能。
- 不能添加存储属性,不能向已有属性添加属性观察器。
- 不能添加父类。
- 不能添加指定初始化器,不能添加反初始化器(
deinit
)。
计算属性、下标、方法、嵌套类型
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 }
}
let a: Double = 100
print(a.km) // 100000.0
print(a.m) // 100.0
print(a.dm) // 10.0
extension Array {
subscript(nullable idx: Int) -> Element? {
if (startIndex..<endIndex).contains(idx) {
return self[idx]
}
return nil
}
}
extension Int {
func repetitions(task: () -> Void) {
for _ in 0..<self { task() }
}
mutating func square() -> Int {
self = self * self
return self
}
enum Kind { case nagative, zero, positive }
var kind: Kind {
switch self {
case 0:
return .zero
case let x where x > 0:
return .positive
default:
return .nagative
}
}
subscript(digitIndex: Int) -> Int {
var decimalBase = 1
for _ in 0..<digitIndex { decimalBase *= 10 }
return (self/decimalBase) % 10
}
}
10.repetitions {
print("wo")
}
print(10.kind)
协议、初始化器
class Person {
var age: Int
var name: String
init(age: Int, name: String) {
self.age = age
self.name = name
}
}
extension Person: Equatable {
static func == (lhs: Person, rhs: Person) -> Bool {
(lhs.age == rhs.age) && (lhs.name == rhs.name)
}
convenience init(age: Int) {
self.init(age: age, name: "")
}
}
let person1 = Person(age: 10) // 便捷初始化器
let person2 = Person(age: 20, name: "long")
print(person1 == person2) // false
如果希望自定义初始化器的同时,编译器也能生成默认的初始化器。
- 可以在扩展中编写自定义初始化器。
- 指定初始化器和
required
初始化器不能写在扩展中。
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, y: 20) // 在扩展中自定义初始化器后,系统默认生成的初始化器依然存在
var p3 = Point(p1)
协议
如果一个类型已经实现了协议的所有要求,但是还没有声明它遵守这个协议。那可以通过扩展来让它遵守。
protocol TestProtocol {
func test()
}
class TestClass {
func test() {
print("test")
}
}
extension TestClass: TestProtocol {
// TestClass 已满足协议的所有要求,可通过扩展了让TestClass 遵守 TestProtocol 协议
}
知识扩展:
// 编写一个函数,判断一个整数是否为奇数
func isOdd<T: BinaryInteger>(_ i: T) -> Bool {
i % 2 != 0
}
extension BinaryInteger {
func isOdd() -> Bool {
self % 2 != 0
}
}
扩展可以给协议提供默认实现,可间接实现【可选协议】的效果。
扩展可以给协议扩充【协议中从未声明过的方法】。
protocol TestProtocol {
func test1()
}
extension TestProtocol {
func test1() {
print("TestProtocol test1")
}
func test2() {
print("TestProtocol test2")
}
}
class TestClass: TestProtocol {
func test1() {
print("TestClass test1")
}
func test2() {
print("TestClass test2")
}
}
class TestClass1: TestProtocol {} // 扩展中提供了test1方法的默认实现。(类似于可选协议)
var cls = TestClass()
cls.test1() // TestClass test1
cls.test2() // TestClass test2
var cls2: TestProtocol = TestClass()
cls2.test1() // TestClass test1
cls2.test2() // TestProtocol test2 (需留意)
泛型
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
}
}