Swift计算属性：动态计算的强大工具

在Swift编程中，属性是构成类、结构体和枚举的重要组成部分。其中，计算属性（Computed Properties） 提供了一种灵活的方式来动态计算值，而不是直接存储数据。理解计算属性的工作机制、适用场景及其与存储属性的区别，对于编写高效、可维护的Swift代码至关重要。

1. 计算属性基础

1.1 什么是计算属性？

计算属性是Swift中一种特殊的属性，它不直接存储值，而是通过一个getter（获取器）和可选的setter（设置器）来间接获取和设置其他属性或值。计算属性的值是在每次访问时动态计算的。

struct Rectangle {
    var width: Double
    var height: Double
    
    // 计算属性area，根据width和height动态计算面积
    var area: Double {
        return width * height
    }
}

let rect = Rectangle(width: 5.0, height: 10.0)
print(rect.area) // 输出: 50.0

代码说明：area 是一个计算属性，它返回矩形 width 和 height 的乘积。

1.2 计算属性的语法

计算属性的基本语法如下：

var propertyName: PropertyType {
    get {
        // 计算并返回属性值的代码
    }
    set(newValue) {
        // 设置其他属性或值的代码，通常基于newValue
    }
}
  • Getter：使用 get 关键字定义，用于计算并返回属性值。如果整个计算属性是只读的，可以省略 get 关键字和花括号，直接返回。
  • Setter：使用 set 关键字定义，可选。它接收一个参数（默认为 newValue），用于在给计算属性赋值时更新其他相关属性或执行其他操作。

1.3 只读 vs. 读写计算属性

  • 只读计算属性：只有 getter，没有 setter。可以省略 get 关键字。

    struct Circle {
    var radius: Double
    // 只读计算属性
    var circumference: Double {
        return 2 * .pi * radius
    }
}

  • 读写计算属性：同时包含 getter 和 setter。

    struct TemperatureConverter {
    var celsius: Double
    // 读写计算属性
    var fahrenheit: Double {
        get {
            return celsius * 1.8 + 32
        }
        set {
            celsius = (newValue - 32) / 1.8 // 使用默认参数名newValue
        }
    }
}

    代码说明：fahrenheit 属性实现了摄氏温度与华氏温度的相互转换。

    你也可以在 setter 中自定义参数名：

    set(newFahrenheit) {
    celsius = (newFahrenheit - 32) / 1.8
}

2. 计算属性与存储属性

理解计算属性与存储属性的区别是掌握Swift属性的关键。

2.1 核心区别

特性存储属性 (Stored Properties)计算属性 (Computed Properties)
数据存储直接在实例内存中存储常量或变量值不存储值，动态计算
内存占用是，每个实例都会分配内存否（但getter/setter方法本身有代码存储开销）
语法var 或 let，可设置默认值var + get/set 块
适用类型类、结构体类、结构体、枚举
属性观察器支持 willSet 和 didSet不支持（逻辑可在setter中实现）
延迟加载支持（使用 lazy 关键字）不支持

2.2 代码示例对比

// 存储属性示例
struct Car {
    var model: String // 变量存储属性
    let year: Int     // 常量存储属性
}

// 计算属性示例
struct Square {
    var sideLength: Double
    // 计算属性area
    var area: Double {
        get {
            return sideLength * sideLength
        }
        set {
            sideLength = sqrt(newValue) // 通过面积设置边长
        }
    }
}

2.3 初始化与内存的差异

  • 存储属性：必须在定义时设置默认值或在初始化器中赋值。它们占用实例的内存空间。

    struct Person {
    var name: String // 必须初始化
    let birthYear: Int // 必须初始化
}

  • 计算属性：无需初始化，因为它们不存储值。它们提供的是计算值的“方法”。

    struct Employee {
    var hourlyRate: Double
    var hoursWorked: Double
    // 计算属性无需初始化
    var salary: Double {
        return hourlyRate * hoursWorked
    }
}

3. 计算属性的高级用法

3.1 在扩展中添加计算属性

Swift的扩展（Extension） 允许你向已有的类、结构体、枚举或协议添加新功能，包括计算属性。这是一种非常强大的功能，无需修改原始类型即可增强其能力。

// 原始类型
class Vehicle {
    var speed: Double = 0.0
}

// 通过扩展添加计算属性
extension Vehicle {
    var speedInKmh: Double {
        get {
            return speed * 1.60934
        }
        set {
            speed = newValue / 1.60934
        }
    }
}

let car = Vehicle()
car.speed = 60.0
print(car.speedInKmh) // 输出约96.5604

代码说明：通过扩展为 Vehicle 类添加了一个用于速度单位转换的计算属性。

3.2 计算属性与泛型结合

泛型允许你编写灵活、可重用的函数和类型。计算属性与泛型结合使用时，可以创造出非常动态和通用的行为。

struct Stack<Element> {
    private var elements: [Element] = []
    
    mutating func push(_ element: Element) {
        elements.append(element)
    }
    
    mutating func pop() -> Element? {
        return elements.popLast()
    }
    
    // 泛型计算属性：返回栈顶元素，类型随Element动态确定
    var top: Element? {
        return elements.last
    }
    
    // 泛型计算属性：判断栈是否为空
    var isEmpty: Bool {
        return elements.isEmpty
    }
}

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

代码说明：Stack 结构体是泛型的，其计算属性 top 和 isEmpty 的类型和行为会根据泛型参数 Element 具体类型而定。

3.3 使用计算属性处理复杂逻辑

计算属性非常适合封装依赖于多个其他属性的复杂逻辑或派生数据。

struct User {
    var firstName: String
    var lastName: String
    
    // 计算属性生成全名
    var fullName: String {
        get {
            return "\(firstName) \(lastName)"
        }
        set {
            let components = newValue.split(separator: " ")
            if components.count >= 2 {
                firstName = String(components[0])
                lastName = String(components[1])
            }
        }
    }
}

var user = User(firstName: "John", lastName: "Doe")
print(user.fullName) // 输出: John Doe
user.fullName = "Jane Smith"
print(user.firstName) // 输出: Jane
print(user.lastName)  // 输出: Smith

代码说明：fullName 属性将两个存储属性组合起来，并通过setter解析字符串更新它们。

struct File {
    var filename: String
    var extensionType: String
    
    // 计算属性处理文件名和扩展名
    var fullFilename: String {
        get {
            return "\(filename).\(extensionType)"
        }
        set(newFullFilename) {
            let parts = newFullFilename.split(separator: ".")
            if parts.count == 2 {
                filename = String(parts[0])
                extensionType = String(parts[1])
            }
        }
    }
}

代码说明：fullFilename 动态组合或解析文件名和扩展名。

4. 计算属性的实用场景

计算属性在Swift开发中应用广泛，以下是一些常见场景：

  1. 几何计算与派生数据： 如前所述的Rectangle的area、Circle的circumference、Point的distanceFromOrigin等。

  2. 数据格式化与转换：

    struct Product {
    var price: Double
    var currencyCode: String = "USD"
    
    // 格式化价格字符串
    var formattedPrice: String {
        let formatter = NumberFormatter()
        formatter.numberStyle = .currency
        formatter.currencyCode = currencyCode
        return formatter.string(from: NSNumber(value: price)) ?? "$\(price)"
    }
}

  3. 依赖其他属性的状态值：

    struct Order {
    var items: [String]
    var unitPrice: Double
    
    // 订单总价依赖于商品数量和单价
    var totalPrice: Double {
        return Double(items.count) * unitPrice
    }
    
    // 是否为大订单
    var isLargeOrder: Bool {
        return totalPrice > 100.0
    }
}

  4. 提供对私有属性的受控访问（封装）：

    class BankAccount {
    private var _balance: Double = 0.0 // 私有存储属性
    
    // 公开的计算属性，提供受控访问
    var balance: Double {
        get {
            return _balance
        }
        set {
            // 可以在此添加验证逻辑，如不能设置为负数
            if newValue >= 0 {
                _balance = newValue
            } else {
                print("Invalid balance value")
            }
        }
    }
}

  5. 在枚举中提供关联值的便捷访问：

    enum Measurement {
    case length(Double)
    case weight(Double)
    
    // 计算属性返回数值部分
    var value: Double {
        get {
            switch self {
            case .length(let value), .weight(let value):
                return value
            }
        }
        set {
            // 根据当前case更新关联值
            switch self {
            case .length:
                self = .length(newValue)
            case .weight:
                self = .weight(newValue)
            }
        }
    }
}

5. 性能考量与最佳实践

5.1 性能影响

计算属性每次被访问时都会执行其getter（或setter）中的代码。这意味着：

  • 简单计算：如乘法、加法等，开销极小，通常可忽略不计。
  • 复杂计算：如果计算涉及密集运算（如循环、递归、数据库查询、网络请求等），每次访问都执行可能会成为性能瓶颈。

