Swift Properties

Properties are a fundamental concept in Swift programming. They allow you to associate values with a particular class, structure, or enumeration. Swift offers several types of properties, each serving a unique purpose in your code.

Stored Properties

Stored properties are the simplest form of properties in Swift. They store constant or variable values as part of an instance.

struct Person {
    let name: String
    var age: Int
}

var john = Person(name: "John", age: 30)
john.age = 31 // Modifying a stored property

Computed Properties

Computed properties don't store a value directly. Instead, they provide a getter and an optional setter to retrieve and set other properties indirectly.

struct Circle {
    var radius: Double
    var area: Double {
        get {
            return Double.pi * radius * radius
        }
    }
}

let circle = Circle(radius: 5)
print(circle.area) // Output: 78.53981633974483

Property Observers

Property observers allow you to monitor changes to a property's value. Swift provides two observers: willSet and didSet.

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("About to set totalSteps to \(newTotalSteps)")
        }
        didSet {
            if totalSteps > oldValue  {
                print("Added \(totalSteps - oldValue) steps")
            }
        }
    }
}

let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// Output:
// About to set totalSteps to 200
// Added 200 steps

Type Properties

Type properties belong to the type itself, not to instances of that type. They're useful for defining values that are universal to all instances of a particular type.

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 1
    }
}

print(SomeStructure.storedTypeProperty) // Output: Some value.
print(SomeStructure.computedTypeProperty) // Output: 1

Best Practices

• Use stored properties for values that don't require computation.
• Implement computed properties when a value needs to be calculated based on other properties.
• Utilize property observers to react to changes in a property's value.
• Employ type properties for values that are universal to all instances of a type.

Understanding and effectively using properties is crucial for writing clean, efficient Swift code. They form the backbone of many Swift features, including initialization and access control.

As you delve deeper into Swift development, you'll find properties playing a vital role in more advanced concepts like property wrappers and key paths. Mastering properties will significantly enhance your ability to create robust and maintainable Swift applications.