Swift Academy · Lezione

Stato, azione e reducer

Modelli le funzionalità come reducer puri sullo stato.

Stato, azione e reducer è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Che cos’è la Composable Architecture

La Composable Architecture, o TCA, è una libreria per creare app Swift con una struttura coerente e verificabile. Si basa su tre elementi: State, che descrive i dati della feature; Action, che descrive ogni evento possibile; e un Reducer, che aggiorna lo stato in risposta alle azioni.

Questo flusso unidirezionale rende le feature prevedibili e facili da testare.

import ComposableArchitecture

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

La macro @Reducer

Una feature viene definita come un tipo annotato con la macro @Reducer. La macro genera il codice di supporto e consente di dichiarare State, Action e body del reducer insieme, in un’unica unità coerente.

Per convenzione, il tipo prende il nome dalla feature, ad esempio CounterFeature.

import ComposableArchitecture

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

Definizione dello State

State è generalmente una struct che contiene tutti i dati necessari a una feature. Contrassegnandola con @ObservableState, permette a SwiftUI di osservare con precisione le modifiche e di eseguire nuovamente il rendering solo di ciò che è interessato.

Mantenga lo stato essenziale e calcoli i valori derivati, così da avere un’unica fonte di verità.

import ComposableArchitecture

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

Definizione delle Action

Action è un enum che elenca ogni evento che la feature può gestire: tocchi dell’utente, risposte, impulsi del timer e così via. Ogni case indica qualcosa che è accaduto, non un comando per modificare direttamente lo stato.

Nomi chiari per le action rendono il comportamento della feature autoesplicativo.

import ComposableArchitecture

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

    enum Action {
        case incrementTapped
        case decrementTapped
    }
}

Il body del Reducer

La logica del reducer risiede in una proprietà calcolata body che restituisce un valore di tipo ReducerOf<Self>. Al suo interno si utilizza Reduce con una closure che riceve lo state modificabile e la action in ingresso.

Si esegue uno switch sull’action e si modifica lo stato di conseguenza.

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

Restituzione degli Effect

Ogni ramo del reducer deve restituire un Effect. Restituire .none significa che, dopo la modifica dello stato, non è necessario svolgere altro lavoro asincrono.

Quando sono necessari effetti collaterali, ad esempio una chiamata di rete, si restituisce un effect che esegue tale lavoro. Gli effetti verranno approfonditi in una lezione successiva.

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
}

Le mutazioni dello stato sono centralizzate

Una regola fondamentale di TCA è che solo il reducer modifica lo stato, e solo in risposta alle action. Le view non modificano mai direttamente lo stato: inviano action.

Questo unico punto centrale per le mutazioni rende il flusso dei dati facile da seguire e da testare.

import ComposableArchitecture

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

Rappresentazione dell’input dell’utente nello State

Le feature simili a form mantengono i campi modificabili nello State e aggiungono action per le modifiche. Contrassegnare le proprietà per i binding consente ai controlli SwiftUI di aggiornarle tramite action in modo type-safe.

In questo caso, una feature tiene traccia di un campo di testo e di un toggle.

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

Action con valori associati

Le action possono trasportare dati tramite valori associati. Questo consente di rappresentare i risultati ricevuti, come un elemento caricato o un errore, affinché il reducer possa salvarli nello stato.

In questo caso, un’action di risposta trasporta il numero recuperato.

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

Perché uno State Equatable è utile

Rendere State conforme a Equatable consente a TCA di rilevare se lo stato è effettivamente cambiato, abilitando aggiornamenti precisi delle view e test esaustivi. È un requisito minimo dai grandi vantaggi.

La maggior parte dei tipi di stato adotta Equatable automaticamente, perché le proprietà memorizzate lo sono già.

import ComposableArchitecture

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

La struttura di una feature completa

Una feature completa si legge dall’alto verso il basso: la macro, lo stato osservabile, l’enum delle action e il body del reducer. Ogni aspetto della feature risiede in un unico tipo, rendendo le feature TCA componibili e facili da esaminare.

Questa struttura coerente si ripete in ogni feature dell’app.

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 rapida: i tre elementi

Ricordi il ruolo di State, Action e Reducer in TCA.

Riepilogo: State, Action e Reducer

Ha appreso gli elementi fondamentali di una feature TCA:

@Reducer definisce un tipo di feature che contiene tutto in un unico punto.
@ObservableState applicato a una struct contiene i dati della feature e abilita un’osservazione precisa.
Un enum Action elenca ogni evento, facoltativamente con valori associati.
Il body del reducer utilizza Reduce per modificare lo stato e restituire un Effect, con .none quando non è necessario alcun effetto collaterale.
Solo il reducer modifica lo stato, mantenendo prevedibile il flusso dei dati.

Ora collegherà questa feature a SwiftUI con uno Store.

import ComposableArchitecture

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

Domande Frequenti

La lezione «Stato, azione e reducer» è gratuita?

Sì — il testo completo di «Stato, azione e reducer» è 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 «Stato, azione e reducer»?

Modelli le funzionalità come reducer puri sullo stato. 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 1 di 4.

Quanto tempo richiede la lezione «Stato, azione e reducer»?

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