优化策略：

  • 缓存结果：如果计算成本高且值不常变化，可以考虑将结果存储在一个私有存储属性中（即缓存），并在依赖属性变化时更新该缓存。
    struct ExpensiveCalculation {
    var inputValue: Int {
        didSet {
            // 当输入变化时，清除缓存
            _cachedOutput = nil
        }
    }
    private var _cachedOutput: Int? // 缓存
    
    var output: Int {
        get {
            // 如果有缓存，返回缓存值
            if let cached = _cachedOutput {
                return cached
            }
            // 否则进行昂贵计算并缓存结果
            let result = performExpensiveCalculation(inputValue)
            _cachedOutput = result
            return result
        }
    }
    private func performExpensiveCalculation(_ input: Int) -> Int {
        // 模拟复杂计算
        return input * input // 假设这实际上非常耗时
    }
}
  • 使用延迟存储属性（Lazy Stored Properties）：对于初始化成本高且可能不会总是被用到的属性，lazy 关键字可以延迟其初始化直到第一次访问。但注意 lazy 是用于存储属性，而非计算属性。

5.2 计算属性 vs. 方法

何时使用计算属性，何时使用方法？这是一个常见的设计决策。

特性计算属性方法
用途获取或设置一个与实例状态相关的、概念上作为“数据”的值执行一个操作、动作或计算
参数不能接受参数（setter的参数 newValue 是固定的）可以接受多个参数
复杂度通常应是简单、快速的计算，不应有显著的副作用可以处理复杂逻辑，包含副作用（如修改内部状态、网络请求）
语法instance.propertyinstance.methodName()

一般准则：

  • 如果你要提供的是一个派生数据（如fullName），并且计算快速、无副作用，优先考虑计算属性。
  • 如果操作需要参数（如 calculateArea(withFactor: Double)），或者执行复杂、耗时的任务（如从数据库加载），或者有明显的副作用（如修改外部状态），则应该使用方法。

5.3 其他最佳实践

  • 只读计算属性可以省略 get：使代码更简洁。
  • setter中通常应更新存储属性：计算属性的setter通常用于反向计算并更新一个或多个存储属性。
  • 避免在计算属性的getter中产生副作用：getter的主要目的应是返回计算值，不应执行修改全局状态等意外操作。
  • 注意值类型中的变异：在结构体或枚举的计算属性setter中修改其他属性，需要将计算属性标记为 mutating。
    struct Point {
    var x = 0.0, y = 0.0
    var isOrigin: Bool {
        get {
            return x == 0 && y == 0
        }
        set {
            // 因为要在setter中修改存储属性x和y，所以需要mutating
            if newValue {
                x = 0
                y = 0
            }
        }
    }
}

6. 与相关特性的对比与协作

6.1 计算属性与属性观察器

  • 属性观察器（willSet, didSet）：用于存储属性，监听属性值的变化并作出响应。它们在值被存储前后调用。
  • 计算属性：不存储值，其setter可以用于在赋值时更新其他属性。

注意：你不能为计算属性添加属性观察器，因为它的值不是存储的，变化可以通过setter本身来管理和观察。

6.2 计算属性与延迟存储属性

  • 延迟存储属性（lazy）：是一种存储属性，其初始值直到第一次使用时才计算并存储。用于优化初始化性能。
  • 计算属性：每次访问都计算，不存储值。

它们解决的问题不同：lazy 延迟昂贵的初始化；计算属性提供动态值。

7. 在Objective-C中的对应概念

在Objective-C中，没有直接等同于Swift计算属性的语法糖。通常需要通过手动实现属性的getter和setter方法来实现类似功能。

// Circle.h
@interface Circle : NSObject
@property (nonatomic) double radius; // 存储属性
@property (nonatomic) double area;   // 计算属性（概念上）
@end

// Circle.m
@implementation Circle
// 编译器为radius自动合成实例变量 _radius

// 手动实现area的getter和setter，模拟计算属性
- (double)area {
    return M_PI * _radius * _radius;
}
- (void)setArea:(double)area {
    _radius = sqrt(area / M_PI);
}
@end

代码说明：在Objective-C中，需要通过手动编写getter和setter方法来实现类似Swift计算属性的行为。

总结

Swift的计算属性是一项强大而灵活的特性，它允许开发者将数据的计算过程封装在属性访问的简洁语法背后。通过理解其与存储属性的区别、掌握其语法和高级用法、并遵循性能最佳实践，你可以有效地运用计算属性来提升代码的可读性、封装性和可维护性。记住，计算属性最适合那些代表派生数据、计算快速且无副作用的场景；对于需要参数或涉及复杂操作的场景，方法通常是更合适的选择。

最后更新: