在 SwiftUI 的 ForEach 中过滤 @Binding 数组 var 返回基于未过滤数组的值

Question

我是一名 Windows C# 开发人员，是 iOS/SwiftUI 开发的新手，我想我已经在这方面陷入了困境。

我有一个带有@Binding 变量的视图：

struct DetailView: View {
    @Binding var project: Project

项目是一个包含任务数组的对象。我正在遍历项目的任务以显示其名称和一个切换，其状态由任务的变量 isComplete 确定。

    ForEach(filteredTasks.indices, id: \.self) { idx in
        HStack {
            Text(filteredTasks[idx].phase)
                .font(.caption)
            Spacer()
            Text(filteredTasks[idx].name)
            Spacer()
            Toggle("", isOn: self.$filteredTasks[idx].isComplete)
        }
    }
}

我花了很长时间才找到这段代码，我发现我必须按照一个带有“索引”选项的示例来让切换分别在每个任务上工作，并确保它的 isComplete 值已保存。

接下来，我想根据具有 Planning、Construction 或 Final 值的任务变量阶段过滤任务列表。所以我创建了 4 个按钮（每个阶段一个，然后是一个“所有任务”以返回完整的未过滤列表），并且经过大量试验和错误（创建不再正确绑定的过滤数组等）。等）我试过了，基本上只使用原始数组。

            List {
                ForEach(project.tasks.filter({ $0.phase.contains(filterValue) }).indices, id: \.self) { idx in
                    HStack {
                        Text(project.tasks[idx].phase)
                            .font(.caption)
                        Spacer()
                        Text(project.tasks[idx].name)
                        Spacer()
                        Toggle("", isOn: self.$project.tasks[idx].isComplete)
                    }
                }
            }

当然，这似乎可行，因为我可以做一个测试：

    func CreateTestArray() {
        let testFilterArray = project.tasks.filter({ $0.phase.contains(filterValue) })
    }

这会给我我想要的过滤列表。但是，在我的 ForEach 视图中，它无法正常工作，我不确定如何解决它。

例如，我有 128 个任务，其中 10 个的值为“Final”，当我使用按钮将 filterValue 设置为 Final 时，testFilterArray 实际上包含正确的 10 个任务 - 但在 ForEach 视图中，我获取原始数组中的前十个任务（属于“计划”类型 - 原始数组按计划/构造/最终排序）；显然，尽管有 filter 语句，ForEach 仍在处理原始数组。计划按钮发送 filterValue = "Planning"，我得到正确的结果，因为过滤器为我在原始数组中的 20 个计划任务返回 0-19 索引，并且由于它们是原始数组中的第一个，它'似乎'规划过滤器工作正常，但实际上它只是偶然地工作，如果数组的排序方式不同，它就不会。

有什么想法可以解决这个问题，以便我可以实际过滤这个数组，为数组中的每个项目正确显示 isComplete 切换，以及动态更新切换状态吗？我觉得我需要再次从头开始，因为我已经让这些限制让我进入了一个小小的 Swift 角落。

谢谢！

更新： 谢谢@jnpdx，您的快速回复 - 我肯定应该包含对象（我在下面列出）。然而，回顾我的对象定义，我想知道我是否在管理对象时犯了一个更基本的错误，这就是我陷入困境的原因（即，在早期的迭代中，我尝试了一些你的建议）。无论如何，我发布的对象是“项目”，它是我传递给项目列表视图的项目列表，然后该视图将单个项目传递给项目视图，然后该视图列出了该特定项目中的任务.

我觉得你的回答让我做出了正确的决定，我只需要备份并查看那些对象定义/管理，看看如何找到一个可以直接解决的情况。

任务：

 struct Task:  Identifiable, Codable {
    let id: UUID
    var phase: String
    var category: String
    var name: String
    var isComplete: Bool
    
    init(id: UUID = UUID(), phase: String, category: String, name: String, isComplete: Bool) {
        self.id = id
        self.phase = phase
        self.category = category
        self.name = name
        self.isComplete = isComplete
    }
}

