Swift Academy · Lekcja

Modelowanie automatów stanów za pomocą wyliczeń

Bezpieczne reprezentowanie przejść stanów aplikacji za pomocą wyliczeń Swift.

Modelowanie automatów stanów za pomocą wyliczeń to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Typy wyliczeniowe doskonale nadają się do modelowania skończonych maszyn stanów. Każdy przypadek reprezentuje stan, a przejścia są funkcjami zwracającymi następny stan. Takie podejście sprawia, że nieprawidłowych stanów nie da się reprezentować.

Prosty typ wyliczeniowy stanu

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

Stany z danymi powiązanymi

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

Funkcja przejścia

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

Dlaczego maszyny stanów oparte na typach wyliczeniowych?

Zalety: • Wyczerpująca instrukcja `switch` — kompilator wymusza obsługę wszystkich stanów • Nieprawidłowe kombinacje są niemożliwe, np. `loaded` bez danych • Stan jest wartością — można go łatwo testować, kopiować i logować • Interfejs użytkownika może reagować na stan i odpowiednio renderować widok

Renderowanie interfejsu użytkownika na podstawie stanu

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

Maszyna stanów odtwarzacza

```swift enum PlayerState { case stopped case playing(track: String, position: TimeInterval) case paused(track: String, position: TimeInterval) } ``` Tylko przypadki `playing` i `paused` przechowują utwór — `stopped` go nie przechowuje, dzięki czemu model sam objaśnia swoją strukturę.

Zapobieganie nieprawidłowym przejściom

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

Testowanie maszyn stanów

```swift func testLight() { var l = TrafficLight.red assert(l.next() == .green) assert(l.next().next() == .yellow) } ``` Maszyny stanów z czystymi funkcjami przejścia można bezpośrednio testować jednostkowo — nie są potrzebne żadne obiekty mock.

Łączenie maszyn stanów

Duże aplikacje często korzystają jednocześnie z wielu maszyn stanów: ```swift struct AppState { var auth: AuthState var data: LoadState<[Article]> var ui: UIState } ``` W architekturach w stylu Flux/Redux można połączyć je w jednej strukturze stanu głównego.

Szybkie sprawdzenie

Co sprawia, że maszyny stanów oparte na typach wyliczeniowych są bezpieczne na etapie kompilacji?

Podsumowanie

Najważniejsze informacje: • Każdy przypadek to stan, a przejścia to funkcje zwracające następny stan • Wartości powiązane przechowują dane właściwe dla danego stanu • Wyczerpująca instrukcja `switch` wymusza przez kompilator obsługę wszystkich stanów • Czyste funkcje przejścia można łatwo testować jednostkowo • Wiele maszyn stanów można połączyć w jednej strukturze stanu głównego Kurs ukończony! Dalej: kompozycja protokołów.

Często zadawane pytania

Czy lekcja „Modelowanie automatów stanów za pomocą wyliczeń” jest bezpłatna?

Tak — pełny tekst „Modelowanie automatów stanów za pomocą wyliczeń” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Modelowanie automatów stanów za pomocą wyliczeń”?

Bezpieczne reprezentowanie przejść stanów aplikacji za pomocą wyliczeń Swift. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Modelowanie automatów stanów za pomocą wyliczeń”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Wartości surowe i CaseIterable
Wartości powiązane dla bogatych danych
Wyliczenia indirect i struktury rekurencyjne
Modelowanie automatów stanów za pomocą wyliczeń

← Powrót do Swift Academy