Swift Academy · Pelajaran

State, Action, dan Reducer

Modelkan fitur sebagai reducer murni atas state.

Pelajaran 1 dari 413 langkah

State, Action, dan Reducer adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Apa Itu Arsitektur yang Dapat Disusun

Arsitektur yang Dapat Disusun, atau TCA, adalah pustaka untuk membangun aplikasi Swift dengan struktur yang konsisten dan dapat diuji. Arsitektur ini berpusat pada tiga bagian: State yang menjelaskan data fitur Anda, Action yang menjelaskan setiap peristiwa yang dapat terjadi, dan Reducer yang mengubah keadaan sebagai respons terhadap tindakan.

Alur searah ini membuat fitur mudah diprediksi dan diuji.

import ComposableArchitecture

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

Makro @Reducer

Sebuah fitur didefinisikan sebagai tipe yang diberi anotasi dengan makro @Reducer. Makro ini menghasilkan kode pendukung dan memungkinkan Anda mendeklarasikan State, Action, dan properti body milik Reducer bersama-sama dalam satu unit yang utuh.

Sesuai konvensi, tipe tersebut diberi nama berdasarkan fiturnya, seperti CounterFeature.

import ComposableArchitecture

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

Mendefinisikan State

State biasanya berupa struct yang menyimpan semua data yang dibutuhkan fitur. Menandainya dengan @ObservableState memungkinkan SwiftUI mengamati perubahan secara tepat dan menggambar ulang hanya bagian yang terpengaruh.

Jaga agar State tetap minimal dan hitung nilai turunan, sehingga hanya ada satu sumber kebenaran.

import ComposableArchitecture

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

Mendefinisikan Action

Action adalah enumerasi yang mencantumkan setiap peristiwa yang dapat ditangani fitur: pengguna mengetuk sesuatu, respons diterima, pewaktu berdetak, dan seterusnya. Setiap kasus menyebutkan sesuatu yang telah terjadi, bukan perintah untuk langsung mengubah keadaan.

Nama tindakan yang jelas membuat perilaku fitur dapat dipahami tanpa dokumentasi tambahan.

import ComposableArchitecture

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

    enum Action {
        case incrementTapped
        case decrementTapped
    }
}

Body Reducer

Logika Reducer berada di properti terhitung body yang mengembalikan some ReducerOf<Self>. Di dalamnya, Anda menggunakan Reduce dengan fungsi penutup yang menerima state yang dapat diubah dan action yang masuk.

Anda memeriksa setiap nilai tindakan lalu mengubah keadaan sesuai kebutuhan.

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

Mengembalikan Efek

Setiap cabang Reducer harus mengembalikan Effect. Mengembalikan .none berarti tidak ada pekerjaan asinkron lanjutan yang perlu dilakukan setelah perubahan keadaan.

Jika memerlukan efek samping, seperti panggilan jaringan, Anda mengembalikan efek yang menjalankan pekerjaan tersebut. Anda akan mempelajari efek lebih lanjut dalam pelajaran berikutnya.

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
}

Perubahan State Dipusatkan

Aturan inti TCA adalah bahwa hanya Reducer yang mengubah keadaan, dan perubahan itu hanya dilakukan sebagai respons terhadap tindakan. Tampilan tidak pernah mengubah keadaan secara langsung; tampilan mengirimkan tindakan.

Tempat terpusat tunggal untuk perubahan ini membuat alur data mudah diikuti dan diuji.

import ComposableArchitecture

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

Memodelkan Masukan Pengguna dalam State

Fitur seperti formulir menyimpan bidang yang dapat diedit di dalam State dan menambahkan tindakan untuk setiap perubahan. Menandai properti dengan pengikatan memungkinkan kontrol SwiftUI memperbaruinya melalui tindakan dengan keamanan tipe.

Di sini, sebuah fitur melacak bidang teks dan sebuah sakelar.

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 dengan Nilai Terkait

Action dapat membawa data menggunakan nilai terkait. Dengan cara inilah Anda memodelkan hasil yang diterima, seperti item yang telah dimuat atau galat, sehingga Reducer dapat menyimpannya dalam State.

Di sini, sebuah tindakan respons membawa angka yang diambil.

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

Mengapa State yang Dapat Dibandingkan Membantu

Membuat State memenuhi Equatable memungkinkan TCA mendeteksi apakah keadaan benar-benar berubah. Hal ini mendukung pembaruan tampilan yang tepat dan pengujian menyeluruh. Ini adalah persyaratan kecil dengan manfaat besar.

Sebagian besar tipe State dapat menggunakan Equatable tanpa pekerjaan tambahan karena properti yang disimpannya sudah memenuhi protokol tersebut.

import ComposableArchitecture

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

Bentuk Fitur Lengkap

Fitur yang selesai dibaca dari atas ke bawah: makro, State yang dapat diamati, enumerasi Action, dan body Reducer. Semua hal tentang fitur berada dalam satu tipe, sehingga fitur TCA dapat disusun dan ditinjau dengan mudah.

Bentuk yang konsisten ini berulang di setiap fitur dalam aplikasi.

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

Pemeriksaan Singkat: Tiga Bagian

Ingat kembali peran State, Action, dan Reducer dalam TCA.

Jawab di pelajaran interaktif

Ringkasan: State, Action, dan Reducer

Anda telah mempelajari inti sebuah fitur TCA:

@Reducer mendefinisikan tipe fitur yang memuat semuanya di satu tempat.
@ObservableState pada sebuah struct menyimpan data fitur dan memungkinkan pengamatan yang tepat.
Enumerasi Action mencantumkan setiap peristiwa, dengan nilai terkait jika diperlukan.
body Reducer menggunakan Reduce untuk mengubah keadaan dan mengembalikan Effect, dengan .none jika tidak diperlukan efek samping.
Hanya Reducer yang mengubah keadaan, sehingga alur data tetap mudah diprediksi.

Selanjutnya, Anda akan menghubungkan fitur ini ke SwiftUI dengan sebuah Store.

import ComposableArchitecture

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

Gratis untuk memulai

Belajar Swift dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 122
Pelajaran: 409

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “State, Action, dan Reducer” gratis?

Ya — teks lengkap “State, Action, dan Reducer” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “State, Action, dan Reducer”?

Modelkan fitur sebagai reducer murni atas state. Kamu berlatih Swift Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “State, Action, dan Reducer” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Swift Academy