MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Swift扩展功能的应用场景剖析

2023-04-067.4k 阅读

一、Swift 扩展功能概述

在 Swift 编程语言中，扩展（Extensions）是一种强大的特性，它允许我们在不修改原始代码的情况下，为现有的类、结构体、枚举甚至协议添加新的功能。这一特性极大地提高了代码的灵活性和可维护性。从本质上来说，扩展就像是对现有类型的一种“增量式”改进，让我们可以根据具体需求逐步丰富类型的功能。

在 Swift 中，使用 extension 关键字来定义扩展。例如，为 Int 类型添加一个简单的扩展：

extension Int {
    func squared() -> Int {
        return self * self
    }
}

let number = 5
let squaredNumber = number.squared()
print(squaredNumber) // 输出 25

在上述代码中，通过扩展 Int 类型，为其添加了一个 squared 方法，使得所有 Int 类型的实例都可以调用这个方法来获取自身的平方值。

二、扩展在类中的应用场景

（一）为现有类添加便捷方法

  1. 数学计算相关便捷方法 对于处理数字相关的类，扩展可以添加许多实用的数学计算方法。比如 Double 类型，我们经常需要进行一些常见的数学运算，如计算绝对值、平方根等。虽然 Swift 标准库已经提供了一些函数，但通过扩展可以让这些操作更加面向对象。
extension Double {
    func absoluteValue() -> Double {
        return self < 0? -self : self
    }

    func squareRoot() -> Double {
        return self >= 0? sqrt(self) : 0
    }
}

let negativeNumber: Double = -5.0
let absValue = negativeNumber.absoluteValue()
print(absValue) // 输出 5.0

let positiveNumber: Double = 9.0
let rootValue = positiveNumber.squareRoot()
print(rootValue) // 输出 3.0
  1. 日期和时间处理便捷方法 在处理 Date 类时，扩展也能发挥很大作用。例如，我们可能经常需要获取某个日期是星期几，或者计算两个日期之间的天数差。
extension Date {
    func dayOfWeek() -> String {
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "EEEE"
        return dateFormatter.string(from: self)
    }

    func days(to otherDate: Date) -> Int {
        let calendar = Calendar.current
        return calendar.dateComponents([.day], from: self, to: otherDate).day?? 0
    }
}

let today = Date()
let dayOfWeek = today.dayOfWeek()
print(dayOfWeek)

let anotherDate = Calendar.current.date(byAdding:.day, value: 5, to: today)!
let daysDiff = today.days(to: anotherDate)
print(daysDiff) // 输出 5

（二）将类的功能模块化

  1. 视图控制器相关功能模块化 在 iOS 开发中，视图控制器（UIViewController）往往承担着多种职责，如视图布局、数据加载、用户交互处理等。通过扩展可以将这些职责进行模块化，使代码结构更加清晰。 例如，我们可以将视图控制器的视图布局相关代码放在一个扩展中：
class MyViewController: UIViewController {
    // 其他属性和方法
}

extension MyViewController {
    func setupViews() {
        let label = UILabel(frame: CGRect(x: 100, y: 100, width: 200, height: 50))
        label.text = "Hello, World!"
        view.addSubview(label)
    }
}

// 在合适的地方调用
let myVC = MyViewController()
myVC.setupViews()

这样，在主类中可以专注于核心业务逻辑，而将视图布局相关代码放在扩展中，提高了代码的可读性和可维护性。 2. 模型类的数据处理模块化 对于模型类，比如一个表示用户信息的 User 类，我们可能有不同类型的数据处理需求，如数据验证、数据格式化等。通过扩展可以将这些功能模块化。

class User {
    let name: String
    let age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

extension User {
    func isValid() -> Bool {
        return!name.isEmpty && age > 0
    }

    func formatUserInfo() -> String {
        return "Name: \(name), Age: \(age)"
    }
}

let user = User(name: "John", age: 30)
let isValid = user.isValid()
print(isValid) // 输出 true

let formattedInfo = user.formatUserInfo()
print(formattedInfo) // 输出 Name: John, Age: 30

三、扩展在结构体中的应用场景

（一）增强标准库结构体功能

  1. CGPoint 结构体的扩展 在 iOS 和 macOS 开发中，CGPoint 结构体用于表示二维平面上的一个点。我们可以通过扩展为其添加一些实用的功能，比如计算两个点之间的距离。
import CoreGraphics

extension CGPoint {
    func distance(to otherPoint: CGPoint) -> CGFloat {
        let dx = otherPoint.x - x
        let dy = otherPoint.y - y
        return sqrt(dx * dx + dy * dy)
    }
}

let point1 = CGPoint(x: 0, y: 0)
let point2 = CGPoint(x: 3, y: 4)
let distance = point1.distance(to: point2)
print(distance) // 输出 5.0
  1. Size 结构体的扩展 Size 结构体用于表示尺寸，我们可以扩展它来进行一些尺寸相关的计算，比如判断一个尺寸是否大于另一个尺寸。
import CoreGraphics

extension CGSize {
    func isGreater(than otherSize: CGSize) -> Bool {
        return width > otherSize.width && height > otherSize.height
    }
}

let size1 = CGSize(width: 100, height: 200)
let size2 = CGSize(width: 50, height: 150)
let isGreater = size1.isGreater(than: size2)
print(isGreater) // 输出 true

（二）为自定义结构体添加特定功能

  1. 表示坐标系统的自定义结构体扩展 假设我们有一个自定义的结构体 CoordinateSystem 用于表示一个简单的坐标系统，我们可以通过扩展为其添加一些转换相关的功能。
struct CoordinateSystem {
    var x: Double
    var y: Double
}

extension CoordinateSystem {
    func toPolarCoordinates() -> (radius: Double, angle: Double) {
        let radius = sqrt(x * x + y * y)
        let angle = atan2(y, x)
        return (radius, angle)
    }
}

let coordinate = CoordinateSystem(x: 3.0, y: 4.0)
let polarCoords = coordinate.toPolarCoordinates()
print("Radius: \(polarCoords.radius), Angle: \(polarCoords.angle)")
  1. 表示颜色的自定义结构体扩展 如果我们有一个自定义的 Color 结构体来表示颜色，我们可以扩展它来进行颜色相关的操作，比如颜色混合。
struct Color {
    var red: CGFloat
    var green: CGFloat
    var blue: CGFloat
    var alpha: CGFloat

    init(red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat = 1.0) {
        self.red = red
        self.green = green
        self.blue = blue
        self.alpha = alpha
    }
}

extension Color {
    func blend(with otherColor: Color) -> Color {
        let newRed = (red + otherColor.red) / 2
        let newGreen = (green + otherColor.green) / 2
        let newBlue = (blue + otherColor.blue) / 2
        let newAlpha = (alpha + otherColor.alpha) / 2
        return Color(red: newRed, green: newGreen, blue: newBlue, alpha: newAlpha)
    }
}

let color1 = Color(red: 1.0, green: 0.0, blue: 0.0)
let color2 = Color(red: 0.0, green: 1.0, blue: 0.0)
let blendedColor = color1.blend(with: color2)
print("Blended Color - Red: \(blendedColor.red), Green: \(blendedColor.green), Blue: \(blendedColor.blue), Alpha: \(blendedColor.alpha)")

四、扩展在枚举中的应用场景

（一）为枚举添加计算属性

  1. 方向枚举的计算属性扩展 假设我们有一个表示方向的枚举 Direction，我们可以通过扩展为其添加一些计算属性，比如获取相反方向。
enum Direction {
    case north
    case south
    case east
    case west
}

extension Direction {
    var opposite: Direction {
        switch self {
        case.north:
            return.south
        case.south:
            return.north
        case.east:
            return.west
        case.west:
            return.east
        }
    }
}

let northDirection = Direction.north
let oppositeDirection = northDirection.opposite
print(oppositeDirection) // 输出.south
  1. 星期枚举的计算属性扩展 对于表示星期的枚举，我们可以扩展它来获取一些关于星期的信息，比如是否是工作日。
enum Weekday {
    case sunday
    case monday
    case tuesday
    case wednesday
    case thursday
    case friday
    case saturday
}

extension Weekday {
    var isWeekday: Bool {
        switch self {
        case.sunday, .saturday:
            return false
        default:
            return true
        }
    }
}

let monday = Weekday.monday
let isWeekday = monday.isWeekday
print(isWeekday) // 输出 true

let sunday = Weekday.sunday
let isSundayWeekday = sunday.isWeekday
print(isSundayWeekday) // 输出 false

（二）为枚举添加方法

