SwiftUI嵌套数据ForEach使用问题：修改后UI无法自动更新

问题背景 #

定义了可嵌套自身的Foo类（实现Equatable/Hashable/Identifiable/ObservableObject协议），通过ForEach嵌套展示数据时，初始渲染正常，但嵌套视图发起的变更无法自动触发UI更新。目前只能手动调用objectWillChange.send()强制刷新，该方式低效且丢失部分动画效果，尝试用Binding解决但无法正确传递嵌套子项的Binding，寻求可行方案。

方案一：利用@Published让ObservableObject自动通知变更 #

核心是让Foo自身的属性变化能自动发送通知，无需手动触发。

修改Foo类 #

将需要监听变化的属性标记为@Published，同时把id设为常量（UUID不应被修改）：

class Foo: Equatable, Hashable, Identifiable, ObservableObject {
    let id: UUID
    @Published var name: String
    @Published var subFoos: [Foo]?
    
    init(name: String, subFoos: [Foo]? = nil) {
        self.id = UUID()
        self.name = name
        self.subFoos = subFoos
    }
    
    public func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
    
    static func == (lhs: Foo, rhs: Foo) -> Bool {
        lhs.id == rhs.id
    }
}

简化FooContainer视图 #

移除冗余的ViewModel，直接通过@ObservedObject绑定Foo实例，用@State控制显示状态以保留动画：

struct FooContainer: View {
    @ObservedObject var foo: Foo
    @State private var isVisible: Bool = true
    
    var body: some View {
        if isVisible {
            VStack {
                HStack {
                    VStack(alignment: .leading) {
                        Text(foo.name)
                        Text(foo.id.uuidString)
                    }
                    
                    Spacer()
                    
                    Button {
                        let newFoo = Foo(name: "Added Foo")
                        if foo.subFoos == nil {
                            foo.subFoos = [newFoo]
                        } else {
                            foo.subFoos?.append(newFoo)
                        }
                    } label: {
                        Text("+")
                            .font(.title)
                    }.buttonStyle(.bordered)
                    
                    Button {
                        isVisible = false
                    } label: {
                        Text("-")
                            .font(.title)
                    }.buttonStyle(.bordered)
                }
                .frame(maxWidth: .infinity, minHeight: 64)
                .background(Color.random)
                
                VStack(spacing: 8) {
                    ForEach(foo.subFoos ?? [], id: \.self) { subFoo in
                        FooContainer(foo: subFoo)
                            .padding(.leading, 32)
                    }
                }
                .animation(.default, value: foo.subFoos)
            }
            .animation(.default, value: isVisible)
        }
    }
}

优势

• 无需手动调用变更通知，@Published会自动监听属性变化并触发UI更新
• 保留完整的动画效果，逻辑简洁易维护
• 适合多视图共享同一个Foo实例的场景

方案二：值类型+自定义Binding传递（纯SwiftUI状态管理） #

将Foo改为值类型（struct），通过自定义Binding实现嵌套层级的状态传递，确保所有变更能向上传播。

修改Foo为值类型 #

struct Foo: Equatable, Hashable, Identifiable {
    let id: UUID
    var name: String
    var subFoos: [Foo]?
    
    init(name: String, subFoos: [Foo]? = nil) {
        self.id = UUID()
        self.name = name
        self.subFoos = subFoos
    }
    
    public func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
    
    static func == (lhs: Foo, rhs: Foo) -> Bool {
        lhs.id == rhs.id
    }
}

实现嵌套Binding传递 #

通过enumerated()获取子项索引，自定义Binding读写数组中的元素：

struct FooContainer: View {
    @Binding var foo: Foo?
    
    init(foo: Binding<Foo?>) {
        self._foo = foo
    }
    
    var body: some View {
        if let foo = $foo.wrappedValue {
            VStack {
                HStack {
                    VStack(alignment: .leading) {
                        Text(foo.name)
                        Text(foo.id.uuidString)
                    }
                    
                    Spacer()
                    
                    Button {
                        let newFoo = Foo(name: "Added Foo")
                        var updatedFoo = foo
                        if updatedFoo.subFoos == nil {
                            updatedFoo.subFoos = [newFoo]
                        } else {
                            updatedFoo.subFoos?.append(newFoo)
                        }
                        self.foo = updatedFoo
                    } label: {
                        Text("+")
                            .font(.title)
                    }.buttonStyle(.bordered)
                    
                    Button {
                        self.foo = nil
                    } label: {
                        Text("-")
                            .font(.title)
                    }.buttonStyle(.bordered)
                }
                .frame(maxWidth: .infinity, minHeight: 64)
                .background(Color.random)
                
                VStack(spacing: 8) {
                    ForEach(Array(foo.subFoos?.enumerated() ?? []), id: \.element.id) { index, subFoo in
                        FooContainer(
                            foo: Binding(
                                get: { foo.subFoos?[index] },
                                set: { newValue in
                                    guard let newValue = newValue else {
                                        var updatedFoo = foo
                                        updatedFoo.subFoos?.remove(at: index)
                                        self.foo = updatedFoo
                                        return
                                    }
                                    var updatedFoo = foo
                                    updatedFoo.subFoos?[index] = newValue
                                    self.foo = updatedFoo
                                }
                            )
                        )
                        .padding(.leading, 32)
                    }
                }
            }
            .animation(.default, value: foo)
        }
    }
}

// 使用示例
struct ContentView: View {
    @State private var rootFoo: Foo? = Foo(
        name: "Root Foo",
        subFoos: [
            Foo(
                name: "SubFoo 1",
                subFoos: [
                    Foo(name: "SubFoo 2")
                ]
            )
        ]
    )
    
    var body: some View {
        VStack(spacing: 8) {
            FooContainer(foo: $rootFoo)
        }
    }
}

优势

• 值类型的不可变性避免了引用共享带来的状态混乱
• 自定义Binding确保嵌套层级的变更能完整向上传播
• 天然支持SwiftUI的动画系统，所有状态变化都能触发平滑动画

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