Wymień property wrappery, które deklarują semantykę…

@State
@Binding
@EnvironmentObject
@ObservedObject
@StateObject

Te wrappery właściwości nie deklarują semantyki odniesienia w tradycyjnym rozumieniu (jak wskaźnik w C++), ale pozwalają pracować z danymi prezentowanymi w SwiftUI jako "odniesienia" lub wspólne mutable źródła prawdy. Zarządzają cyklem życia danych i zapewniają automatyczną aktualizację UI przy ich zmianie.

Na przykład:

@State: Zarządza stanem lokalnym wewnątrz widoku. Zmiana zmiennej @State powoduje ponowne renderowanie widoku.

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

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

@Binding: Pozwala na utworzenie dwukierunkowego powiązania z @State lub innym źródłem danych. Zmiany w jednym miejscu odzwierciedlają się w drugim.

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

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

struct ChildView: View {
    @Binding var count: Int // Otrzymujemy Binding

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

@ObservedObject: Używany dla typów referencyjnych (klas), które implementują protokół ObservableObject. Zmiana właściwości oznaczonych @Published w tym obiekcie wywołuje aktualizację widoku.

import Combine

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

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

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

@StateObject: Podobny do @ObservedObject, ale przeznaczony do tworzenia instancji ObservableObject wewnątrz widoku i zarządzania jej cyklem życia. Widok staje się właścicielem obiektu.

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() // Tworzenie i posiadanie obiektu

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

@EnvironmentObject: Umożliwia przekazywanie instancji ObservableObject w hierarchii widoków, bez przekazywania ich przez inicjalizatory każdego widoku.

import Combine

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

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

    var body: some View {
        ContentView()
            .environmentObject(settings) // Wstrzyknięcie do środowiska
    }
}

struct ContentView: View {
    @EnvironmentObject var settings: UserSettings // Dostęp z środowiska

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

Wymień property wrappery, które deklarują semantykę odwołania.