项目：

 struct Project: Identifiable, Codable {
    
    var id: UUID
    var name: String
    var type: String
    var tasks: [Task]
    var isComplete: Bool

    
    init(id: UUID = UUID(), name: String, type: String, tasks: [Task] = [], isComplete: Bool) {
        self.id = id
        self.name = name
        self.type = type
        self.tasks = tasks
        self.isComplete = isComplete
    }

}

和项目模型：

 class ProjectData: ObservableObject {
    
    // code to access the json file is here
    
    // An accessible list of projects from the saved file
    @Published var projects: [Project] = []
    
    // load and save functions follow

更新： 谢谢@jnpdx，您的解决方案在按照您所说的那样进行调整以使其在我的特定模型设计中发挥作用后起作用。这是最终在我的案例中起作用的 sn-ps。

在我看来：

 List {
  ForEach(project.tasks.filter({ $0.phase.contains(filterValue) })) { task in
    HStack {
      Text(task.name)
      Toggle("", isOn: self.makeBinding(item: task))
      }
   }
}

以及被调用的函数：

     func makeBinding(item: Task) -> Binding<Bool> {
        let i = self.project.tasks.firstIndex { $0.id == item.id }!
        return .init(
            get: { self.project.tasks[i].isComplete },
            set: { self.project.tasks[i].isComplete = $0 }
        )
    }

Answer 1

让我们看看您的代码中的以下行：

ForEach(project.tasks.filter({ $0.phase.contains(filterValue) }).indices, id: \.self) { idx in

在第一部分中，您过滤tasks，然后请求索引。我的怀疑是你希望它会返回类似 [1, 5, 10, 11, 12] 的东西，这意味着它们在数组中的原始位置。但是，实际上，您会得到一个像 [0,1,2,3,4] 这样的连续数组，因为它会为您提供新创建的数组中的索引（filter 的结果）。

有几种方法可以解决这个问题，这也与您之前的 ForEach 相关。

执行ForEach 并迭代结构/对象而不是索引更习惯。你没有显示Task 是由什么组成的，但假设它是这样的：

struct Task : Hashable {
  var id = UUID()
  var name: String
  var phrase: String
  var isComplete: Bool
}

要对其进行迭代，您可以这样做：

ForEach(task, id: \.id) { task in 
  Text(task.name)
  Toggle("Done?", isOn: project.taskCompletedBinding(id: task.id)) //explained later
}

我在评论中询问了Project 的类型，因为我不完全清楚为什么它是@Binding。似乎可能它是一个对象？如果它是一个很好的视图模型，您可以在那里处理您的Toggle 逻辑。比如：

class Project : ObservableObject {
    @Published var tasks : [Task] = [Task(name: "1", phrase: "phase", isComplete: false),Task(name: "2", phrase: "phase", isComplete: true),Task(name: "3", phrase: "phase2", isComplete: false)]

    var completedTasks : [Task] {
        return tasks.filter { $0.isComplete }
    }
    
    func taskCompletedBinding(id: UUID) -> Binding<Bool> {
        Binding<Bool>(get: {
            self.tasks.first(where: { $0.id == id})?.isComplete ?? false
        }, set: { newValue in
            self.tasks = self.tasks.map { t in
                if t.id == id {
                    var tCopy = t
                    tCopy.isComplete = newValue
                    return tCopy
                } else {
                    return t
                }
            }
        })
    }
}

您可以测试它是否可以这样做：

struct ContentView: View {
    @ObservedObject var project = Project()
    
    var body: some View {
        ForEach(project.tasks, id: \.id) { task in
            Text(task.name)
            Toggle("Done?", isOn: project.taskCompletedBinding(id: task.id))
        }
    }
}

如果Project 是一个结构体而不是一个对象，最好将它包装在一个ObservableObject 视图模型中，就像我在上面所做的那样。