Swift 中的扩展是什么？如何使用扩展？

Swift 中的扩展是什么？如何使用扩展？扩展可以添加哪些功能？

Swift 中的扩展是一种为现有的类、结构体、枚举或协议类型添加新功能的机制。扩展可以添加新的功能，但不能重写现有的功能。

扩展的基本用法：

swift
extension Int {
    var squared: Int {
        return self * self
    }
    
    func isEven() -> Bool {
        return self % 2 == 0
    }
}

let number = 5
print(number.squared)  // 25
print(number.isEven())  // false

扩展可以添加的功能：

1. 计算属性：

   swift
   extension Double {
       var km: Double { return self * 1000 }
       var m: Double { return self }
       var cm: Double { return self / 100 }
       var mm: Double { return self / 1000 }
   }
   
   let oneInch = 25.4.mm
   print("One inch is \(oneInch) meters")

2. 实例方法：

   swift
   extension String {
       func reversed() -> String {
           return String(self.reversed())
       }
       
       func trimmed() -> String {
           return self.trimmingCharacters(in: .whitespacesAndNewlines)
       }
   }
   
   let text = "Hello World"
   print(text.reversed())  // dlroW olleH

3. 类型方法：

   swift
   extension Int {
       static func random(in range: Range<Int>) -> Int {
           return Int.random(in: range)
       }
   }
   
   let randomNum = Int.random(in: 1..<100)

4. 初始化器：

   swift
   extension UIColor {
       convenience init(hex: String) {
           let hex = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
           var int: UInt64 = 0
           Scanner(string: hex).scanHexInt64(&int)
           let a, r, g, b: UInt64
       }
   }

5. 下标：

   swift
   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

6. 嵌套类型：

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

协议扩展：

swift
protocol TextRepresentable {
    var textualDescription: String { get }
}

extension TextRepresentable {
    func describe() -> String {
        return "Description: \(textualDescription)"
    }
}

struct Person: TextRepresentable {
    var textualDescription: String
}

let person = Person(textualDescription: "John Doe")
print(person.describe())

条件扩展：

swift
extension Collection where Element: Equatable {
    func allEqual() -> Bool {
        guard let first = first else { return true }
        return all { $0 == first }
    }
}

extension Array where Element: Numeric {
    func sum() -> Element {
        return reduce(0, +)
    }
}

扩展的限制：

• 不能添加存储属性
• 不能添加属性观察器
• 不能重写现有的方法
• 不能添加指定的初始化器
• 不能添加反初始化器

最佳实践：

1. 使用扩展组织相关功能
2. 使用协议扩展提供默认实现
3. 使用条件扩展为特定类型添加功能
4. 避免在扩展中添加过多功能
5. 保持扩展的单一职责原则