  1. 状态枚举的方法扩展 假设我们有一个表示应用程序状态的枚举 AppState，我们可以为其添加一些方法来处理状态转换。
enum AppState {
    case idle
    case loading
    case running
    case paused
}

extension AppState {
    mutating func transition(to newState: AppState) {
        if (self ==.idle && newState ==.loading) ||
           (self ==.loading && (newState ==.running || newState ==.paused)) ||
           (self ==.running && (newState ==.paused || newState ==.idle)) ||
           (self ==.paused && (newState ==.running || newState ==.idle)) {
            self = newState
        } else {
            print("Invalid state transition")
        }
    }
}

var appState = AppState.idle
appState.transition(to:.loading)
print(appState) // 输出.loading

appState.transition(to:.paused)
print(appState) // 输出.paused

appState.transition(to:.idle)
print(appState) // 输出.idle
  1. 文件类型枚举的方法扩展 对于表示文件类型的枚举，我们可以扩展它来获取文件类型对应的图标名称。
enum FileType {
    case document
    case image
    case video
    case audio
}

extension FileType {
    func iconName() -> String {
        switch self {
        case.document:
            return "doc_icon"
        case.image:
            return "image_icon"
        case.video:
            return "video_icon"
        case.audio:
            return "audio_icon"
        }
    }
}

let fileType = FileType.image
let iconName = fileType.iconName()
print(iconName) // 输出 image_icon

五、扩展在协议中的应用场景

（一）为协议提供默认实现

  1. 可打印协议的默认实现 假设我们定义了一个 Printable 协议，要求遵循该协议的类型提供一个 printDescription 方法。我们可以通过扩展为协议提供一个默认实现。
protocol Printable {
    func printDescription() -> String
}

extension Printable {
    func printDescription() -> String {
        return "Default description"
    }
}

struct MyStruct: Printable {
    // 可以不实现 printDescription 方法，使用默认实现
}

let myStruct = MyStruct()
let description = myStruct.printDescription()
print(description) // 输出 Default description
  1. 可计算协议的默认实现 如果有一个 Calculable 协议，用于表示可进行某种计算的类型，我们可以为其提供默认的计算实现。
protocol Calculable {
    func calculate() -> Int
}

extension Calculable {
    func calculate() -> Int {
        return 0
    }
}

class MyClass: Calculable {
    // 可以不实现 calculate 方法，使用默认实现
}

let myClass = MyClass()
let result = myClass.calculate()
print(result) // 输出 0

（二）扩展协议功能

  1. 数据存储协议的功能扩展 假设我们有一个 DataStorable 协议，用于表示可以存储数据的类型。我们可以通过扩展为其添加一些额外的功能，比如获取存储数据的大小。
protocol DataStorable {
    func store(data: String)
    func retrieve() -> String?
}

extension DataStorable {
    func dataSize() -> Int {
        if let data = retrieve() {
            return data.count
        }
        return 0
    }
}

class InMemoryStore: DataStorable {
    private var storedData: String?

    func store(data: String) {
        storedData = data
    }

    func retrieve() -> String? {
        return storedData
    }
}

let inMemoryStore = InMemoryStore()
inMemoryStore.store(data: "Hello, World!")
let size = inMemoryStore.dataSize()
print(size) // 输出 13
  1. 排序协议的功能扩展 对于一个 Sortable 协议，用于表示可排序的类型。我们可以扩展它来提供一些排序相关的辅助方法，比如获取排序后的副本。
protocol Sortable {
    func compare(to other: Self) -> ComparisonResult
}

extension Sortable {
    func sorted() -> [Self] {
        var array: [Self] = []
        // 假设这里有一个方法可以获取所有实例，实际应用中需要根据具体情况实现
        let allInstances = getAllInstances()
        for instance in allInstances {
            var inserted = false
            for (index, existing) in array.enumerated() {
                if compare(to: existing) ==.orderedAscending {
                    array.insert(instance, at: index)
                    inserted = true
                    break
                }
            }
            if!inserted {
                array.append(instance)
            }
        }
        return array
    }
}

struct Number: Sortable {
    let value: Int

    func compare(to other: Number) -> ComparisonResult {
        return value < other.value?.orderedAscending : value > other.value?.orderedDescending :.orderedSame
    }
}

let number1 = Number(value: 3)
let number2 = Number(value: 1)
let number3 = Number(value: 2)

let sortedNumbers = [number1, number2, number3].sorted()
for number in sortedNumbers {
    print(number.value)
}
// 输出 1 2 3

六、扩展在代码组织和复用方面的优势

（一）代码组织更清晰

