What’s Swift Computed Property? A Simple Explanation

When working with Swift, you often come across computed and stored properties. Understanding how these properties work is crucial to becoming a proficient Swift developer. Swift's computed property feature allows developers to create a property whose value is calculated dynamically, rather than stored directly in memory like a stored property. This distinction is key for developing efficient, flexible code in the Swift programming language.

In this blog, we’ll dive deep into computed properties, how they differ from stored properties, and how you can use them effectively in Swift. By the end, you'll clearly understand Swift computed property, how to write one, and where it fits in your development workflow.

What is a Computed Property?

In simple terms, a computed property doesn’t store a value. Instead, it calculates a value whenever it is accessed. A computed property derives its value based on other properties or values within a class or structure. This makes computed properties especially useful when you want a property that updates its value dynamically based on other property changes.

Syntax of Computed Properties

A computed property in Swift typically consists of a getter, and optionally, a setter if the property is mutable. Here’s how a basic computed property looks:

Copy
1
2
3
4
5
6
7
8
9
10
11
struct Rectangle {
    var width: Double
    var height: Double

    var area: Double {
        // Computed property
        get {
            return width * height
        }
    }
}

In this example, the area is a computed property. It does not store a value directly but calculates it based on the width and height of the rectangle whenever it's accessed.

Stored Properties vs Computed Properties

The main difference between a stored property and a computed property is that a stored property directly holds data in memory, while a computed property calculates its value dynamically. A stored property can have a default value or a user-defined value that is saved and retained. For example:

Copy
1
2
3
struct Circle {
    var radius: Double = 5.0  // Stored property
}

Here, radius is a stored property with a default value of 5.0.

While stored properties hold the value directly, computed properties calculate their values indirectly based on other properties. For instance, in the Rectangle example, area is not stored but computed dynamically.

Read-Only Computed Properties

In Swift, a computed property can be made read-only by providing just a getter without a setter. These read-only computed properties are useful when you want to expose a dynamically calculated value but prevent modification.

Here’s an example of a read-only computed property:

Copy
1
2
3
4
5
6
7
8
9
struct Rectangle {
    var width: Double
    var height: Double

    // Read-only computed property
    var perimeter: Double {
        return 2 * (width + height)
    }
}

In this case, perimeter is a read-only computed property since it only has a getter. You cannot set a new value for it directly.

Computed Properties with Setters

You can also create a computed property with a setter. This allows you to set a new value, and the setter can manipulate other properties or trigger some internal logic. Here’s an example where the setter updates multiple properties indirectly:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
struct Square {
    var sideLength: Double = 0.0

    var area: Double {
        get {
            return sideLength * sideLength
        }
        set(newArea) {
            sideLength = sqrt(newArea)
        }
    }
}

In this case, setting the area (a computed property) indirectly updates the sideLength. This example illustrates how computed properties not only retrieve values but can also modify other properties and values.

Property Observers and Computed Properties

It’s important to note that property observers such as willSet and didSet are only available for stored properties, not computed ones. That said, you can still indirectly observe values in a computed property using custom setters.

Why Use Computed Properties?

Computed properties are a powerful feature of Swift that let you keep your data in sync without manually updating multiple properties. By calculating values indirectly, you ensure consistency between properties.

Here are a few common use cases where computed properties shine:

1. Dynamic Calculations: When you need a property that changes based on other properties, such as calculating dimensions, areas, or speeds.

2. Simplified Code: Using computed properties avoids unnecessary stored values, reducing code complexity and potential bugs.

3. Efficient Data Management: Computed properties are especially useful when you have data that are derived from other values but does not need to be stored directly.

Advanced Computed Properties Example

Let’s take a look at a more complex example that showcases both a getter and setter in a computed property:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct File {
    var filename: String
    var extensionType: String

    // Computed property combining two stored properties
    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])
            }
        }
    }
}

In this case, fullFilename is a computed property that derives its value from two stored properties: filename and extensionType. This computed property returns the full filename when accessed, and optionally a setter allows updating both the filename and extensionType.

Benefits of Computed Properties in Swift

• Flexibility: Computed properties offer flexibility by letting you calculate values on the fly.

• Efficiency: Since computed properties calculate values dynamically, they prevent redundant storage of data.

• Code Maintenance: Computed properties centralize logic and calculations, making code easier to maintain.

• Real-time Updates: Since a computed property is recalculated every time it’s accessed, the value always reflects the latest state of related properties.

The Bottom Line

In this article, we explored the concept of a Swift computed property, which calculates its value dynamically rather than storing it directly, unlike stored properties. We covered how computed properties can have a getter and optionally a setter, making them useful for deriving values based on other properties.

Additionally, we highlighted the distinction between read-only computed properties and those with setters. By mastering both stored and computed properties, you can write more efficient, maintainable Swift code. Understanding the versatility of a Swift computed property is key to optimizing your development workflow.