PricingLoginStart free
Swift Academy · Pelajaran

Kesan dan Kebergantungan

Kendalikan kesan sampingan dan suntik kebergantungan.

Pelajaran 3 daripada 413 langkah

Kesan dan Kebergantungan ialah pelajaran Swift Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Swift Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Mengapa Kesan Sampingan Wujud

Reducer mesti kekal tulen: diberikan keadaan dan tindakan, Reducer hanya mengubah keadaan. Namun, aplikasi sebenar memerlukan kesan sampingan seperti permintaan rangkaian dan pemasa. TCA memodelkan perkara ini sebagai kesan sampingan yang dikembalikan oleh Reducer, supaya pengubahan kekal tulen manakala kerja tak segerak berjalan secara berasingan.

Pemisahan inilah yang menjadikan ciri boleh diuji.

import ComposableArchitecture

// Reducer stays pure; side effects are values it returns.
// Returning .none means no further work.

Mengembalikan .none

Apabila sesuatu tindakan hanya mengubah keadaan dan tidak memerlukan kerja susulan, Reducer mengembalikan .none. Ini ialah kesan yang paling biasa dan menandakan bahawa tiada kerja tak segerak perlu dilakukan.

Anda telah melihatnya sebelum ini; inilah nilai asas yang digunakan oleh setiap cabang apabila tiada pilihan lain.

import ComposableArchitecture

Reduce { state, action in
    switch action {
    case .incrementTapped:
        state.count += 1
        return .none
    }
}

Effect.run untuk Kerja Tak Segerak

Untuk melakukan kerja tak segerak, Anda mengembalikan .run. Penutupannya menerima pemegang send yang digunakan untuk menghantar hasil kembali ke dalam sistem sebagai tindakan baharu.

Di sini, tindakan fetch memuatkan data dan menghantar tindakan respons apabila selesai.

import ComposableArchitecture

Reduce { state, action in
    switch action {
    case .reloadTapped:
        return .run { send in
            let value = try await loadNumber()
            await send(.responseReceived(value))
        }
    case let .responseReceived(value):
        state.count = value
        return .none
    }
}

Menghantar Semula Hasil sebagai Action

Sesuatu kesan tidak boleh mengubah keadaan secara langsung; sebaliknya, kesan menghantar tindakan melalui send. Reducer kemudiannya mengendalikan tindakan tersebut dan mengemas kini keadaan. Gelung ini memastikan setiap pengubahan berlaku dalam Reducer.

Jadi, respons rangkaian menjadi tindakan respons yang disimpan oleh Reducer.

import ComposableArchitecture

.run { send in
    let result = try await fetch()
    await send(.dataLoaded(result))
}
// .dataLoaded is then handled by the reducer to set state.

Mengendalikan Ralat dalam Kesan Sampingan

Kerja tak segerak boleh melemparkan ralat. Anda boleh menangkap ralat dalam kesan tersebut dan menghantar tindakan kegagalan, supaya Reducer beralih kepada keadaan ralat dengan kemas.

Penutupan catch pilihan pada .run menerima ralat yang dilemparkan.

import ComposableArchitecture

.run { send in
    let value = try await loadNumber()
    await send(.responseReceived(value))
} catch: { error, send in
    await send(.loadFailed)
}

Mengapa Kebergantungan Penting

Jika Reducer memanggil klien rangkaian atau membaca tarikh secara langsung, Reducer menjadi sukar diuji dan dikawal. TCA menyelesaikan masalah ini dengan kebergantungan: perkhidmatan yang boleh disuntik dan diakses oleh Reducer melalui @Dependency.

Dalam ujian, Anda menggantikannya dengan objek tiruan yang memberikan hasil boleh dijangka.

import ComposableArchitecture

// Instead of calling APIClient.shared directly,
// inject it as a dependency so tests can replace it.

Pembungkus Sifat @Dependency

Dalam Reducer, Anda mengisytiharkan kebergantungan dengan @Dependency, lalu menamakannya menggunakan laluan kuncinya dalam nilai kebergantungan. Pustaka menyediakan kebergantungan terbina dalam seperti jam dan penjana UUID.

Di sini, Reducer mendapatkan jam berterusan.

import ComposableArchitecture

@Reducer
struct TimerFeature {
    @ObservableState
    struct State: Equatable { var seconds = 0 }
    enum Action { case start, tick }

    @Dependency(\.continuousClock) var clock

    var body: some ReducerOf<Self> {
        Reduce { state, action in .none }
    }
}

