SwiftData查询对象列表添加Toggle：无对象内置Bool的状态存储咨询

针对多课程下学生Toggle状态独立存储的问题，分两种场景给出解决方案：

场景一：临时状态（仅View生命周期内保留） #

如果不需要将选中状态持久化到数据库，仅在页面打开时保存状态，可以在ClassView内用字典存储每个学生的选中状态，利用SwiftData模型的唯一标识persistentModelID作为键：

修改后的ClassView代码 #

import SwiftUI
import SwiftData

struct ClassView: View {
    @Environment(\.modelContext) private var modelContext
    var group: Group
    
    // 用学生的唯一标识作为键，存储选中状态
    @State private var selectedStates: [PersistentIdentifier: Bool] = [:]

    var body: some View {
        List {
            Section("Maths") {
                ForEach(mathStudents(group: group)) { student in
                    HStack{
                        Text(student.name)
                        // 绑定Toggle状态到字典
                        Toggle(isOn: Binding(
                            get: { selectedStates[student.persistentModelID] ?? false },
                            set: { selectedStates[student.persistentModelID] = $0 }
                        )) {}
                        .onChange(of: selectedStates[student.persistentModelID] ?? false) { _, newValue in
                            // 处理状态变化逻辑
                            print("学生\(student.name)数学课程选中状态：\(newValue)")
                        }
                    }
                }
            }
            Section("Physics") {
                ForEach(physicsStudents(group: group)) { student in
                    HStack{
                        Text(student.name)
                        Toggle(isOn: Binding(
                            get: { selectedStates[student.persistentModelID] ?? false },
                            set: { selectedStates[student.persistentModelID] = $0 }
                        )) {}
                        .onChange(of: selectedStates[student.persistentModelID] ?? false) { _, newValue in
                            print("学生\(student.name)物理课程选中状态：\(newValue)")
                        }
                    }
                }
            }
        }
        .onAppear {
            // 初始化所有课程学生的状态为未选中（可根据需求调整初始值）
            mathStudents(group: group).forEach {
                selectedStates[$0.persistentModelID] = selectedStates[$0.persistentModelID] ?? false
            }
            physicsStudents(group: group).forEach {
                selectedStates[$0.persistentModelID] = selectedStates[$0.persistentModelID] ?? false
            }
        }
    }

    func mathStudents(group: Group) -> [Student] { ... }
    func physicsStudents(group: Group) -> [Student] { ... }
}

核心逻辑 #

• 用PersistentIdentifier作为唯一键，避免同名学生的状态冲突；
• @State字典仅在View存活时生效，页面销毁后状态重置。

场景二：持久化状态（保存到数据库） #

如果需要将选中状态长期保存，且支持学生在不同课程下的独立状态，需要新建一个中间关联模型，专门存储学生-课程-选中状态的关系：

1. 新建关联模型 #

@Model
final class CourseEnrollment {
    var isChecked: Bool
    var student: Student
    var course: Course // 需提前定义Course模型，存储课程信息（如名称、ID等）

    init(isChecked: Bool = false, student: Student, course: Course) {
        self.isChecked = isChecked
        self.student = student
        self.course = course
    }
}

2. 修改ClassView代码 #

import SwiftUI
import SwiftData

struct ClassView: View {
    @Environment(\.modelContext) private var modelContext
    var group: Group
    private let mathCourse: Course
    private let physicsCourse: Course

    // 查询对应课程下的所有 enrollment 记录
    @Query private var mathEnrollments: [CourseEnrollment]
    @Query private var physicsEnrollments: [CourseEnrollment]

    // 初始化时传入课程对象，构建查询条件
    init(group: Group, mathCourse: Course, physicsCourse: Course) {
        self.group = group
        self.mathCourse = mathCourse
        self.physicsCourse = physicsCourse

        _mathEnrollments = Query(filter: #Predicate<CourseEnrollment> {
            $0.course == mathCourse && $0.student.group == group
        })
        _physicsEnrollments = Query(filter: #Predicate<CourseEnrollment> {
            $0.course == physicsCourse && $0.student.group == group
        })
    }

    var body: some View {
        List {
            Section("Maths") {
                ForEach(mathEnrollments) { enrollment in
                    HStack{
                        Text(enrollment.student.name)
                        // 直接绑定到关联模型的isChecked属性，自动持久化
                        Toggle(isOn: $enrollment.isChecked) {}
                            .onChange(of: enrollment.isChecked) { _, newValue in
                                print("学生\(enrollment.student.name)数学课程选中状态：\(newValue)")
                            }
                    }
                }
            }
            Section("Physics") {
                ForEach(physicsEnrollments) { enrollment in
                    HStack{
                        Text(enrollment.student.name)
                        Toggle(isOn: $enrollment.isChecked) {}
                            .onChange(of: enrollment.isChecked) { _, newValue in
                                print("学生\(enrollment.student.name)物理课程选中状态：\(newValue)")
                            }
                    }
                }
            }
        }
        .onAppear {
            // 为课程下的学生自动创建 enrollment 记录（避免重复）
            mathStudents(group: group).forEach { student in
                let hasEnrollment = mathEnrollments.contains { $0.student == student }
                if !hasEnrollment {
                    modelContext.insert(CourseEnrollment(student: student, course: mathCourse))
                }
            }

            physicsStudents(group: group).forEach { student in
                let hasEnrollment = physicsEnrollments.contains { $0.student == student }
                if !hasEnrollment {
                    modelContext.insert(CourseEnrollment(student: student, course: physicsCourse))
                }
            }
        }
    }

    func mathStudents(group: Group) -> [Student] { ... }
    func physicsStudents(group: Group) -> [Student] { ... }
}

核心逻辑 #

• CourseEnrollment模型作为中间层，解决了学生与课程的多对多关联，同时独立存储每个学生在对应课程的选中状态；
• 绑定$enrollment.isChecked后，状态变化会自动同步到SwiftData数据库，无需额外保存操作。

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