SwiftUI中@Published双向数据流：忽略程序修改触发的上传事件

核心思路是通过自定义Binding来区分「用户手动操作Toggle」和「代码直接更新@Published变量」两种场景，只有用户交互触发的状态变化才会触发服务器上传，代码同步状态时不会触发上传逻辑。

1. 修改ObservableObject（ViewModel） #

添加用于标记用户操作的信号源，结合Combine管道过滤非用户触发的更新：

import Combine

class SettingsViewModel: ObservableObject {
    @Published var toggleValue1: Bool = false
    @Published var toggleValue2: Bool = false
    
    // 标记是否为用户主动触发的更新，初始为false
    private let userInitiatedUpdate = CurrentValueSubject<Bool, Never>(false)
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        // 从本地存储加载初始值
        toggleValue1 = getValue1()
        toggleValue2 = getValue2()
        
        // 组合Toggle值与用户操作信号，仅处理用户触发的更新
        Publishers.CombineLatest($toggleValue1, $toggleValue2)
            .combineLatest(userInitiatedUpdate)
            .map { [weak self] (togglePair, isUserAction) in
                (self?.convertToSomeType(togglePair) ?? SomeType(value1: false, value2: false), isUserAction)
            }
            .removeDuplicates { $0.0 == $1.0 }
            .filter { $0.1 } // 只保留用户触发的更新
            .map { $0.0 }
            .sink { [weak self] state in
                self?.uploadToServer(state)
            }
            .store(in: &cancellables)
    }
    
    // 为Toggle提供自定义Binding：仅用户操作时标记为主动更新
    var toggle1Binding: Binding<Bool> {
        Binding(
            get: { self.toggleValue1 },
            set: {
                self.toggleValue1 = $0
                self.userInitiatedUpdate.send(true)
            }
        )
    }
    
    var toggle2Binding: Binding<Bool> {
        Binding(
            get: { self.toggleValue2 },
            set: {
                self.toggleValue2 = $0
                self.userInitiatedUpdate.send(true)
            }
        )
    }
    
    // 从服务器同步状态的方法：直接修改变量，不触发上传
    func syncFromServer(newValue1: Bool, newValue2: Bool) {
        toggleValue1 = newValue1
        toggleValue2 = newValue2
        saveValue1(newValue1)
        saveValue2(newValue2)
        // 不发送userInitiatedUpdate信号，因此不会触发上传
    }
    
    // 本地存储相关方法（示例用UserDefaults）
    private func getValue1() -> Bool {
        UserDefaults.standard.bool(forKey: "toggle1")
    }
    
    private func saveValue1(_ value: Bool) {
        UserDefaults.standard.set(value, forKey: "toggle1")
    }
    
    private func getValue2() -> Bool {
        UserDefaults.standard.bool(forKey: "toggle2")
    }
    
    private func saveValue2(_ value: Bool) {
        UserDefaults.standard.set(value, forKey: "toggle2")
    }
    
    // 状态转换逻辑
    private func convertToSomeType(_ pair: (Bool, Bool)) -> SomeType {
        SomeType(value1: pair.0, value2: pair.1)
    }
    
    // 服务器上传逻辑
    private func uploadToServer(_ state: SomeType) {
        Task {
            // 执行上传请求
            // 上传成功后同步本地存储
            saveValue1(state.value1)
            saveValue2(state.value2)
        }
    }
}

// 示例状态类型
struct SomeType {
    let value1: Bool
    let value2: Bool
}

2. SwiftUI视图中使用自定义Binding #

在视图里直接调用ViewModel提供的自定义Binding，而非直接绑定@Published变量：

struct SettingsView: View {
    @StateObject private var viewModel = SettingsViewModel()
    
    var body: some View {
        Form {
            Toggle("Toggle 1", isOn: viewModel.toggle1Binding)
            Toggle("Toggle 2", isOn: viewModel.toggle2Binding)
        }
        .onAppear {
            // 视图出现时从服务器拉取最新状态并同步
            Task {
                let serverValue1 = await fetchServerValue1()
                let serverValue2 = await fetchServerValue2()
                viewModel.syncFromServer(newValue1: serverValue1, newValue2: serverValue2)
            }
        }
    }
    
    // 模拟服务器请求方法
    private func fetchServerValue1() async -> Bool {
        // 替换为实际网络请求逻辑
        true
    }
    
    private func fetchServerValue2() async -> Bool {
        // 替换为实际网络请求逻辑
        false
    }
}

方案优势 #

• 完全区分用户交互与代码更新：自定义Binding仅在用户点击Toggle时标记为主动更新，代码同步服务器状态时不会触发上传
• 无需额外标志位：通过Combine信号自然过滤非用户操作，代码更简洁优雅
• 初始加载不触发上传：初始从本地存储加载值时，userInitiatedUpdate为false，会被filter过滤掉

内容的提问来源于stack exchange，提问作者Krisztian