Swift Academy · Leçon

Modéliser des machines à états avec des énumérations

Représenter en toute sécurité les transitions d’état d’une application avec les énumérations Swift.

Modéliser des machines à états avec des énumérations est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 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

Les énumérations sont idéales pour modéliser des machines à états finis. Chaque cas représente un état ; les transitions sont des fonctions qui renvoient l'état suivant. Cette approche rend les états invalides impossibles à représenter.

Énumération d'état simple

```swift enum TrafficLight { case red, yellow, green func next() -> TrafficLight { switch self { case .red: return .green case .green: return .yellow case .yellow: return .red } } } var light = TrafficLight.red light = light.next() // .green ```

États avec données associées

```swift enum LoadState { case idle case loading(progress: Double) case loaded(T) case failed(Error) } var state: LoadState<[String]> = .idle state = .loading(progress: 0.5) state = .loaded(["alice","bob"]) ```

Fonction de transition

```swift func transition(_ state: LoadState, event: AppEvent) -> LoadState { switch (state, event) { case (.idle, .startFetch): return .loading(progress: 0) case (.loading, .progress(let p)): return .loading(progress: p) case (.loading, .success(let d)): return .loaded(d) case (.loading, .error(let e)): return .failed(e) default: return state } } ```

Pourquoi des machines à états fondées sur des énumérations ?

Avantages : • `switch` exhaustif — le compilateur vous oblige à gérer tous les états • Les combinaisons invalides sont impossibles (par exemple, `loaded` sans données) • L'état est une valeur — facile à tester, copier et journaliser • L'interface utilisateur peut examiner l'état avec `switch` et effectuer le rendu correspondant

Rendu de l'interface utilisateur à partir de l'état

```swift func render(_ state: LoadState<[User]>) { switch state { case .idle: showEmptyView() case .loading(let p): showProgress(p) case .loaded(let users): showList(users) case .failed(let err): showError(err) } } ```

Machine à états du lecteur

```swift enum PlayerState { case stopped case playing(track: String, position: TimeInterval) case paused(track: String, position: TimeInterval) } ``` Seuls `playing` et `paused` contiennent une piste ; `stopped` n'en contient pas, ce qui rend le modèle explicite.

Prévenir les transitions invalides

```swift extension PlayerState { mutating func play(track: String) { guard case .stopped = self else { return } self = .playing(track: track, position: 0) } mutating func pause() { if case .playing(let t, let p) = self { self = .paused(track: t, position: p) } } } ```

Tester les machines à états

```swift func testLight() { var l = TrafficLight.red assert(l.next() == .green) assert(l.next().next() == .yellow) } ``` Les machines à états dotées de fonctions de transition pures sont faciles à tester unitairement : aucun simulacre n'est nécessaire.

Composer des machines à états

Les grandes applications comportent souvent plusieurs machines à états qui fonctionnent ensemble : ```swift struct AppState { var auth: AuthState var data: LoadState<[Article]> var ui: UIState } ``` Composez-les dans une structure d'état racine unique pour les architectures de style Flux/Redux.

Vérification rapide

Qu'est-ce qui rend les machines à états fondées sur des énumérations sûres à la compilation ?

Récapitulatif

Points essentiels : • Chaque cas représente un état ; les transitions sont des fonctions qui renvoient l'état suivant • Les valeurs associées contiennent les données propres à chaque état • Un `switch` exhaustif garantit la gestion de tous les états par le compilateur • Les fonctions de transition pures sont faciles à tester unitairement • Composez plusieurs machines à états dans une structure d'état racine Cours terminé ! Ensuite : la composition de protocoles.

Questions Fréquemment Posées

La leçon « Modéliser des machines à états avec des énumérations » est-elle gratuite ?

Oui — le texte complet de « Modéliser des machines à états avec des énumérations » 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 « Modéliser des machines à états avec des énumérations » ?

Représenter en toute sécurité les transitions d’état d’une application avec les énumérations Swift. 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 4 sur 4.

Combien de temps prend la leçon « Modéliser des machines à états avec des énumérations » ?

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

Valeurs brutes et CaseIterable
Valeurs associées pour des données riches
Énumérations indirectes et structures récursives
Modéliser des machines à états avec des énumérations

← Retour à Swift Academy