关键字 extension

在 Swift 中，extension 关键词用于为已有的类、结构体、枚举和协议类型添加新功能。这使得你可以在不访问原始源码的情况下扩展类型的行为。Extensions 非常强大和灵活，它们可以：

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

下面是关于扩展（extension）的一些详细示例和解释：

基本用法 #

1. 添加计算属性 #

你可以通过扩展添加计算属性，但无法添加存储属性：

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 distance = 5.0.km
print(distance)  // 输出: 5000.0

2. 添加实例方法和类型方法 #

可以通过扩展添加新的实例方法和类型方法：

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

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

3. 提供新的构造器 #

扩展可以为现有类型添加新的构造器：

struct Point {
    var x = 0.0, y = 0.0
}

extension Point {
    init(value: Double) {
        self.x = value
        self.y = value
    }
}

let point = Point(value: 3.0)
print(point)  // 输出: Point(x: 3.0, y: 3.0)

4. 添加下标 #

可以为已有类型添加新的下标功能：

extension Array {
    subscript(safe index: Int) -> Element? {
        return indices.contains(index) ? self[index] : nil
    }
}

let array = [1, 2, 3]
print(array[safe: 1])  // 输出: Optional(2)
print(array[safe: 10]) // 输出: nil

使现有类型遵循协议 #

你可以通过扩展让现有类型遵循一个或多个协议：

protocol Printable {
    func printDescription()
}

extension Int: Printable {
    func printDescription() {
        print("Integer: \(self)")
    }
}

let num = 42
num.printDescription()  // 输出: Integer: 42

添加嵌套类型 #

可以在扩展中为已有类型添加新的嵌套类型：

extension Int {
    enum Parity {
        case even, odd
    }
    
    var parity: Parity {
        return self % 2 == 0 ? .even : .odd
    }
}

let number = 3
print(number.parity)  // 输出: odd

泛型扩展 #

你可以对泛型类型进行扩展，而不需要在扩展声明中再次指定泛型参数：

struct Stack<Element> {
    var items = [Element]()
    
    mutating func push(_ item: Element) {
        items.append(item)
    }
    
    mutating func pop() -> Element {
        return items.removeLast()
    }
}

extension Stack {
    var topElement: Element? {
        return items.last
    }
}

var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
print(intStack.topElement)  // 输出: Optional(2)

条件扩展 #

你可以对泛型类型进行条件扩展，限制扩展只能应用于满足某些条件的泛型类型：

extension Array where Element: Equatable {
    func isAllEqual() -> Bool {
        guard let first = self.first else { return true }
        return self.dropFirst().allSatisfy { $0 == first }
    }
}

let equalArray = [1, 1, 1, 1]
let nonEqualArray = [1, 2, 1, 1]

print(equalArray.isAllEqual())    // 输出: true
print(nonEqualArray.isAllEqual()) // 输出: false

总结 #

extension 是 Swift 中一个非常强大的工具，允许你为已有类型添加新的功能，而无需访问源代码。它们在打造模块化、可组合和易扩展的代码方面起着关键作用。