  1. 按功能划分扩展 通过将不同功能的代码放在不同的扩展中，使得代码结构更加清晰。例如，对于一个复杂的类，我们可以将其网络请求相关的功能放在一个扩展中，数据处理功能放在另一个扩展中。
class MyComplexClass {
    // 类的基本属性和方法
}

extension MyComplexClass {
    // 网络请求相关方法
    func fetchData() {
        // 网络请求代码
    }
}

extension MyComplexClass {
    // 数据处理相关方法
    func processData(data: Data) {
        // 数据处理代码
    }
}

这样，在阅读和维护代码时，可以快速定位到特定功能的代码，提高了代码的可读性。 2. 分离协议实现 当一个类遵循多个协议时，将每个协议的实现放在不同的扩展中，可以使代码更加清晰。

class MyClass: Protocol1, Protocol2 {
    // 类的其他代码
}

extension MyClass: Protocol1 {
    func protocol1Method() {
        // Protocol1 方法的实现
    }
}

extension MyClass: Protocol2 {
    func protocol2Method() {
        // Protocol2 方法的实现
    }
}

（二）提高代码复用性

  1. 跨项目复用扩展 如果在一个项目中为某个类型编写了有用的扩展，在其他项目中如果使用到相同的类型，就可以很方便地复用这些扩展。例如，为 String 类型编写的用于验证邮箱格式的扩展：
extension String {
    func isValidEmail() -> Bool {
        let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
        let emailPred = NSPredicate(format: "SELF MATCHES %@", emailRegEx)
        return emailPred.evaluate(with: self)
    }
}

这个扩展可以在多个需要验证邮箱格式的项目中复用，提高了开发效率。 2. 不同模块间复用扩展 在一个大型项目中，不同模块可能都需要对某个基础类型进行扩展。通过将这些扩展放在一个公共的模块中，可以实现不同模块间的复用。比如，在一个 iOS 应用的不同视图控制器模块中，都可能需要对 UIView 进行扩展来添加一些自定义的动画效果，将这些扩展放在一个公共的 UIView+Extensions 文件中，各个模块都可以使用。

七、使用扩展时的注意事项

（一）避免命名冲突

  1. 与现有成员冲突 在为类型添加扩展时，要注意避免扩展中的方法或属性与该类型原有的成员命名冲突。例如，如果为 Int 类型扩展一个名为 description 的属性，而 Int 类型本身已经有一个 description 属性，就会导致编译错误。
// 以下代码会导致编译错误
extension Int {
    var description: String {
        return "Custom description"
    }
}
  1. 不同扩展间冲突 如果在多个扩展中为同一个类型添加了同名的成员，也会导致编译错误。例如：
extension Int {
    func customMethod() {
        print("First custom method")
    }
}

extension Int {
    func customMethod() {
        print("Second custom method")
    }
}
// 以上代码会导致编译错误，因为两个扩展中都有 customMethod

（二）注意扩展的访问控制

  1. 默认访问控制 扩展默认具有与被扩展类型相同的访问控制级别。例如，如果扩展一个公开（public）的类，扩展中的成员默认也是公开的。但如果扩展一个内部（internal）的类，扩展中的成员默认也是内部的。
public class MyPublicClass {
    // 类的代码
}

extension MyPublicClass {
    public func publicMethodInExtension() {
        // 公开方法
    }

    func internalMethodInExtension() {
        // 内部方法，因为扩展默认与类的访问控制级别相同
    }
}
  1. 显式设置访问控制 我们也可以显式地为扩展中的成员设置访问控制级别，但不能超过被扩展类型的访问控制级别。例如，不能在扩展一个内部类时，将某个成员设置为公开。
internal class MyInternalClass {
    // 类的代码
}

extension MyInternalClass {
    internal func internalMethodInExtension() {
        // 合法，内部方法
    }

    // 以下代码会导致编译错误，不能将成员设置为公开
    // public func publicMethodInExtension() {
    //     // 代码
    // }
}

八、总结扩展的强大功能与应用潜力

Swift 的扩展功能为开发者提供了极大的灵活性和便利性。从为现有类型添加便捷方法，到将类的功能模块化，再到在协议中提供默认实现和扩展功能，扩展在各种场景下都发挥着重要作用。它不仅使代码组织更加清晰，提高了代码的可读性和可维护性，还极大地增强了代码的复用性，无论是在同一个项目的不同模块之间，还是在不同项目之间，都可以方便地复用扩展代码。

然而，在使用扩展时，我们也需要注意避免命名冲突，合理设置访问控制，以确保代码的正确性和安全性。通过深入理解和熟练运用扩展功能，开发者能够更加高效地开发出高质量、可维护的 Swift 应用程序，充分发挥 Swift 语言的强大潜力。无论是在小型的 iOS 应用开发，还是大型的跨平台项目中，扩展都将是提升开发效率和代码质量的重要工具。