Какие знаешь однонаправленные архитектуры?

Однонаправленные архитектуры в iOS-разработке

Однонаправленные архитектуры — это подход к организации кода, при котором поток данных в приложении строго однонаправлен: от состояния (state) к UI и обратно через предсказуемые действия (actions). Это противоположность двунаправленным связям, где данные могут обновляться из множества мест, что усложняет отладку и тестирование. В iOS-экосистеме наиболее известными реализациями являются Redux и его адаптации, а также The Composable Architecture (TCA) от Point-Free.

Ключевые принципы однонаправленного потока:

1. Единый источник истины (Single Source of Truth) — всё состояние приложения хранится в одном неизменяемом (immutable) объекте.
2. Состояние неизменяемо (State is Immutable) — для обновления состояния создаётся новая копия с изменениями.
3. Изменения через действия (Changes via Actions) — UI или другие части приложения отправляют действия (actions), которые описывают, что произошло.
4. Предсказуемые редюсеры (Predictable Reducers) — чистые функции, которые принимают текущее состояние и действие, возвращая новое состояние.
5. Однонаправленный цикл (Unidirectional Loop) — UI отображает состояние → пользовательское взаимодействие создаёт действие → редюсер обновляет состояние → UI перерисовывается.

Популярные реализации в iOS:

1. Redux-подобные архитектуры

Изначально Redux пришёл из веб-разработки (JavaScript), но был адаптирован для Swift. Пример базовой реализации:

// Состояние
struct AppState {
    var counter: Int = 0
}

// Действия
enum AppAction {
    case increment
    case decrement
}

// Редюсер
func appReducer(state: inout AppState, action: AppAction) {
    switch action {
    case .increment:
        state.counter += 1
    case .decrement:
        state.counter -= 1
    }
}

// Хранилище
class Store<State, Action> {
    private var state: State
    private let reducer: (inout State, Action) -> Void
    
    init(state: State, reducer: @escaping (inout State, Action) -> Void) {
        self.state = state
        self.reducer = reducer
    }
    
    func send(_ action: Action) {
        reducer(&state, action)
    }
}

Библиотеки: ReSwift, SwiftRex.

2. The Composable Architecture (TCA)

Мощная библиотека от Point-Free, построенная на идеях Redux и Elm, но с глубокой интеграцией в Swift. Предоставляет инструменты для управления побочными эффектами, композиции модулей и тестирования.

import ComposableArchitecture

// Доменный модуль
struct CounterFeature: Reducer {
    struct State: Equatable {
        var count = 0
    }
    
    enum Action: Equatable {
        case incrementButtonTapped
        case decrementButtonTapped
    }
    
    func reduce(into state: inout State, action: Action) -> Effect<Action> {
        switch action {
        case .incrementButtonTapped:
            state.count += 1
            return .none
        case .decrementButtonTapped:
            state.count -= 1
            return .none
        }
    }
}

// Использование в SwiftUI
struct CounterView: View {
    let store: StoreOf<CounterFeature>
    
    var body: some View {
        WithViewStore(store, observe: { $0 }) { viewStore in
            VStack {
                Text("Count: \(viewStore.count)")
                Button("Increment") {
                    viewStore.send(.incrementButtonTapped)
                }
                Button("Decrement") {
                    viewStore.send(.decrementButtonTapped)
                }
            }
        }
    }
}

3. MVVM + State Management

Хотя MVVM сама по себе не является строго однонаправленной, её можно комбинировать с паттернами типа MVI (Model-View-Intent) или использовать реактивные фреймворки (Combine, RxSwift) для однонаправленного потока. Пример с Combine:

class CounterViewModel: ObservableObject {
    @Published private(set) var count = 0 // State
    
    // Actions
    func increment() {
        count += 1
    }
    
    func decrement() {
        count -= 1
    }
}

Преимущества однонаправленных архитектур:

• Предсказуемость — благодаря строгому потоку данных легче отслеживать изменения и дебажить.
• Тестируемость — редюсеры как чистые функции легко тестировать без моков UI.
• Консистентность — состояние всегда синхронизировано, нет рассинхрона между данными.
• Масштабируемость — удобно добавлять новые функции, логгировать действия, реализовывать undo/redo.

Недостатки:

• Бойлерплейт — требуется писать много кода для простых действий (action, reducer, state).
• Кривая обучения — особенно для разработчиков, не знакомых с функциональным программированием.
• Производительность — постоянное копирование больших структур состояния может быть накладно (решается через оптимизации, например, TCA использует efficient store).

Когда использовать?

• Сложные приложения с множеством взаимосвязанных состояний (финансовые, редакторы, графики).
• Командная разработка — где важна согласованность и тестируемость.
• Требования к отладке — необходимость логгировать каждое действие или путешествовать во времени (time-travel debugging).

В iOS-мире TCA набирает огромную популярность благодаря своей типобезопасности, композиции и мощным инструментам. Для более простых приложений можно рассмотреть Redux-подобные решения или даже Combine-based MVVM с однонаправленным потоком. Ключ — выбрать подход, соответствующий сложности проекта и опыту команды.