Swift Academy · Aula

Estado, Ação e Redutor

Modele funcionalidades como redutores puros sobre o estado.

Estado, Ação e Redutor é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 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.

O que é a Composable Architecture?

A Composable Architecture, ou TCA, é uma biblioteca para criar aplicativos em Swift com uma estrutura consistente e testável. Ela se baseia em três partes: State, que descreve os dados da sua funcionalidade; Action, que descreve cada evento que pode acontecer; e um Reducer, que atualiza o estado em resposta às ações.

Esse fluxo unidirecional torna as funcionalidades previsíveis e fáceis de testar.

import ComposableArchitecture

// State holds data, Action describes events,
// a Reducer turns (state, action) into the next state.

A macro @Reducer

Uma funcionalidade é definida como um tipo anotado com a macro @Reducer. A macro gera o código de suporte e permite declarar State, Action e o redutor body juntos em uma única unidade coesa.

Por convenção, o tipo recebe o nome da funcionalidade, como CounterFeature.

import ComposableArchitecture

@Reducer
struct CounterFeature {
    // State, Action, and body go here
}

Definindo State

State geralmente é uma estrutura que contém todos os dados necessários para uma funcionalidade. Marcá-la com @ObservableState permite que o SwiftUI observe alterações com precisão e renderize novamente apenas o que foi afetado.

Mantenha o estado mínimo e calcule os valores derivados, para que exista uma única fonte de verdade.

import ComposableArchitecture

@Reducer
struct CounterFeature {
    @ObservableState
    struct State: Equatable {
        var count = 0
    }
}

Definindo ações

Action é uma enumeração que lista cada evento que a funcionalidade pode tratar: toques do usuário, respostas, eventos do temporizador e assim por diante. Cada caso nomeia algo que aconteceu, não um comando para alterar o estado diretamente.

Nomes claros para as ações tornam o comportamento da funcionalidade autoexplicativo.

import ComposableArchitecture

@Reducer
struct CounterFeature {
    @ObservableState
    struct State: Equatable { var count = 0 }

    enum Action {
        case incrementTapped
        case decrementTapped
    }
}

O corpo do Reducer

A lógica do redutor fica em uma propriedade computada body que retorna algum ReducerOf<Self>. Dentro dela, você usa Reduce com um fechamento que recebe o state mutável e a action recebida.

Você percorre os casos da ação e altera o estado de acordo com eles.

import ComposableArchitecture

@Reducer
struct CounterFeature {
    @ObservableState
    struct State: Equatable { var count = 0 }
    enum Action { case incrementTapped, decrementTapped }

    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .incrementTapped:
                state.count += 1
                return .none
            case .decrementTapped:
                state.count -= 1
                return .none
            }
        }
    }
}

Retornando efeitos

Cada ramo do redutor deve retornar um Effect. Retornar .none significa que não há mais trabalho assíncrono a realizar após a alteração de estado.

Quando você precisar de efeitos colaterais, como uma chamada de rede, retorne um efeito que execute esse trabalho. Você explorará os efeitos em uma lição posterior.

import ComposableArchitecture

// Every reducer branch returns an Effect.
// No side effect needed? Return .none.
// Need async work? Return an effect describing it.
Reduce { state, action in
    state.count += 1
    return .none
}

As mutações de State são centralizadas

Uma regra fundamental do TCA é que apenas o redutor altera o estado, e somente em resposta a ações. As interfaces nunca alteram o estado diretamente; elas enviam ações.

Esse único local central para as alterações é o que torna o fluxo de dados fácil de acompanhar e testar.

import ComposableArchitecture

// Views send actions; the reducer mutates state.
// store.send(.incrementTapped)  ->  state.count += 1
// No direct state mutation outside the reducer.

Modelando a entrada do usuário em State

Funcionalidades semelhantes a formulários mantêm os campos editáveis em State e adicionam ações para as alterações. Marcar propriedades com vínculos permite que os controles do SwiftUI as atualizem por meio de ações de maneira segura quanto ao tipo.

Aqui, uma funcionalidade acompanha um campo de texto e um controle de alternância.

import ComposableArchitecture

@Reducer
struct FormFeature {
    @ObservableState
    struct State: Equatable {
        var name = ""
        var isSubscribed = false
    }
    enum Action: BindableAction {
        case binding(BindingAction<State>)
    }
    var body: some ReducerOf<Self> {
        BindingReducer()
    }
}

Ações com valores associados

Ações podem transportar dados usando valores associados. É assim que você modela resultados recebidos, como um item carregado ou um erro, para que o redutor possa armazená-los no estado.

Aqui, uma ação de resposta transporta o número obtido.

import ComposableArchitecture

@Reducer
struct NumberFeature {
    @ObservableState
    struct State: Equatable { var value = 0 }
    enum Action {
        case reloadTapped
        case responseReceived(Int)
    }
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .reloadTapped:
                return .none
            case let .responseReceived(value):
                state.value = value
                return .none
            }
        }
    }
}

Por que um State comparável ajuda

Conformar State a Equatable permite que o TCA detecte se o estado realmente mudou, o que possibilita atualizações precisas da interface e testes exaustivos. É um pequeno requisito com grandes benefícios.

A maioria dos tipos de estado adota Equatable automaticamente, pois suas propriedades armazenadas já são comparáveis.

import ComposableArchitecture

@ObservableState
struct State: Equatable {
    var count = 0
    var title = ""
}
// Equatable enables change detection and test assertions.

A estrutura de uma funcionalidade completa

Uma funcionalidade concluída é lida de cima para baixo: a macro, o estado observável, a enumeração de ações e o corpo do redutor. Tudo sobre a funcionalidade fica em um único tipo, o que torna as funcionalidades do TCA componíveis e fáceis de revisar.

Essa estrutura consistente se repete em todas as funcionalidades de um aplicativo.

import ComposableArchitecture

@Reducer
struct CounterFeature {
    @ObservableState
    struct State: Equatable { var count = 0 }
    enum Action { case incrementTapped, decrementTapped }
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .incrementTapped: state.count += 1; return .none
            case .decrementTapped: state.count -= 1; return .none
            }
        }
    }
}

Verificação rápida: as três partes

Relembre as funções de State, Action e do Reducer no TCA.

Recapitulação: State, Action e Reducer

Você aprendeu o núcleo de uma funcionalidade do TCA:

@Reducer define um tipo de funcionalidade que contém tudo em um só lugar.
@ObservableState em uma estrutura armazena os dados da funcionalidade e permite uma observação precisa.
Uma enumeração de Action lista cada evento, opcionalmente com valores associados.
O body do redutor usa Reduce para alterar o estado e retornar um Effect, usando .none quando nenhum efeito colateral é necessário.
Apenas o redutor altera o estado, mantendo o fluxo de dados previsível.

A seguir, você conectará essa funcionalidade ao SwiftUI com um armazenamento.

import ComposableArchitecture

// Recap: @Reducer + State + Action + body(Reduce)
// One type, one source of truth, predictable updates.

Perguntas Frequentes

A aula “Estado, Ação e Redutor” é grátis?

Sim — o texto completo de “Estado, Ação e Redutor” é 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 “Estado, Ação e Redutor”?

Modele funcionalidades como redutores puros sobre o estado. 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 1 de 4.

Quanto tempo leva a aula “Estado, Ação e Redutor”?

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

← Voltar para Swift Academy