Swift Academy · leksjon

Modellering av tilstandsmaskiner med enum-er

Representer tilstandsoverganger i apper på en trygg måte med Swift-enum-er.

Leksjon 4 av 412 trinn

Modellering av tilstandsmaskiner med enum-er er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Swift Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Velkommen

Enum-er egner seg godt til å modellere endelige tilstandsmaskiner. Hvert tilfelle er en tilstand, og overganger er funksjoner som returnerer den neste tilstanden. Denne tilnærmingen gjør det umulig å representere ugyldige tilstander.

Enkel tilstandsenum

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

Tilstander med tilknyttede data

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

Overgangsfunksjon

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

Hvorfor bruke enum-baserte tilstandsmaskiner?

Fordeler: • Uttømmende switch – kompilatoren tvinger deg til å håndtere alle tilstander • Ugyldige kombinasjoner er umulige (for eksempel `loaded` uten data) • Tilstanden er en verdi – den er enkel å teste, kopiere og logge • Grensesnittet kan gjøre en switch på tilstanden og vise riktig innhold

Gjengi grensesnittet fra tilstanden

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

Tilstandsmaskin for en spiller

```swift enum PlayerState { case stopped case playing(track: String, position: TimeInterval) case paused(track: String, position: TimeInterval) } ``` Bare `playing` og `paused` inneholder et spor – `stopped` gjør ikke det, noe som gjør modellen selvforklarende.

Forhindre ugyldige overganger

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

Teste tilstandsmaskiner

```swift func testLight() { var l = TrafficLight.red assert(l.next() == .green) assert(l.next().next() == .yellow) } ``` Tilstandsmaskiner med rene overgangsfunksjoner kan enkelt testes med enhetstester – du trenger ingen mocker.

Kombinere tilstandsmaskiner

Store apper har ofte flere tilstandsmaskiner som samarbeider: ```swift struct AppState { var auth: AuthState var data: LoadState<[Article]> var ui: UIState } ``` Kombiner dem i én rotstruktur for tilstanden i Flux-/Redux-lignende arkitekturer.

Kort sjekk

Hva gjør enum-baserte tilstandsmaskiner typesikre ved kompilering?

Besvar den i den interaktive leksjonen

Oppsummering

Viktigste punkter: • Hvert tilfelle = en tilstand; overganger = funksjoner som returnerer neste tilstand • Tilknyttede verdier inneholder data som er spesifikke for tilstanden • Uttømmende switch = kompilatoren håndhever håndteringen av alle tilstander • Rene overgangsfunksjoner er enkle å teste med enhetstester • Kombiner flere tilstandsmaskiner i én rotstruktur for tilstanden Kurset er fullført! Neste: protokollsammensetting.

Gratis å komme i gang

Lær deg Swift med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 122
Leksjoner: 409

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Modellering av tilstandsmaskiner med enum-er» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «Modellering av tilstandsmaskiner med enum-er», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Modellering av tilstandsmaskiner med enum-er»?

Representer tilstandsoverganger i apper på en trygg måte med Swift-enum-er. Du øver på Swift Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Swift Academy?

Ingen tidligere erfaring er nødvendig. Swift Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Modellering av tilstandsmaskiner med enum-er»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Swift Academy-leksjonen?

Ja. Alle Swift Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Råverdier og CaseIterable
Tilknyttede verdier for innholdsrike data
Indirekte enum-er og rekursive strukturer
Modellering av tilstandsmaskiner med enum-er

← Tilbake til Swift Academy