Mastering Swift: Unleashing the Power of Computed Properties

What Are Computed Properties in Swift?

In Swift, properties come in two main flavors: stored properties and computed properties. Stored properties, as their name suggests, store a constant or variable value as part of an instance of a particular class or structure. You're likely very familiar with these.

Computed properties, on the other hand, do not store a value directly. Instead, they provide a getter and an optional setter to retrieve and set other properties and values indirectly. They offer a concise way to express values that are derived from other properties. Think of them as dynamic, on-demand calculations that always return the most up-to-date value based on the current state of your object.

This approach helps to keep your data models clean, prevents redundant data storage, and ensures data consistency. Computed properties are a fundamental feature of Swift's powerful type system and are widely used in a variety of programming scenarios, from simple data transformations to complex UI logic.

Defining Computed Properties: The Getter and Setter

Every computed property must provide a getter. The getter is responsible for calculating and returning the property's value. You can define a read-only computed property by providing only a getter. This is common when the value is purely a derivation of other stored properties and doesn't make sense to set directly.

For computed properties that can be both read and written, you'll provide both a getter and a setter. The setter allows you to indirectly modify other stored properties when the computed property is assigned a new value. Inside the setter, the new value is implicitly available as newValue. You can also provide a custom name for the newValue parameter if you prefer.

Let's look at a concrete example using a Rectangle struct. This example is compatible with iOS 7.0+, macOS 10.9+, watchOS 2.0+, and tvOS 9.0+.

struct Rectangle {
    var width: Double
    var height: Double

    // Read-only computed property for area
    var area: Double {
        return width * height
    }

    // Read-write computed property for perimeter
    var perimeter: Double {
        get {
            return 2 * (width + height)
        }
        set(newPerimeter) { // 'newValue' is implicitly available if you omit 'newPerimeter'
            // Let's assume we want to maintain the aspect ratio if we update the perimeter
            let oldPerimeter = 2 * (width + height)
            if oldPerimeter > 0 {
                let ratio = newPerimeter / oldPerimeter
                width *= ratio
                height *= ratio
            } else {
                // Handle cases where oldPerimeter is zero (e.g., width or height is zero)
                // For simplicity, let's just make it a square with side = newPerimeter / 4
                width = newPerimeter / 4
                height = newPerimeter / 4
            }
        }
    }
}

var myRectangle = Rectangle(width: 10.0, height: 5.0)
print("Initial Rectangle: Width=\(myRectangle.width), Height=\(myRectangle.height)") // Output: Initial Rectangle: Width=10.0, Height=5.0
print("Area: \(myRectangle.area)")       // Output: Area: 50.0
print("Perimeter: \(myRectangle.perimeter)") // Output: Perimeter: 30.0

myRectangle.width = 12.0 // Changing a stored property
print("New Area after width change: \(myRectangle.area)") // Output: New Area after width change: 60.0 (Recalculated)

myRectangle.perimeter = 40.0 // Setting the computed property
print("Rectangle after perimeter set: Width=\(myRectangle.width), Height=\(myRectangle.height)")
// Expected Output: Rectangle after perimeter set: Width=16.0, Height=8.0 (original ratio 2:1 maintained, perims 30 -> 40)
print("New Perimeter: \(myRectangle.perimeter)") // Output: New Perimeter: 40.0

Shorthand Getter Declaration

When a computed property's getter consists solely of a single expression, Swift allows you to omit the return keyword. This makes your code even more concise, especially for simple calculations. This shorthand syntax is very common and enhances readability for common scenarios.

Consider our Rectangle example. The area computed property can be written more succinctly:

This shorthand is particularly useful when working with SwiftUI views, where many properties are essentially computed values derived from the view's state. It's a hallmark of modern Swift coding style and helps reduce boilerplate.

struct Circle {
    var radius: Double

    // Read-only computed property with shorthand getter
    var diameter: Double {
        2 * radius
    }

    // Read-write computed property with shorthand getter
    var circumference: Double {
        get { 2 * Double.pi * radius }
        set { radius = newValue / (2 * Double.pi) }
    }
}

