Swift Academy · Lezione

Modellare macchine a stati con gli enum

Rappresentare in sicurezza le transizioni di stato dell’app con gli enum di Swift.

Modellare macchine a stati con gli enum è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Introduzione

Gli enum sono ideali per modellare macchine a stati finiti. Ogni caso rappresenta uno stato; le transizioni sono funzioni che restituiscono lo stato successivo. Questo approccio impedisce di rappresentare stati illegali.

Enum di stato semplice

```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 ```

Stati con dati associati

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

Funzione di transizione

```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 } } ```

Perché usare macchine a stati basate su enum?

Vantaggi: • Switch esaustivo: il compilatore impone di gestire tutti gli stati • Le combinazioni illegali sono impossibili, ad esempio `loaded` senza dati • Lo stato è un valore: è facile da testare, copiare e registrare • L'interfaccia può analizzare lo stato con uno switch e visualizzare la vista corrispondente

Rendering dell'interfaccia dallo stato

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

Macchina a stati del lettore

```swift enum PlayerState { case stopped case playing(track: String, position: TimeInterval) case paused(track: String, position: TimeInterval) } ``` Solo `playing` e `paused` contengono una traccia; `stopped` non la contiene, rendendo il modello autoesplicativo.

Prevenire le transizioni non valide

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

Testare le macchine a stati

```swift func testLight() { var l = TrafficLight.red assert(l.next() == .green) assert(l.next().next() == .yellow) } ``` Le macchine a stati con funzioni di transizione pure sono facilmente testabili con test unitari: non servono mock.

Comporre macchine a stati

Le app di grandi dimensioni spesso hanno più macchine a stati che collaborano: ```swift struct AppState { var auth: AuthState var data: LoadState<[Article]> var ui: UIState } ``` È possibile combinarle in un'unica struct di stato principale per architetture in stile Flux/Redux.

Verifica rapida

Che cosa rende le macchine a stati basate su enum sicure a compile time?

Riepilogo

Concetti chiave: • Ogni caso rappresenta uno stato; le transizioni sono funzioni che restituiscono lo stato successivo • I valori associati contengono i dati specifici dello stato • Uno switch esaustivo garantisce dal compilatore la gestione di tutti gli stati • Le funzioni di transizione pure sono facili da testare con test unitari • È possibile combinare più macchine a stati in un'unica struct di stato principale Corso completato! Prossimo argomento: composizione dei protocolli.

Domande Frequenti

La lezione «Modellare macchine a stati con gli enum» è gratuita?

Sì — il testo completo di «Modellare macchine a stati con gli enum» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Modellare macchine a stati con gli enum»?

Rappresentare in sicurezza le transizioni di stato dell’app con gli enum di Swift. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Modellare macchine a stati con gli enum»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Swift Academy