Swift Academy · Lekcja

Publikowanie i obserwowanie powiadomień

Wysyłanie i odbieranie zdarzeń w całej aplikacji.

Publikowanie i obserwowanie powiadomień to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 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.

NotificationCenter

NotificationCenter to mechanizm rozgłaszania: jedna część aplikacji wysyła powiadomienie, a dowolna liczba obserwatorów na nie reaguje, bez konieczności wzajemnej znajomości nadawcy i odbiorców.

Centrum domyślne

Większość kodu korzysta z NotificationCenter.default — współdzielonego centrum, które przekazuje powiadomienia w obrębie procesu.

import Foundation

let center = NotificationCenter.default
print("Using the default notification center")

Definiowanie nazwy powiadomienia

Powiadomienia są identyfikowane za pomocą Notification.Name. Zdefiniowanie stałej zapobiega literówkom i centralizuje nazwę.

import Foundation

extension Notification.Name {
    static let dataUpdated = Notification.Name("dataUpdated")
}
print("Defined a notification name")

Wysyłanie powiadomienia

post(name:object:) rozsyła powiadomienie. object to zazwyczaj nadawca albo nil.

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("ping")
center.post(name: name, object: nil)
print("Posted a notification")

Dodawanie obserwatora (domknięcie)

Oparte na bloku addObserver(forName:object:queue:using:) uruchamia domknięcie za każdym razem, gdy zostanie wysłane powiadomienie, i zwraca token.

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("ping")
let token = center.addObserver(forName: name, object: nil, queue: .main) { _ in
    print("Observer fired")
}
center.post(name: name, object: nil)
_ = token

Obserwatory oparte na selektorze

Klasyczne API używa celu i #selector. Metoda otrzymuje argument typu Notification.

import Foundation

class Watcher: NSObject {
    func start() {
        NotificationCenter.default.addObserver(
            self, selector: #selector(handle(_:)),
            name: Notification.Name("ping"), object: nil)
    }
    @objc func handle(_ n: Notification) { print("Handled") }
}
Watcher().start()

Odbieranie powiadomienia

Domknięcie lub metoda obserwatora otrzymuje wartość typu Notification, zawierającą jego nazwę, obiekt i userInfo.

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("event")
_ = center.addObserver(forName: name, object: nil, queue: nil) { note in
    print("Got: \(note.name.rawValue)")
}
center.post(name: name, object: nil)

Rozsyłanie jeden-do-wielu

Wiele obserwatorów może nasłuchiwać tej samej nazwy. Pojedyncze wywołanie post powiadamia je wszystkie.

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("refresh")
_ = center.addObserver(forName: name, object: nil, queue: nil) { _ in print("A") }
_ = center.addObserver(forName: name, object: nil, queue: nil) { _ in print("B") }
center.post(name: name, object: nil)

Filtrowanie według obiektu

Przekazanie niezerowego object do addObserver sprawia, że obserwator reaguje tylko na komunikaty wysłane przez tego nadawcę.

import Foundation

let center = NotificationCenter.default
let sender = NSObject()
let name = Notification.Name("scoped")
_ = center.addObserver(forName: name, object: sender, queue: nil) { _ in
    print("Only from sender")
}
center.post(name: name, object: sender)

Powiadomienia systemowe

System wysyła wiele wbudowanych powiadomień, takich jak zdarzenia klawiatury lub cyklu życia aplikacji, które obserwuje się w ten sam sposób.

import Foundation

// e.g. UIApplication.didEnterBackgroundNotification on iOS
let custom = Notification.Name("appReady")
_ = NotificationCenter.default.addObserver(forName: custom, object: nil, queue: nil) { _ in
    print("App ready")
}

Kiedy tego używać

NotificationCenter sprawdza się w przypadku globalnych zdarzeń jeden-do-wielu, gdy nadawca i odbiorcy powinni pozostać niezależni. W przypadku ścisłych relacji jeden-do-jednego często bardziej przejrzysty jest delegat.

import Foundation

// Broadcast a global event many parts of the app care about.
let name = Notification.Name("userLoggedOut")
NotificationCenter.default.post(name: name, object: nil)
print("Broadcast logout")

Szybkie sprawdzenie

Co robi NotificationCenter.default.post(name:object:)?

Podsumowanie

NotificationCenter.default oddziela nadawców od odbiorców: definiuje się Notification.Name, wysyła je za pomocą post, a następnie używa addObserver z domknięciem lub selektorem, aby reagować na powiadomienia. Obsługuje rozsyłanie jeden-do-wielu i filtrowanie według obiektu. Następnie: przekazywanie danych w userInfo.

Często zadawane pytania

Czy lekcja „Publikowanie i obserwowanie powiadomień” jest bezpłatna?

Tak — pełny tekst „Publikowanie i obserwowanie powiadomień” 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 „Publikowanie i obserwowanie powiadomień”?

Wysyłanie i odbieranie zdarzeń w całej aplikacji. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Publikowanie i obserwowanie powiadomień”?

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

← Powrót do Swift Academy