Name property wrappers that declare reference…

@State
@Binding
@EnvironmentObject
@ObservedObject
@StateObject

These property wrappers do not declare semantics of references in the traditional sense (like pointers in C++), but they allow working with data presented in SwiftUI as "references" or shared mutable sources of truth. They manage the lifecycle of data and ensure automatic UI updates when they change.

For example:

@State: Manages local state within a View. Changing an @State variable causes the View to redraw.

struct MyView: View {
    @State private var isActive = false

    var body: some View {
        Button("Toggle") {
            isActive.toggle()
        }
    }
}

@Binding: Allows creating a two-way binding to an @State or other data source. Changes in one place are reflected in the other.

struct ParentView: View {
    @State private var value = 0

    var body: some View {
        VStack {
            Text("Value: \(value)")
            ChildView(count: $value) // `$` creates a Binding
        }
    }
}

struct ChildView: View {
    @Binding var count: Int // Receives a Binding

    var body: some View {
        Button("Increment") {
            count += 1 // Changing the Binding
        }
    }
}

@ObservedObject: Used for reference types (classes) that conform to ObservableObject. Changes to @Published properties in this object trigger view updates.

import Combine

class Counter: ObservableObject {
    @Published var count = 0
}

struct ContentView: View {
    @ObservedObject var counter = Counter() // Reference type

    var body: some View {
        VStack {
            Text("Count: \(counter.count)")
            Button("Increment") {
                counter.count += 1
            }
        }
    }
}

@StateObject: Similar to @ObservedObject, but intended for creating an instance of ObservableObject within a View and managing its lifecycle. The View becomes the owner of the object.

import Combine

class TimerData: ObservableObject {
    @Published var timerSeconds = 0

    init() {
        Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in
            self.timerSeconds += 1
        }
    }
}

struct TimerView: View {
    @StateObject var timerData = TimerData() // Creating and owning the object

    var body: some View {
        Text("Time: \(timerData.timerSeconds)")
    }
}

@EnvironmentObject: Allows passing instances of ObservableObject through the View hierarchy without passing them explicitly through each View's initializer.

import Combine

class UserSettings: ObservableObject {
    @Published var loggedIn = false
}

struct AppView: View {
    @StateObject var settings = UserSettings()

    var body: some View {
        ContentView()
            .environmentObject(settings) // Inject into environment
    }
}

struct ContentView: View {
    @EnvironmentObject var settings: UserSettings // Access from environment

    var body: some View {
        Toggle("Logged In", isOn: $settings.loggedIn)
    }
}

Name property wrappers that declare reference semantics.