Menggunakan Kebergantungan dalam Kesan Sampingan

Selepas diisytiharkan, Anda menggunakan kebergantungan tersebut di dalam .run. Oleh sebab jam disuntik, ujian boleh membekalkan jam ujian yang memajukan masa apabila diminta.

Di sini, pemasa berdetik setiap saat menggunakan jam yang disuntik.

import ComposableArchitecture

var body: some ReducerOf<Self> {
    Reduce { state, action in
        switch action {
        case .start:
            return .run { send in
                for await _ in self.clock.timer(interval: .seconds(1)) {
                    await send(.tick)
                }
            }
        case .tick:
            state.seconds += 1
            return .none
        }
    }
}

Menentukan Kebergantungan Sendiri

Anda mendaftarkan kebergantungan tersuai dengan mematuhi DependencyKey dan menyediakan liveValue. Kemudian, Anda menambah sifat terhitung pada DependencyValues supaya kebergantungan itu mendapat laluan kunci.

Di sini, klien API menjadi kebergantungan utama.

import ComposableArchitecture

struct NumberClient {
    var fetch: () async throws -> Int
}

extension NumberClient: DependencyKey {
    static let liveValue = NumberClient {
        try await loadNumber()
    }
}

extension DependencyValues {
    var numberClient: NumberClient {
        get { self[NumberClient.self] }
        set { self[NumberClient.self] = newValue }
    }
}

Menyuntik Kebergantungan Tersuai

Dengan laluan kunci yang tersedia, Reducer mengisytiharkan klien menggunakan @Dependency(\.numberClient) dan memanggilnya di dalam kesan. Persekitaran produksi menggunakan nilai langsung; ujian mengatasinya.

Di sini, tindakan muat semula mendapatkan data melalui klien yang disuntik.

import ComposableArchitecture

@Reducer
struct NumberFeature {
    @ObservableState
    struct State: Equatable { var value = 0 }
    enum Action { case reload, response(Int) }

    @Dependency(\.numberClient) var numberClient

    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .reload:
                return .run { send in
                    let n = try await numberClient.fetch()
                    await send(.response(n))
                }
            case let .response(n):
                state.value = n
                return .none
            }
        }
    }
}

Membatalkan Kesan

Kesan yang berjalan lama seperti pemasa sepatutnya boleh dibatalkan. Anda menandai kesan dengan pengecam cancellable dan membatalkannya kemudian daripada tindakan lain menggunakan .cancel.

Dalam contoh ini, pemasa boleh dihentikan apabila diperlukan.

import ComposableArchitecture

enum CancelID { case timer }

// Start a cancellable effect:
.run { send in /* ... */ }
    .cancellable(id: CancelID.timer)

// Stop it from another action:
.cancel(id: CancelID.timer)

Semakan Pantas: Kesan dan Hasil

Ingat kembali cara kesan menyampaikan hasilnya kepada pereduksi.

Jawab dalam pelajaran interaktif

Imbas Kembali: Kesan dan Kebergantungan

Anda telah mempelajari cara TCA mengendalikan kesan sampingan dan penyuntikan:

  • Pereduksi kekal tulen dan memulangkan nilai Effect; .none bermaksud tiada kerja.
  • .run melaksanakan kerja tak segerak dan menghantar hasil kembali melalui await send(.action).
  • Ralat dikendalikan dengan penutupan catch kesan tersebut.
  • @Dependency menyuntik perkhidmatan seperti jam atau klien anda sendiri, yang diisytiharkan melalui DependencyKey dan DependencyValues.
  • Kesan yang berjalan lama boleh dijadikan cancellable berdasarkan ID.

Seterusnya, anda akan menggabungkan ciri dan mengujinya secara menyeluruh.

import ComposableArchitecture

// Recap: pure reducer + Effect.run for async work
// + @Dependency for testable, injectable services.
Percuma untuk bermula

Pelajari Swift dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
122
Pelajaran
409
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Kesan dan Kebergantungan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Swift Academy, termasuk “Kesan dan Kebergantungan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Kesan dan Kebergantungan”?

Kendalikan kesan sampingan dan suntik kebergantungan. Anda berlatih Swift Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Swift Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Swift Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Kesan dan Kebergantungan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Keadaan, Tindakan dan Reducer
  2. Store dan Integrasi SwiftUI
  3. Kesan dan Kebergantungan
  4. Menggubah dan Menguji Ciri
← Kembali ke Swift Academy