Swift Academy · Lektion

State, Action und Reducer

Modellieren Sie Features als reine Reducer über dem State.

State, Action und Reducer ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist The Composable Architecture?

The Composable Architecture, kurz TCA, ist eine Bibliothek zum Erstellen von Swift-Apps mit einer konsistenten und testbaren Struktur. Sie basiert auf drei Bestandteilen: State beschreibt die Daten Ihres Features, Action beschreibt jedes mögliche Ereignis und ein Reducer entwickelt den State als Reaktion auf Actions weiter.

Dieser unidirektionale Datenfluss macht Features vorhersehbar und leicht testbar.

import ComposableArchitecture

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

Das @Reducer-Makro

Ein Feature wird als Typ definiert, der mit dem Makro @Reducer annotiert ist. Das Makro generiert unterstützenden Code und ermöglicht es Ihnen, State, Action und den Reducer-body gemeinsam in einer geschlossenen Einheit zu deklarieren.

Der Typ wird üblicherweise nach dem Feature benannt, zum Beispiel CounterFeature.

import ComposableArchitecture

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

State definieren

State ist normalerweise eine Struktur, die alle benötigten Daten eines Features enthält. Wenn Sie sie mit @ObservableState markieren, kann SwiftUI Änderungen gezielt beobachten und nur die betroffenen Teile neu rendern.

Halten Sie den State so klein wie möglich und berechnen Sie abgeleitete Werte, damit es eine einzige Quelle der Wahrheit gibt.

import ComposableArchitecture

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

Actions definieren

Action ist ein Enum, das jedes Ereignis auflistet, das ein Feature verarbeiten kann: Tippen des Benutzers, Antworten, Timer-Ticks und so weiter. Jeder Case benennt etwas, das passiert ist, und keinen Befehl, der den State direkt verändert.

Klare Action-Namen machen das Verhalten des Features selbsterklärend.

import ComposableArchitecture

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

    enum Action {
        case incrementTapped
        case decrementTapped
    }
}

Der Reducer-Body

Die Logik des Reducers befindet sich in einer berechneten body-Eigenschaft, die einen Wert vom Typ ReducerOf<Self> zurückgibt. Darin verwenden Sie Reduce mit einer Closure, die den veränderbaren state und die eingehende action erhält.

Sie prüfen die Action mit einem Switch und verändern den State entsprechend.

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

Effects zurückgeben

Jeder Zweig des Reducers muss einen Effect zurückgeben. Die Rückgabe von .none bedeutet, dass nach der State-Änderung keine weitere asynchrone Arbeit ausgeführt werden muss.

Wenn Sie Seiteneffekte benötigen, etwa einen Netzwerkaufruf, geben Sie einen Effect zurück, der diese Arbeit ausführt. Effects sehen Sie sich in einer späteren Lektion genauer an.

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
}

State-Mutationen werden zentral gebündelt

Eine zentrale Regel von TCA lautet: Nur der Reducer verändert den State, und zwar ausschließlich als Reaktion auf Actions. Views ändern den State niemals direkt, sondern senden Actions.

Diese zentrale Stelle für Mutationen macht den Datenfluss leicht nachvollziehbar und testbar.

import ComposableArchitecture

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

Benutzereingaben im State modellieren

Formularähnliche Features speichern bearbeitbare Felder im State und fügen Actions für Änderungen hinzu. Wenn Sie Eigenschaften mit Bindings versehen, können SwiftUI-Steuerelemente sie typsicher über Actions aktualisieren.

Dieses Feature verwaltet ein Textfeld und einen Schalter.

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

Actions mit zugehörigen Werten

Actions können mithilfe von zugehörigen Werten Daten übertragen. So modellieren Sie zurückgelieferte Ergebnisse, etwa ein geladenes Element oder einen Fehler, damit der Reducer sie im State speichern kann.

Hier enthält eine Response-Action die abgerufene Zahl.

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

Warum Equatable für den State hilfreich ist

Wenn State Equatable entspricht, kann TCA erkennen, ob sich der State tatsächlich geändert hat. Das ermöglicht präzise View-Aktualisierungen und umfassende Tests. Es ist eine kleine Voraussetzung mit großen Vorteilen.

Die meisten State-Typen übernehmen Equatable automatisch, weil ihre gespeicherten Eigenschaften bereits Equatable entsprechen.

import ComposableArchitecture

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

Der Aufbau eines vollständigen Features

Ein fertiges Feature lässt sich von oben nach unten lesen: das Makro, der beobachtbare State, das Action-Enum und der Reducer-Body. Alles, was zum Feature gehört, befindet sich in einem einzigen Typ. Das macht TCA-Features komponierbar und leicht zu überprüfen.

Dieser einheitliche Aufbau wiederholt sich in jedem Feature einer 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
            }
        }
    }
}

Kurzer Check: Die drei Bestandteile

Rufen Sie sich die Aufgaben von State, Action und Reducer in TCA ins Gedächtnis.

Zusammenfassung: State, Action und Reducer

Sie haben das Herzstück eines TCA-Features kennengelernt:

@Reducer definiert einen Feature-Typ, der alles an einer Stelle enthält.
@ObservableState an einer Struktur enthält die Daten des Features und ermöglicht eine präzise Beobachtung.
Ein Action-Enum listet jedes Ereignis auf, optional mit zugehörigen Werten.
Der Reducer-body verwendet Reduce, um den State zu verändern und einen Effect zurückzugeben. Wenn kein Seiteneffekt benötigt wird, wird .none zurückgegeben.
Nur der Reducer verändert den State, wodurch der Datenfluss vorhersehbar bleibt.

Als Nächstes verbinden Sie dieses Feature über einen Store mit SwiftUI.

import ComposableArchitecture

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

Häufig gestellte Fragen

Ist die Lektion „State, Action und Reducer“ kostenlos?

Ja — der vollständige Text von „State, Action und Reducer“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „State, Action und Reducer“?

Modellieren Sie Features als reine Reducer über dem State. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „State, Action und Reducer“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy