SwiftUI：如何在init中用Binding初始化@StateObject？

你当前的代码存在两个核心问题：

1. @State变量在init阶段未被SwiftUI状态系统接管：此时$value并不是有效的Binding，无法传递给ViewModel。
2. @StateObject的生命周期由SwiftUI管理：不能直接在init中赋值，必须通过_viewModel = StateObject(wrappedValue: ...)的方式初始化，但即便如此，此时的@State Binding依然无效。

以下是几种可行的实现方案：

方案一：通过@Published双向同步（推荐） #

让ViewModel持有一个@Published变量，在View中建立和@State的双向同步，既保留@StateObject的生命周期管理，又实现数据联动：

import SwiftUI

class ViewModel: ObservableObject {
    @Published var value: Bool
    
    init(initialValue: Bool) {
        self.value = initialValue
    }
    
    // 这里可以添加依赖value的业务逻辑
    func toggleValue() {
        value.toggle()
    }
}

struct MyView: View {
    @State private var value: Bool
    @StateObject private var viewModel: ViewModel
    
    init() {
        let initialValue = false
        // 初始化@State
        self._value = State(initialValue: initialValue)
        // 初始化@StateObject
        self._viewModel = StateObject(wrappedValue: ViewModel(initialValue: initialValue))
    }
    
    var body: some View {
        VStack {
            Text("View State Value: \(value.description)")
            Text("ViewModel Value: \(viewModel.value.description)")
            
            Button("Toggle from View") {
                value.toggle()
            }
            
            Button("Toggle from ViewModel") {
                viewModel.toggleValue()
            }
        }
        // 同步View的State到ViewModel
        .onChange(of: value) { newValue in
            viewModel.value = newValue
        }
        // 同步ViewModel的Published值到View的State
        .onChange(of: viewModel.value) { newValue in
            value = newValue
        }
    }
}

方案二：改用@ObservedObject（适用于视图生命周期绑定场景） #

如果可以接受ViewModel的生命周期和View完全绑定（即View重建时ViewModel也会重新初始化），可以将@StateObject改为@ObservedObject，在init中直接传递@State的Binding：

import SwiftUI

class ViewModel: ObservableObject {
    let valueBinding: Binding<Bool>
    
    init(valueBinding: Binding<Bool>) {
        self.valueBinding = valueBinding
    }
    
    func toggleValue() {
        valueBinding.wrappedValue.toggle()
    }
}

struct MyView: View {
    @State private var value: Bool
    @ObservedObject private var viewModel: ViewModel
    
    init() {
        // 初始化@State
        self._value = State(initialValue: false)
        // 传递@State的Binding到ViewModel
        self.viewModel = ViewModel(valueBinding: self._value.projectedValue)
    }
    
    var body: some View {
        VStack {
            Text("View State Value: \(value.description)")
            Button("Toggle from ViewModel") {
                viewModel.toggleValue()
            }
        }
    }
}

注意：这种方式下，当MyView因父视图状态变化而重建时，ViewModel会被重新创建，若需要ViewModel跨视图重建保留状态，建议使用方案一。

方案三：自定义Binding同步（繁琐但灵活） #

通过自定义Binding在init阶段初始化ViewModel，后续在视图生命周期中同步到@State：

import SwiftUI

class ViewModel: ObservableObject {
    let valueBinding: Binding<Bool>
    
    init(valueBinding: Binding<Bool>) {
        self.valueBinding = valueBinding
    }
}

struct MyView: View {
    @State private var value: Bool = false
    @StateObject private var viewModel: ViewModel
    
    init() {
        var tempValue = false
        // 创建临时Binding用于初始化ViewModel
        let tempBinding = Binding<Bool>(
            get: { tempValue },
            set: { tempValue = $0 }
        )
        self._viewModel = StateObject(wrappedValue: ViewModel(valueBinding: tempBinding))
        self._value = State(initialValue: tempValue)
    }
    
    var body: some View {
        VStack {
            Text("View State Value: \(value.description)")
            Text("ViewModel Binding Value: \(viewModel.valueBinding.wrappedValue.description)")
        }
        .onAppear {
            // 初始化同步
            viewModel.valueBinding.wrappedValue = value
        }
        .onChange(of: value) { newValue in
            viewModel.valueBinding.wrappedValue = newValue
        }
        .onChange(of: viewModel.valueBinding.wrappedValue) { newValue in
            value = newValue
        }
    }
}

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