如何停止 ForEach 中额外的不必要的可识别视图渲染？

我预计，由于我的视图是可识别的，SwiftUI 将识别哪些视图需要更新并仅重新渲染那些视图。

“哪些视图需要更新”不是由身份决定的，而是由平等决定的。

事实上， s 的任何身份都StudentView不会改变。因此按照您的逻辑，即使显示姓名已更新的学生的视图也不应该更新，因为它显示的学生仍然具有相同的id。

如果您的视图仅包含“简单”的结构值，SwiftUI 通常可以确定视图是否已更改（因此应该更新），即使视图及其包含的值不符合Equatable。这是一个演示：

struct ContentView: View {
    @State var classroom = classroom1
    var body: some View {
        // you don't need findIndex, just pass a binding to ForEach!
        ForEach($classroom.students) { $student in
            HStack {
                SimpleStudentView(student: student)
                Button("Update") {
                    // only one SimpleStudentView gets updated when you tap the button
                    student.name += " updated"
                }
            }
        }
    }
}

struct SimpleStudentView: View {
    let student: Student
    
    var body: some View {
        print("updated", student.name)
        return Text(student.name)
    }
}

但是，如果你的视图有一个(String) -> Void，SwiftUI 总是认为你的视图已经发生了变化。毕竟，你如何判断一个 是否(String) -> Void等于另一个(String) -> Void？

您可以使其StudentView自身符合Equatable，因此 SwiftUI 确切地知道如何将 的旧版本StudentView与新版本进行比较，并确定是否body需要再次调用。

@preconcurrency Equatable这需要在 Swift 6 中实现，因为View它与主参与者隔离。只要您不调用==主参与者，这便是安全的。SwiftUI 将始终调用==主参与者。

struct Student: Identifiable, Equatable { // Student should conform to Equatable!
    let id: UUID = UUID()
    var name: String
}

struct StudentView: View, @preconcurrency Equatable {
    let student: Student
    let action: (String) -> Void
    
    var body: some View {
        print("updated", student.name)
        return Text(student.name)
            .onTapGesture {
                action(student.name + " updated! ")
            }
    }
    
    static func ==(lhs: Self, rhs: Self) -> Bool {
        lhs.student == rhs.student
    }
}

struct ContentView: View {
    
    @State private var school: [Classroom] = [classroom1, classroom2]
    
    var body: some View {
        VStack {
            Divider()
            ForEach($school) { $classroom in
                ForEach($classroom.students) { $student in
                    StudentView(student: student) {
                        student.name = $0
                    }
                }
                Divider()
            }
        }
        .padding()
    }
}

或者，将 包装(String) -> Void在您自己的Equatable实现中。在这里，我将(String) -> Void和包装Student成一个结构体。

struct StudentAndAction: Equatable {
    let student: Student
    let action: (String) -> Void
    
    static func ==(lhs: Self, rhs: Self) -> Bool {
        lhs.student == rhs.student
    }
}

struct StudentView: View {
    let studentAndAction: StudentAndAction
    
    init(student: Student, action: @escaping (String) -> Void) {
        self.studentAndAction = StudentAndAction(student: student, action: action)
    }
    
    var body: some View {
        print("updated", studentAndAction.student.name)
        return Text(studentAndAction.student.name)
            .onTapGesture {
                studentAndAction.action(studentAndAction.student.name + " updated! ")
            }
        
    }
}

您也可以将其包装(String) -> Void到Equatable始终返回 true 的实现中。

这是来自@Sweeper 的非常有见地的回答，直接解决了您的代码的问题。

但是，如果您不想混淆 Equatable 和在数组中查找索引，则可以通过使用可观察类而不是结构体并将绑定传递给子视图来大大简化一切。

因此，不要struct：

struct Classroom: Identifiable {
    let id: UUID = UUID()
    var name: String
    var students: [Student]
}

使用可观察类：

@Observable
class Classroom: Identifiable {
    let id: UUID = UUID()
    var name: String
    var students: [Student]
    
    init(name: String, students: [Student]) {
        self.name = name
        self.students = students
    }
}

而不是循环查找索引：

ForEach(classroom.students) { student in
    StudentView(student: student, action: { value in
       if let classroomIndex: Int = findIndex(item: classroom, array: school) {
        if let studentIndex: Int = findIndex(item: student, array: classroom.students) {
school[classroomIndex].students[studentIndex].name = value
                            }
                        }
                    })
                }

传递绑定：

ForEach($classroom.students) { $student in
    StudentView(student: $student)  
}
                    
    Divider()

以下是完整代码：

import SwiftUI

struct SchoolView: View {
    
    @State private var school: [Classroom] = [classroom1, classroom2]

    var body: some View {
        
        VStack {
            Divider()
            
            ForEach($school) { $classroom in
                VStack {
                    Text(classroom.name)
                        .font(.headline)
                    
                    ForEach($classroom.students) { $student in
                        StudentView(student: $student)
                    }
                    
                    Divider()
                }
            }
            
        }
        .padding()
    }
}

struct StudentView: View {
    @Binding var student: Student
    
    var body: some View {
        let _ = print("rendering for:", student.name)
        Text(student.name)
            .onTapGesture {
                student.name += " updated!"
            }
    }
}

@Observable
class Student: Identifiable {
    let id: UUID = UUID()
    var name: String = ""
    
    init(name: String) {
        self.name = name
    }
}

@Observable
class Classroom: Identifiable {
    let id: UUID = UUID()
    var name: String
    var students: [Student]
    
    init(name: String, students: [Student]) {
        self.name = name
        self.students = students
    }
}

let classroom1: Classroom = Classroom(
    name: "Classroom 1",
    students: [
        Student(name: "John"),
        Student(name: "Diana"),
        Student(name: "Brandon")
    ]
)
let classroom2: Classroom = Classroom(
    name: "Classroom 2",
    students: [
        Student(name: "Charlie"),
        Student(name: "Alice"),
        Student(name: "Bob")
    ]
)

#Preview {
    SchoolView()
}