SwiftUI多视图状态管理疑难咨询：索引与视图更新问题

Hey there, let's tackle your SwiftUI state management headaches step by step. The core issues you're facing mostly stem from mixing reference-type ObservableObject classes for nested data and not leveraging SwiftUI's binding system properly. Let's break down each problem and fix your code example.

Key Problems & Solutions #

1. Syncing Changes Between Parent/Child Views #

Your main issue with updates not propagating is because Item and SubItem are reference-type ObservableObjects—changes inside them don't trigger updates in the parent Model's @Published items array. Instead, switch to value types (structs) for nested data. Struct changes will automatically trigger the @Published array to emit updates, since the array element itself changes.

2. Index Out of Range Errors #

Using firstIndex(where:)! is risky (force-unwrapping can crash if the element isn't found), and deleting with indices tied to a non-bounded array can go wrong when the array changes. Instead, use SwiftUI's built-in support for binding to array elements directly in ForEach.

3. Binding Deeply Nested Variables to @EnvironmentObject #

You don't need messy index chains. By passing Binding references down the view hierarchy, you can directly modify nested properties while keeping everything synced to your root Model.

4. Avoiding Multiple ObservedObjects #

By making Item and SubItem structs, you only need your root Model to be an ObservableObject. All child views can work with Binding types instead, eliminating the need for extra @ObservedObject properties.

Fixed Code Example #

import SwiftUI

// MARK: - Model (Only ObservableObject Needed)
class Model: ObservableObject { 
    @Published var items: [Item] 
    init(items: [Item]) { 
        self.items = items 
    } 
} 

// MARK: - Nested Value Types (Structs)
struct Item: Identifiable { 
    let id = UUID() 
    var itemName: String 
    var subItems: [SubItem] 
} 

struct SubItem: Identifiable { 
    let id = UUID() 
    var isOn: Bool 
} 

// MARK: - Main View
struct MainView: View { 
    @EnvironmentObject var model: Model 
    var body: some View { 
        NavigationStack { // Use NavigationStack instead of NavigationView (iOS 16+)
            List { 
                // Use ForEach with binding to array elements
                ForEach($model.items) { $item in 
                    NavigationLink(destination: SubView1(item: $item)) { 
                        HStack{ 
                            Text(item.itemName)
                            // Safely access subItems with optional checks (no force-unwrapping)
                            if let firstSubItem = item.subItems.first {
                                Text(firstSubItem.isOn ? "True":"False")
                            }
                            if item.subItems.count > 1 {
                                Text(item.subItems[1].isOn ? "True":"False")
                            }
                        } 
                    }
                }.onDelete(perform: delete) 
            }
            .navigationTitle("Main View")
        } 
    } 
    func delete(at offsets: IndexSet) { 
        model.items.remove(atOffsets: offsets) 
    } 
} 

// MARK: - SubView 1
struct SubView1: View { 
    @Binding var item: Item // Receive binding to Item
    var body: some View { 
        List { 
            ForEach($item.subItems) { $subItem in 
                NavigationLink(destination: SubView2(subItem: $subItem)) { 
                    ToggleView(subItem: $subItem) 
                } 
            }.onDelete(perform: delete) 
        }
        .navigationTitle(item.itemName)
    } 
    func delete(at offsets: IndexSet) { 
        item.subItems.remove(atOffsets: offsets) 
    } 
} 

// MARK: - SubView 2
struct SubView2: View { 
    @Binding var subItem: SubItem // Receive binding to SubItem
    var body: some View { 
        Toggle(isOn: $subItem.isOn) { 
            Text("Toggle-Text") 
        }
        .padding()
        .navigationTitle("Sub Item Detail")
    } 
} 

// MARK: - Toggle View
struct ToggleView: View { 
    @Binding var subItem: SubItem // Receive binding to SubItem
    var body: some View { 
        Toggle(isOn: $subItem.isOn) { 
            Text("Toggle-Text") 
        } 
    } 
}

What Changed & Why? #

• Structs for Nested Data: Item and SubItem are now structs. Any change to their properties updates the parent array element, triggering the Model's @Published update—so the main view automatically refreshes.
• Binding Passing: All child views receive @Binding references instead of @ObservedObject. This lets them modify the original data directly, with changes syncing up to the Model and main view.
• Safe Index Access: We added checks for subItems count instead of force-unwrapping, preventing crashes.
• Modern Navigation: Switched to NavigationStack (iOS 16+) for better compatibility with SwiftUI's latest features.

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