Noem de property wrapper die de semantiek van de…

@State
@Binding
@EnvironmentObject
@ObservedObject
@StateObject

Deze property wrappers declareren niet de referentiële semantiek in de traditionele zin (zoals een pointer in C++), maar stellen je in staat om te werken met gegevens die in SwiftUI worden gepresenteerd als "referenties" of gedeelde mutable bronnen van waarheid. Ze beheren de levenscyclus van de gegevens en zorgen voor automatische UI-updates bij wijzigingen.

Bijvoorbeeld:

@State: Beheert de lokale toestand binnen een View. Het wijzigen van de @State-variabele leidt tot een hertekening van de View.

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

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

@Binding: Maakt het mogelijk om een bidirectionele binding te creëren aan @State of een andere gegevensbron. Wijzigingen op één plek worden weerspiegeld op de andere.

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

    var body: some View {
        VStack {
            Text("Value: \(value)")
            ChildView(count: $value) // $ creëert een Binding
        }
    }
}

struct ChildView: View {
    @Binding var count: Int // Ontvangt een Binding

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

@ObservedObject: Wordt gebruikt voor referentietypen (klassen) die het protocol ObservableObject implementeren. Het wijzigen van @Published-eigenschappen in dit object veroorzaakt een update van de View.

import Combine

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

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

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

@StateObject: Vergelijkbaar met @ObservedObject, maar bedoeld om een instantie van ObservableObject binnen een View te maken en de levenscyclus te beheren. De View wordt eigenaar van het 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() // Object maken en bezitten

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

@EnvironmentObject: Maakt het mogelijk om ObservableObject-instanties door te geven in de View-hiërarchie, zonder ze via de initializers van elke View door te geven.

import Combine

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

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

    var body: some View {
        ContentView()
            .environmentObject(settings) // Invoegen in de omgeving
    }
}

struct ContentView: View {
    @EnvironmentObject var settings: UserSettings // Toegang uit de omgeving

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

Noem de property wrapper die de semantiek van de verwijzing declareert.