Swift Academy · Aula

Modelagem de máquinas de estados com enums

Represente transições de estado do aplicativo com segurança usando enums do Swift.

Aula 4 de 412 etapas

Modelagem de máquinas de estados com enums é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Boas-vindas

As enumerações são ideais para modelar máquinas de estados finitos. Cada caso é um estado; as transições são funções que retornam o próximo estado. Essa abordagem torna estados inválidos irrepresentáveis.

Enumeração de estado simples

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

Estados com dados associados

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

Função de transição

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

Por que máquinas de estados com enumerações?

Benefícios: • `switch` exaustivo — o compilador força o tratamento de todos os estados • Combinações inválidas são impossíveis (por exemplo, `loaded` sem dados) • O estado é um valor — fácil de testar, copiar e registrar • A interface pode usar `switch` no estado e renderizá-lo adequadamente

Renderização da interface a partir do estado

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

Máquina de estados do reprodutor

```swift enum PlayerState { case stopped case playing(track: String, position: TimeInterval) case paused(track: String, position: TimeInterval) } ``` Somente `playing` e `paused` carregam uma faixa — `stopped` não carrega, o que torna o modelo autoexplicativo.

Impedindo transições inválidas

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

Testando máquinas de estados

```swift func testLight() { var l = TrafficLight.red assert(l.next() == .green) assert(l.next().next() == .yellow) } ``` Máquinas de estados com funções de transição puras são testáveis por testes unitários de forma trivial — não são necessários objetos simulados.

Compondo máquinas de estados

Aplicativos grandes geralmente têm várias máquinas de estados trabalhando em conjunto: ```swift struct AppState { var auth: AuthState var data: LoadState<[Article]> var ui: UIState } ``` Combine-as em uma única estrutura de estado raiz para arquiteturas no estilo Flux/Redux.

Verificação rápida

O que torna as máquinas de estados baseadas em enumerações seguras em tempo de compilação?

Responda na aula interativa

Recapitulação

Principais conclusões: • Cada caso = um estado; transições = funções que retornam o próximo estado • Valores associados carregam dados específicos do estado • `switch` exaustivo = tratamento de estados imposto pelo compilador • Funções de transição puras são fáceis de testar com testes unitários • Combine várias máquinas de estados em uma estrutura de estado raiz Curso concluído! Próximo: composição de protocolos.

Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 122
Aulas: 409

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Modelagem de máquinas de estados com enums” é grátis?

Sim — o texto completo de “Modelagem de máquinas de estados com enums” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Modelagem de máquinas de estados com enums”?

Represente transições de estado do aplicativo com segurança usando enums do Swift. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Modelagem de máquinas de estados com enums”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Valores brutos e CaseIterable
Valores associados para dados mais completos
Enums indiretos e estruturas recursivas
Modelagem de máquinas de estados com enums

← Voltar para Swift Academy