SwiftUI嵌套ForEach遍历嵌套结构体时编译器超时失败求助

以下是几种针对该问题的有效解决方案，核心思路是减少SwiftUI编译器的类型推断负担：

1. 拆分嵌套视图为独立子视图 #

将内层ForEach的逻辑抽成单独的子视图，让编译器分别处理每个视图的类型，避免一次性解析复杂的嵌套结构。

示例代码： #

首先定义遵循Identifiable的模型：

struct ParentModel: Identifiable {
    let id: UUID
    let name: String
    let children: [ChildModel]
}

struct ChildModel: Identifiable {
    let id: UUID
    let title: String
}

父视图只处理外层遍历，内层遍历交给子视图：

struct ParentView: View {
    let parents: [ParentModel]
    
    var body: some View {
        ScrollView {
            VStack(spacing: 16) {
                ForEach(parents) { parent in
                    VStack(alignment: .leading) {
                        Text(parent.name)
                            .font(.title)
                        // 调用子视图处理内层遍历
                        ChildRowView(children: parent.children)
                    }
                }
            }
            .padding()
        }
    }
}

子视图专注于内层数据的渲染：

struct ChildRowView: View {
    let children: [ChildModel]
    
    var body: some View {
        ForEach(children) { child in
            Text(child.title)
                .font(.subheadline)
                .padding(.leading)
        }
    }
}

2. 显式指定ForEach的元素类型 #

不让编译器自动推断元素类型，而是直接标注，减少编译器的计算量。

示例代码： #

struct ParentView: View {
    let parents: [ParentModel]
    
    var body: some View {
        ScrollView {
            VStack(spacing: 16) {
                // 显式标注外层元素类型
                ForEach(parents) { (parent: ParentModel) in
                    VStack(alignment: .leading) {
                        Text(parent.name)
                            .font(.title)
                        // 显式标注内层元素类型
                        ForEach(parent.children) { (child: ChildModel) in
                            Text(child.title)
                                .font(.subheadline)
                                .padding(.leading)
                        }
                    }
                }
            }
            .padding()
        }
    }
}

3. 将复杂视图逻辑抽为计算属性/函数 #

把ForEach闭包内的复杂视图结构抽成单独的计算属性或函数，简化闭包内容，让编译器更容易解析。

示例代码： #

struct ParentView: View {
    let parents: [ParentModel]
    
    var body: some View {
        ScrollView {
            VStack(spacing: 16) {
                ForEach(parents) { parent in
                    // 直接调用预先定义好的视图生成函数
                    parentContent(for: parent)
                }
            }
            .padding()
        }
    }
    
    // 抽离复杂视图逻辑
    private func parentContent(for parent: ParentModel) -> some View {
        VStack(alignment: .leading) {
            Text(parent.name)
                .font(.title)
            ForEach(parent.children) { child in
                Text(child.title)
                    .font(.subheadline)
                    .padding(.leading)
            }
        }
    }
}

这些方法都是通过简化编译器的类型推断工作来解决超时问题，你可以根据自己的视图复杂度选择最合适的方案。

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