var myCircle = Circle(radius: 5.0)
print("Circle Diameter: \(myCircle.diameter)") // Output: Circle Diameter: 10.0
myCircle.circumference = 31.4159
print("Circle Radius after circumference change: \(myCircle.radius)") // Output: Circle Radius after circumference change: 4.99999... (approx 5.0)

When to Use Computed Properties

Computed properties are invaluable in situations where you need a value that:

1. Is derived from other properties: Like the area or perimeter of a Rectangle. You don't need to store it; you can calculate it on the fly.
2. Needs to be recalculated frequently: Every time one of its dependencies changes, the computed property automatically reflects the new state.
3. Simplifies your API: Instead of exposing a calculateArea() method, you can provide a cleaner, more Swifty area property.
4. Avoids redundant storage: Why store fullName if you already have firstName and lastName? This reduces memory usage and eliminates potential inconsistencies.
5. Performs data transformation: You might have an Int property storing raw data, but a String computed property that formats it nicely for display.

Example: Formatting a Date Imagine you have a Date object, but you often need to display it in a user-friendly string format. A computed property can encapsulate this formatting logic.

This example is compatible with iOS 7.0+, macOS 10.9+, watchOS 2.0+, and tvOS 9.0+.

import Foundation

struct Event {
    var date: Date
    var title: String

    // A computed property to get a user-friendly date string
    var formattedDate: String {
        let formatter = DateFormatter()
        formatter.dateStyle = .medium
        formatter.timeStyle = .short
        return formatter.string(from: date)
    }

    // A computed property to check if the event is in the past
    var isPastEvent: Bool {
        date < Date()
    }
}

let now = Date()
let pastDate = now.addingTimeInterval(-3600 * 24)
let futureDate = now.addingTimeInterval(3600 * 24)

let pastEvent = Event(date: pastDate, title: "Yesterday's Meeting")
let upcomingEvent = Event(date: futureDate, title: "Tomorrow's Keynote")

print("\(pastEvent.title): \(pastEvent.formattedDate) (Past: \(pastEvent.isPastEvent))")
// Output example: Yesterday's Meeting: Oct 26, 2023 at 10:00 AM (Past: true)
print("\(upcomingEvent.title): \(upcomingEvent.formattedDate) (Past: \(upcomingEvent.isPastEvent))")
// Output example: Tomorrow's Keynote: Oct 28, 2023 at 10:00 AM (Past: false)

Computed Properties vs. Methods

A common question is when to use a computed property versus a method. The general guideline is:

• Computed Property: Use when the value is conceptually a characteristic of the instance, can be accessed as a property, and doesn't involve heavy computation or side effects. It reads like accessing a value.
• Method: Use when the action performs a task, modifies the object's state (has side effects), takes parameters, or involves significant computation that might be expensive or should be explicitly called.

For instance, area is a characteristic of a Rectangle, so .area is appropriate. If you had a method calculateAreaAndDisplayIt(), that implies an action with side effects (displaying) and perhaps more complex logic, making a method more suitable.

Strive for clarity and intuitiveness in your API design. If it feels like an attribute, make it a computed property. If it feels like an action, make it a method.

Class Computed Properties (Type Properties)

Just like stored properties, computed properties can also be defined as type properties by using the static keyword for structs and enums, or static/class for classes. These properties are associated with the type itself, not with any particular instance of that type.

For classes, class var means the property can be overridden by subclasses, while static var implies it cannot be overridden (it behaves like static in structs/enums). For computed type properties, you only define a getter.

This feature is available since Swift 1.0 (iOS 7.0+, macOS 10.9+).

Example: Global Configuration Status

struct AppConfiguration {
    static var serverURL: String = "https://api.myapp.com"
    static var defaultLanguage: String = "en"

    // Computed type property to indicate if the app is in debug mode
    static var isDebugMode: Bool {
        #if DEBUG
        return true
        #else
        return false
        #endif
    }

    // Example of a computed type property in a class that can be overridden
    class var appVersion: String {
        Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "Unknown"
    }
}

print("Is Debug Mode: \(AppConfiguration.isDebugMode)")
print("App Version: \(AppConfiguration.appVersion)")