В чем разница между однонаправленным и двунаправленным потоком данных в архитектуре?

А, слушай, вот это тема, про которую можно до утра спорить, пока не поймёшь, что все эти умные слова сводятся к одному: как не наебнуться с данными в своём приложении. Смотри, есть два главных лагеря, и они друг друга ненавидят, как кошка с собакой.

Однонаправленный поток (Unidirectional Data Flow, UDF) Это когда у тебя всё, блядь, по расписанию, как в армии. Данные ходят строго по кругу: Состояние → Вид → Действие → Опять Состояние. Никаких самоволок, сука. Хочешь что-то поменять? Пиши заявление в трёх экземплярах, то есть создавай экшен. Это как бюрократия, но зато предсказуемая, епта.

Вот смотри, классика жанра, типа Redux:

// 1. Состояние — священная корова, единый источник истины. Трогать только в белых перчатках.
struct AppState {
    var username: String = ""
    var isLoading: Bool = false
}

// 2. Экшены — это бумажки, на которых написано "хочу то" и "хочу это".
enum Action {
    case setUsername(String)
    case setLoading(Bool)
}

// 3. Редьюсер — это чиновник в окошке. Получил бумажку (экшен) и старую папку (стейт), выдал новую папку. Сам ничего не решает, просто правила выполняет.
func reducer(state: AppState, action: Action) -> AppState {
    var newState = state
    switch action {
    case .setUsername(let name):
        newState.username = name // Иммутабельно, блядь, как будто клонировал!
    case .setLoading(let loading):
        newState.isLoading = loading
    }
    return newState
}

// 4. Вьюха — это ты, пришедший в это окошко. Ты видишь только то, что в папке лежит, и можешь только бумажки подавать.
struct ProfileView: View {
    let state: AppState
    let dispatch: (Action) -> Void // Функция-почтальон для отправки бумажек

    var body: some View {
        VStack {
            TextField("Name", text: Binding(
                get: { state.username }, // Посмотрел в папку
                set: { newName in dispatch(.setUsername(newName)) } // Подал бумажку с новым именем
            ))
            if state.isLoading { ProgressView() }
        }
    }
}

Чем хорош UDF? Да тем, что если что-то пошло не так, ты всегда можешь посмотреть папочку с бумажками (лог экшенов) и понять, на каком этапе какой мудак всё сломал. Редьюсер тестируется на раз-два, потому что он, как робот, от одних и тех же входных данных всегда выдаёт один и тот же результат. Предсказуемость, блядь, наше всё.

Двунаправленная привязка (Bidirectional / Two-Way Binding) А это полная противоположность, ебаный цирк. Тут данные и UI связаны невидимой резинкой. Потянул в одном месте — дернулось в другом. Изменил текст в поле — модель тут же обновилась. Изменил модель в коде — интерфейс тут же перерисовался. Магия, хуле.

Вот, например, в SwiftUI это выглядит до охуения просто:

struct ContentView: View {
    @State private var text: String = "" // Вот он, источник данных, прямо тут

    var body: some View {
        // Смотри, магия! Знак доллара ($text) — это и есть та самая резинка.
        // Поменял в поле — text обновился. Поменял text в коде — поле обновилось.
        TextField("Enter text", text: $text)
        Text("You typed: (text)")
    }
}

Или вот реактивный подход на Combine:

class LoginViewModel: ObservableObject {
    @Published var username = "" // Объявил свойство как @Published — и всё, понеслась.
    @Published var password = ""
    // Тыкнул в поле, символ улетел в `username`, система это увидела и крикнула всем вьюхам: "Перерисовывайтесь, мудаки!"
}

Так что же лучше, спросишь ты? Давай на пальцах.

Вывод, который все ненавидят: нормальные пацаны используют гибрид, ёпта. Глобальное состояние всего приложения (типа данных пользователя, корзины покупок) тащат через однонаправленный поток — для порядка и спокойствия. А локальные пиздюльки вроде текста в инпуте или состояния чекбокса — через двустороннюю привязку, чтобы не писать тонны однообразного кода. И так живут, хитрожопые.