Swift Academy · Leçon

@Published et observation dans Combine

Comprendre comment @Published fonctionne en interne pour émettre des changements via les éditeurs Combine.

Leçon 3 sur 412 étapes

@Published et observation dans Combine est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Bienvenue

`@Published` est une enveloppe de propriété du framework Combine qui émet une nouvelle valeur via un éditeur chaque fois que la propriété change.

Notions de base sur @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" ```

Protocole ObservableObject

```swift class ViewModel: ObservableObject { @Published var title = "Initial" @Published var items: [String] = [] } ``` Toute classe conforme à `ObservableObject` bénéficie gratuitement d'un éditeur `objectWillChange`.

Éditeur 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 avec SwiftUI @StateObject

```swift @StateObject var vm = ViewModel() // In View body: Text(vm.title) // Re-renders when vm.title changes ``` `@StateObject` possède le ViewModel ; `@ObservedObject` observe un ViewModel possédé à l'extérieur.

Enchaîner les éditeurs issus de @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 émet avant l'affectation

`objectWillChange` est déclenché *avant* que la nouvelle valeur soit stockée : ```swift vm.objectWillChange.sink { _ in print("will change") } $count.sink { n in print("is \(n)") } // Order: "will change" then "is 1" ```

Stocker les abonnements

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

Limites de @Published

• Uniquement sur les classes (types référence) • Impossible à utiliser sur des constantes `let` • Ne fonctionne pas entre les frontières d'acteurs sans isolation explicite • La valeur est publiée *avant* la fin de l'affectation (sémantique de willSet)

Macro d'observation (Swift 5.9+)

Swift 5.9 introduit `@Observable` comme solution de remplacement plus simple : ```swift @Observable class Counter { var count = 0 } // No Combine import needed; SwiftUI auto-subscribes ```

Vérification rapide

Quand `@Published` émet-il sa valeur — avant ou après l'affectation de la propriété ?

Réponds-y dans la leçon interactive

Récapitulatif

Points essentiels : • `@Published var x` expose `$x` comme un `Publisher` • `ObservableObject` bénéficie gratuitement d'un éditeur `objectWillChange` • Émet avant que la nouvelle valeur soit stockée (willSet) • Stockez les abonnements dans `Set` • Swift 5.9 : `@Observable` remplace la plupart des usages de `@Published` Ensuite : composer des enveloppes de propriétés.

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « @Published et observation dans Combine » est-elle gratuite ?

Oui — le texte complet de « @Published et observation dans Combine » 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 « @Published et observation dans Combine » ?

Comprendre comment @Published fonctionne en interne pour émettre des changements via les éditeurs Combine. 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 3 sur 4.

Combien de temps prend la leçon « @Published et observation dans Combine » ?

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

← Retour à Swift Academy