Swift’s Composable Architecture Brings Redux Model to iOS App Development
New York, August 25, 2024 -The world of iOS app development is witnessing a new wave of architectural innovation with the rise of Composable Architecture (TCA), a Swift library designed to simplify andstreamline the process of building complex applications. Recently released in version 1.13, TCA offers a comprehensive framework for tackling common challenges in app development, includingstate management, feature composition, side effect handling, and testing.
TCA’s core principles are rooted in the concepts of state, action, reducer, and store – concepts familiar to React developers using Redux, but relatively new to native iOSdevelopment. This approach, according to TCA creators Brandon Williams and Stephen Celis, allows developers to break down large, complex features into smaller, more manageable components that can be easily combined.
While TCA can be used with both UIKit andSwift, its design is heavily inspired by SwiftUI, making it a natural complement to the framework. This makes TCA particularly user-friendly for developers familiar with SwiftUI and its patterns.
One of TCA’s key features is the @ObservableState macro, which functions similarly to iOS 16’s @Observable and allows for the detection of any state changes, mirroring SwiftUI’s behavior. TCA also borrows SwiftUI’s approach to composability, where each feature is a type that provides a body property, mimicking SwiftUI’s @Environment property wrappers and utilizing @Dependency property wrappers for dependencyspecification.
The following code snippet demonstrates how to model a simple increment/decrement counter feature using TCA:
“`swift
@Reducer
struct Feature {
@ObservableState
struct State: Equatable {
var count = 0
var numberFact: String?
}
enum Action {
case decrementButtonTapped
case incrementButtonTapped
case numberFactButtonTapped
case numberFactResponse(String)
}
var body: some Reducer\u003cState, Action\u003e {
Reduce { state, action in
switch action {
// Implementall actions here;
// They will modify the state or produce side effects
}
}
}
}
“`
As shown, the app’s state and user-driven actions are modeled using specific types, while the body method handles updating the state for each action.
State sharing is another crucial aspect of TCA, achieved through the @Shared macro. This macro works similarly to SwiftUI’s @Binding, exposing a publisher property that allows for the detection of any changes made to the reference from any part of the application. The @Shared property wrapper also supportspersisting data to memory, user defaults, shared files, or using custom mechanisms.
TCA leverages commonly used UI elements from SwiftUI, such as sheet(item:), popover(item:), and NavigationStack, but also offers its own navigation mechanisms more suited to state-driven applications. The libraryprimarily supports two navigation modes: tree-based navigation and stack-based navigation.
While adopting a library as the foundation for an application’s architecture can be a challenging decision, the authors of TCA argue that in certain cases, it might be the best approach rather than attempting to reinvent the wheel from scratch. If alibrary’s core principles align with your priorities when building an application, adopting it can be a wise choice. A well-defined set of tools with a consistent maintenance history and a strong community is preferable to stitching together numerous tips and tricks scattered across internet blog posts.
Swift Composable Architecture can be cloned fromGitHub or installed from the Swift Package Index. With over 12,000 stars and 1,400 forks on GitHub, along with over 200 contributors, it has become one of the most popular Swift architecture libraries on the Swift Package Index.
This new development in iOS app developmentis likely to have a significant impact on how developers approach building complex applications. TCA’s focus on composability, state management, and ease of testing makes it a compelling alternative to traditional architectures, particularly for developers familiar with SwiftUI. As TCA continues to evolve and gain traction, it could become a cornerstone of iOS app developmentin the years to come.
【来源】https://mp.weixin.qq.com/s/X-0vo0bQZl2tsg4ArhQlpQ
Views: 1