0Pricing
Swift Academy · Leçon

Publier et observer des notifications

Envoyez et recevez des événements à l’échelle de l’application.

Publier et observer des notifications est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

NotificationCenter

NotificationCenter est un mécanisme de diffusion : une partie de l’app publie une notification et un nombre quelconque d’observateurs réagissent, sans que l’émetteur et les récepteurs se connaissent.

Le centre par défaut

La plupart du code utilise NotificationCenter.default, un centre partagé qui achemine les notifications dans tout le processus.

import Foundation

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

Définir un nom de notification

Les notifications sont identifiées par un Notification.Name. Définir une constante évite les fautes de frappe et centralise le nom.

import Foundation

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

Publier une notification

post(name:object:) diffuse la notification. L'object est généralement le sender ou nil.

import Foundation

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

Ajouter un observateur (fermeture)

La méthode addObserver(forName:object:queue:using:) fondée sur un bloc exécute une fermeture chaque fois que la notification est déclenchée et renvoie un 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

Observateurs fondés sur un sélecteur

L'API classique utilise une cible et #selector. La méthode reçoit un argument 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()

Recevoir la notification

La fermeture ou la méthode de l'observateur reçoit une valeur Notification contenant son nom, son objet et son 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)

Diffusion vers plusieurs destinataires

De nombreux observateurs peuvent écouter le même nom. Un seul post les notifie tous.

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)

Filtrer par objet

Le fait de transmettre un object non nul à addObserver applique un filtre : l'observateur ne se déclenche que pour les publications provenant de ce sender.

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)

Notifications système

Le système publie de nombreuses notifications intégrées, par exemple pour le clavier ou les événements du cycle de vie de l'application ; vous les observez de la même manière.

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")
}

Quand l'utiliser

NotificationCenter convient aux événements globaux destinés à plusieurs destinataires, lorsque le sender et les destinataires doivent rester indépendants. Pour des liens étroits entre deux objets, un delegate est souvent plus clair.

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")

Vérification rapide

Que fait NotificationCenter.default.post(name:object:) ?

Récapitulatif

NotificationCenter.default dissocie les émetteurs et les destinataires : vous définissez un Notification.Name, vous le publiez avec post, puis vous utilisez addObserver avec une fermeture ou un sélecteur pour réagir. Cette approche prend en charge la diffusion vers plusieurs destinataires et le filtrage par objet. Ensuite : transporter des données dans userInfo.

Questions Fréquemment Posées

La leçon « Publier et observer des notifications » est-elle gratuite ?

Oui — le texte complet de « Publier et observer des notifications » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Publier et observer des notifications » ?

Envoyez et recevez des événements à l’échelle de l’application. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Publier et observer des notifications » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Publier et observer des notifications
  2. Charges utiles userInfo des notifications
  3. Supprimer les observateurs en toute sécurité
  4. Alternatives au modèle observateur
← Retour à Swift Academy