Swift Stored Property Usage Simplified For Beginners

Swift's stored properties are a fundamental aspect of managing data within classes and structures. Enumerations can store data indirectly using associated values.

Understanding the differences between stored and computed properties, alongside concepts like lazy stored properties, property observers, and type properties, is crucial for writing efficient and clean code.

This blog explores the nuances of stored properties, their initialization, behavior, and how they interact with computed properties to help you master property management in Swift. Let’s dive in!

What Are Stored Properties in Swift?

A stored property is a variable or constant that is part of an instance of a class, structure, or enumeration. Stored properties hold a value for as long as the instance exists in memory, determined by its scope and references. Swift allows you to define these properties with an initial value, or you can assign a default value directly in their declaration.

Example of a Simple Stored Property

Swift

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

var rect = Rectangle(width: 10.0, height: 20.0)
print("Rectangle Width: \(rect.width), Height: \(rect.height)")

In the above example, width and height are stored properties. They store constant and variable values for each instance of the Rectangle structure.

Types of Stored Properties

Stored properties can be categorized based on their behavior and initialization.

Variable Stored Properties

A variable stored property is declared using the var keyword and allows modification after initialization. For example:

Swift

Copy
1
2
3
4
5
6
7
8
9
10
11
12
class Person {
    var name: String
    var age: Int
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

var person = Person(name: "Alice", age: 30)
person.age = 31
print("Updated age: \(person.age)")

Constant Stored Properties

A constant stored property is declared using the let keyword. Once set, its value cannot be changed. Constant stored properties are especially useful when defining values that should remain immutable throughout the instance's lifecycle.

Swift

Copy
1
2
3
4
5
6
7
struct FixedPoint {
    let x: Int
    let y: Int
}

let point = FixedPoint(x: 10, y: 20)
// point.x = 30 // This will throw an error

Lazy Stored Properties

A lazy stored property is initialized only when it is first accessed, which delays memory allocation and computational overhead until required. This is especially useful for properties that rely on expensive operations or external factors.

Swift

Copy
1
2
3
4
5
6
7
8
9
class DataLoader {
    lazy var data: String = {
        // Simulate data loading
        return "Loaded Data"
    }()
}

let loader = DataLoader()
print(loader.data) // "Loaded Data"

Lazy stored properties are defined using the lazy keyword and can only be var, as they need to be mutable.

Computed Properties vs Stored Properties

While stored properties allocate memory for their values, computed properties do not. Instead, they calculate and return a value dynamically. Computed properties are defined with a getter and, optionally, a setter.

Example of Computed Properties

Swift

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct Circle {
    var radius: Double
    var diameter: Double {
        get {
            return radius * 2
        }
        set {
            radius = newValue / 2
        }
    }
}

var circle = Circle(radius: 5)
print(circle.diameter) // 10
circle.diameter = 12
print(circle.radius) // 6

The setter allows us to update the radius indirectly by assigning a new value to the diameter.

Read-Only Computed Properties

If a computed property only has a getter, it is considered a read-only computed property. These properties do not allow setting a new value.

Swift

Copy
1
2
3
4
5
6
struct Square {
    var side: Double
    var area: Double {
        return side * side
    }
}

Using Property Observers

Property observers let you monitor and respond to changes in a property's value. They are supported only by stored properties and can be implemented using willSet and didSet.

Swift

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Counter {
    var count: Int = 0 {
        willSet {
            print("Count is about to change to \(newValue)")
        }
        didSet {
            print("Count has changed from \(oldValue) to \(count)")
        }
    }
}

let counter = Counter()
counter.count = 10
counter.count = 15

In this example, the count property has observers that react whenever its value changes.

Lazy Stored Properties and Memory Optimization

One of the benefits of using a lazy stored property is optimizing memory usage. This type of property delays its initialization until it's explicitly accessed, which can help avoid unnecessary memory allocation.

Swift

Copy
1
2
3
4
5
6
class ImageProcessor {
    lazy var processedImage: String = {
        // Simulated image processing
        return "Processed Image"
    }()
}

Why Stored Properties Allocate Memory

Stored properties allocate memory because they need to retain their stored property's value. This makes them ideal for holding values that don't require dynamic recalculation, unlike computed properties.

Stored Properties and Type Properties

Stored properties can also be used in combination with type properties. Type properties, defined using the static keyword, are associated with the type itself rather than any particular instance.

Swift

Copy
1
2
3
4
struct Configuration {
    static let maxConnections = 10
    static var currentConnections = 0
}

Here, maxConnections is a static constant, meaning its value cannot be changed and is shared across all instances.

Combining Stored and Computed Properties

You can use both stored and computed properties together in the same structure or class to balance memory usage and computation efficiency.

Swift

Copy
1
2
3
4
5
6
7
struct Rectangle {
    var width: Double
    var height: Double
    var area: Double {
        return width * height
    }
}

In this example, width and height are stored properties, while area is a computed property.

Wrapping Up!

The Swift stored property is a cornerstone of data handling in Swift. By understanding the differences between stored and computed properties, lazy stored properties, and type properties, you can write more efficient and readable code. Use stored properties to store values that need persistent memory, while leveraging computed properties to calculate values on the fly.

By combining the right mix of stored and computed properties, you can strike a balance between performance and simplicity in your code.