> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Swift Computed Property
A computed property is a property that does not allocate memory to store a value directly. Instead, it provides a custom getter and an optional setter to retrieve and mutate other properties and state indirectly. Because their values are evaluated dynamically at runtime, computed properties must always be declared as variables (`var`) and require an explicit type annotation.
## Read-Write Computed Properties
A read-write computed property defines both a `get` block to calculate and return the value, and a `set` block to modify underlying state. The getter must include a `return` statement (or implicitly return a single expression) that matches the property's declared type.
```swift theme={"dark"}
var explicitSetterProperty: Int {
get {
let calculatedValue = 42
return calculatedValue
}
set(customName) {
print("Updating state with \(customName)")
}
}
```
If you do not explicitly define a parameter name for the setter, Swift automatically provides an implicit parameter named `newValue`.
```swift theme={"dark"}
var implicitSetterProperty: Int {
get {
return 42
}
set {
print("Updating state with \(newValue)")
}
}
```
## Read-Only Computed Properties
If a computed property only defines a getter and omits the setter, it becomes a read-only computed property. Attempting to assign a value to a read-only computed property results in a compile-time error.
For read-only properties, Swift allows a shorthand syntax where the `get` keyword and its associated braces are omitted entirely.
```swift theme={"dark"}
var readOnlyProperty: String {
return "Computed Value"
}
```
## Mutating and Nonmutating Modifiers
When defining computed properties on value types (structures and enumerations), the getter is nonmutating and the setter is mutating by default. You can alter this behavior using the `mutating` and `nonmutating` modifiers:
* **`mutating get`**: Required if reading the property modifies the instance's own state.
* **`nonmutating set`**: Used when the setter modifies external state (such as a reference type or global state) without modifying the value type instance itself.
```swift theme={"dark"}
struct AccessTracker {
private var accessCount: Int = 0
var trackedValue: Int {
mutating get {
accessCount += 1
return accessCount
}
}
}
struct ExternalStateModifier {
var proxyValue: Int {
get {
return 0
}
nonmutating set {
print("Modifying external state with \(newValue) without mutating self")
}
}
}
```
## Asynchronous and Throwing Computed Properties
Modern Swift allows read-only computed properties to participate in concurrency and error handling. A getter can be marked with `async`, `throws`, or both (`async throws`).
```swift theme={"dark"}
var asyncProperty: Int {
get async {
// Suspend and await an asynchronous operation
return 100
}
}
enum PropertyError: Error { case invalidState }
var throwingProperty: String {
get throws {
throw PropertyError.invalidState
}
}
```
## Technical Constraints and Characteristics
* **No Backing Storage:** Computed properties do not have an underlying instance variable. They act purely as an interface to compute or mutate other data.
* **Immutability Restriction:** You cannot declare a computed property with the `let` keyword. Even if the property is read-only, its value is not fixed at initialization, violating the contract of a constant.
* **Type Inference:** Swift cannot infer the type of a computed property from its getter's return statement. The type annotation (e.g., `: Int`, `: String`) is strictly required.
* **Supported Types:** Computed properties can be declared within classes, structures, and enumerations. They are also heavily utilized in extensions to add computed state to existing types.
* **Property Observers:** You cannot attach property observers (`willSet` or `didSet`) to a newly defined computed property, as observation logic can simply be placed inside the `set` block. However, you *can* attach property observers to an *inherited* computed property by overriding it in a subclass.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
