Swift Read-Only Property

A read-only property in Swift is a property that exposes a value for retrieval but prohibits modification after its initial state is established. Swift implements read-only properties through three distinct mechanisms: read-only computed properties, constant stored properties, and access control modifiers.

Read-Only Computed Properties

A read-only computed property calculates and returns a value dynamically. It provides a get block (getter) but omits the set block (setter).

Because the value of a computed property is not fixed and can change depending on the underlying state it evaluates, it must always be declared with the var keyword, never with let.

Syntax: You can define a read-only computed property using an explicit get block, or you can omit the get keyword entirely for a more concise shorthand declaration.

struct ComputedPropertySyntax {
    var underlyingState: Int
    
    // Explicit read-only computed property
    var explicitReadOnly: Int {
        get {
            return underlyingState * 2
        }
    }
    
    // Shorthand read-only computed property (implicit getter)
    var implicitReadOnly: Int {
        return underlyingState * 2
    }
}

Constant Stored Properties

A constant stored property allocates memory to hold a value that is assigned exactly once. Once initialized, the compiler enforces immutability, making the property strictly read-only for the lifetime of the instance.

Syntax: Constant stored properties are declared using the let keyword.

struct StoredPropertySyntax {
    // Constant stored property
    let immutableValue: String
    
    init(value: String) {
        // Assignment occurs exactly once during initialization
        self.immutableValue = value
    }
}

Asymmetric Access Control (private(set))

Swift allows the mutation of a stored property to be restricted to the defining scope while exposing the getter to external scopes. This creates a property that behaves as read-only to external consumers but remains a mutable stored property internally.

Syntax: This is achieved by applying the private(set), fileprivate(set), or internal(set) modifier before the var declaration.

struct AccessControlSyntax {
    // Getter is internal (default), setter is private
    private(set) var externallyReadOnly: Int = 0
    
    mutating func internalMutation() {
        // Mutation is permitted within the defining scope
        externallyReadOnly += 1
    }
}

Tired of Poor Swift Skills? Fix That With Deep Grasping!

Learn More