Swift Academy · Lekcja

@Published i obserwacja w Combine

Jak działa @Published wewnętrznie i emituje zmiany za pośrednictwem publisherów Combine.

Lekcja 3 z 412 kroki

@Published i obserwacja w Combine to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

`@Published` to wrapper właściwości z frameworka Combine, który za każdym razem, gdy właściwość się zmienia, emituje nową wartość przez publisher.

Podstawy @Published

```swift import Combine class Counter: ObservableObject { @Published var count = 0 } let c = Counter() let cancel = c.$count.sink { print("Count: \($0)") } c.count += 1 // "Count: 1" c.count += 1 // "Count: 2" ```

Protokół ObservableObject

```swift class ViewModel: ObservableObject { @Published var title = "Initial" @Published var items: [String] = [] } ``` Każda klasa zgodna z `ObservableObject` otrzymuje bezpłatnie publisher `objectWillChange`.

Publisher objectWillChange

```swift class VM: ObservableObject { @Published var name = "" } let vm = VM() let cancel = vm.objectWillChange.sink { print("Will change") } vm.name = "Alice" // "Will change" printed before assignment ```

@Published z SwiftUI @StateObject

```swift @StateObject var vm = ViewModel() // In View body: Text(vm.title) // Re-renders when vm.title changes ``` `@StateObject` jest właścicielem ViewModelu, a `@ObservedObject` obserwuje obiekt zarządzany z zewnątrz.

Łączenie publisherów z @Published

```swift class Search: ObservableObject { @Published var query = "" @Published var results: [String] = [] private var cancellables = Set() init() { $query .debounce(for: 0.3, scheduler: RunLoop.main) .sink { [weak self] q in self?.search(q) } .store(in: &cancellables) } } ```

@Published emituje przed przypisaniem

Publisher `objectWillChange` emituje *przed* zapisaniem nowej wartości: ```swift vm.objectWillChange.sink { _ in print("will change") } $count.sink { n in print("is \(n)") } // Order: "will change" then "is 1" ```

Przechowywanie subskrypcji

```swift var cancellables = Set() c.$count .sink { print("\($0)") } .store(in: &cancellables) // cancellables keeps subscription alive ```

Ograniczenia @Published

• Tylko w klasach (typach referencyjnych) • Nie można używać ze stałymi `let` • Nie działa na granicach aktorów bez jawnej izolacji • Wartość jest emitowana *przed* zakończeniem przypisania (semantyka willSet)

Makro obserwacji (Swift 5.9+)

Swift 5.9 wprowadza `@Observable` jako prostszą alternatywę: ```swift @Observable class Counter { var count = 0 } // No Combine import needed; SwiftUI auto-subscribes ```

Szybkie sprawdzenie

Kiedy `@Published` emituje swoją wartość — przed czy po ustawieniu właściwości?

Odpowiedz w interaktywnej lekcji

Podsumowanie

Najważniejsze wnioski: • `@Published var x` udostępnia `$x` jako `Publisher` • `ObservableObject` otrzymuje bezpłatny publisher `objectWillChange` • Emisja następuje przed zapisaniem nowej wartości (willSet) • Przechowuj subskrypcje w `Set` • Swift 5.9: `@Observable` zastępuje większość zastosowań `@Published` Dalej: komponowanie wrapperów właściwości.

Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 122
Lekcje: 409

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „@Published i obserwacja w Combine” jest bezpłatna?

Tak — pełny tekst „@Published i obserwacja w Combine” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „@Published i obserwacja w Combine”?

Jak działa @Published wewnętrznie i emituje zmiany za pośrednictwem publisherów Combine. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „@Published i obserwacja w Combine”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Tworzenie niestandardowego wrappera właściwości
Wartości projekcji za pomocą $binding
@Published i obserwacja w Combine
Kompozycja wielu wrapperów właściwości

← Powrót do Swift Academy