SwiftUI中如何将View的Binding值与ObservableObject的Published值双向绑定？

需要实现objValue（ObservableObject的Published属性）和viewValue（View的Binding属性）的双向同步，同时避免使用onChange修饰符导致的额外View重绘，以下是两种可行方案：

方案一：通过Combine订阅实现双向同步 #

在View初始化阶段建立双向订阅，通过去重和相等判断避免循环触发，确保每次变更只触发一次View重绘。

import SwiftUI
import Combine

class MyObject: ObservableObject {
    @Published var objValue: Int = 0
}

struct MyView: View {
    @Binding var viewValue: Int
    @StateObject private var obj = MyObject()
    @State private var cancellables = Set<AnyCancellable>()
    
    init(viewValue: Binding<Int>) {
        self._viewValue = viewValue
        
        // 订阅objValue变更，同步到viewValue（避免循环）
        obj.$objValue
            .removeDuplicates()
            .sink { [weak self] newValue in
                guard let self = self, self.viewValue != newValue else { return }
                self.viewValue = newValue
            }
            .store(in: &cancellables)
        
        // 订阅viewValue变更，同步到objValue（避免循环）
        viewValue
            .publisher
            .removeDuplicates()
            .sink { [weak self] newValue in
                guard let self = self, self.obj.objValue != newValue else { return }
                self.obj.objValue = newValue
            }
            .store(in: &cancellables)
    }
    
    var body: some View {
        VStack {
            Text("View Value: \(viewValue)")
            Text("Object Value: \(obj.objValue)")
            
            Button("+1 to Object Value") {
                obj.objValue += 1
            }
            
            Button("+1 to View Value") {
                viewValue += 1
            }
        }
        .onChange(of: viewValue) { newValue in
            // 此处逻辑仅在viewValue变更时触发一次，无额外重绘
            print("View value updated to: \(newValue)")
        }
    }
}

方案说明 #

• 利用Combine的sink方法订阅两个值的变更流，removeDuplicates()和相等判断避免循环同步。
• 同步逻辑在View初始化时完成，不会在body中产生额外状态变更触发重绘。
• 无论修改objValue还是viewValue，都会同步到另一方，且仅触发一次View重绘。

方案二：在ObservableObject内部处理绑定同步 #

将同步逻辑封装到ObservableObject中，隔离状态同步与UI逻辑，让View结构更简洁。

import SwiftUI
import Combine

class MyObject: ObservableObject {
    @Published var objValue: Int = 0
    private var cancellables = Set<AnyCancellable>()
    
    init(externalValue: Binding<Int>) {
        // 初始化时同步初始值
        objValue = externalValue.wrappedValue
        
        // 订阅外部Binding值变更，同步到objValue
        externalValue
            .publisher
            .removeDuplicates()
            .sink { [weak self] newValue in
                guard let self = self, self.objValue != newValue else { return }
                self.objValue = newValue
            }
            .store(in: &cancellables)
        
        // 订阅objValue变更，同步到外部Binding值
        $objValue
            .removeDuplicates()
            .sink { [weak externalValue] newValue in
                guard let externalValue = externalValue, externalValue.wrappedValue != newValue else { return }
                externalValue.wrappedValue = newValue
            }
            .store(in: &cancellables)
    }
}

struct MyView: View {
    @Binding var viewValue: Int
    @StateObject private var obj: MyObject
    
    init(viewValue: Binding<Int>) {
        self._viewValue = viewValue
        self._obj = StateObject(wrappedValue: MyObject(externalValue: viewValue))
    }
    
    var body: some View {
        VStack {
            Text("View Value: \(viewValue)")
            Text("Object Value: \(obj.objValue)")
            
            Button("+1 to Object Value") {
                obj.objValue += 1
            }
            
            Button("+1 to View Value") {
                viewValue += 1
            }
        }
        .onChange(of: viewValue) { newValue in
            print("View value updated to: \(newValue)")
        }
    }
}

方案说明 #

• 双向同步逻辑完全封装在MyObject内部，View仅需传入Binding即可完成关联。
• 同样通过去重和相等判断避免循环触发，确保每次变更仅同步一次，无额外View重绘。
• 符合MVVM架构思想，状态同步逻辑与UI逻辑分离，代码可维护性更强。

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