为什么 sorted(by:) 有效但 sort(by:) 在 ForEach 循环中无效

Question

我正在尝试以有序的方式显示自定义对象列表。 虽然这有效......

import SwiftUI

struct MyModel: Identifiable {
    let id = UUID()
    let timestamp: Date
}

struct ViewModel {
    var models = [
        MyModel(timestamp: Date().addingTimeInterval(300)),
        MyModel(timestamp: Date().addingTimeInterval(100)),
        MyModel(timestamp: Date().addingTimeInterval(500))
    ]
}

struct MyView: View {
    @State var viewModel = ViewModel()
    
    var body: some View {
        List {
            ForEach(viewModel.models.sorted(by: { (lhs, rhs) -> Bool in // will not work with `sort(by:)`
                lhs.timestamp > rhs.timestamp
            })) { model in
                Text("\(model.timestamp)")
            }
            .onDelete(perform: { indexSet in
                //delete from viewModel.models
            })
        }
    }
}

...删除时它不够用，因为我正在处理的数组没有排序（可以说只是它的可视化）。

sort(by:) 应该是我需要的，因为它“对集合进行适当的排序，使用给定的谓词作为元素之间的比较。”根据 Apple 的文档。

但是，相同的ForEach 语句不适用于sort(by:)，抛出错误Cannot convert value of type '()' to expected argument type 'Range<Int>'。

在这种情况下，有没有办法使用ForEach 进行就地排序和循环，还是我必须在我的ViewModel 中处理排序？

Answer 1

之所以不能在ForEach 中使用sort(by:)，是因为sort(by:) 是一个返回Void 的变异函数。另一方面，sorted(by:) 返回一个新数组，您可以使用 ForEach 遍历该数组。

您可以通过在ViewModel 上创建一个单独的计算属性来解决您的问题，该属性返回已排序的models 并使用此已排序的属性调用ForEach。您只需要确保您还对已排序的数组执行删除操作。

struct ViewModel {
    var models = [
        MyModel(timestamp: Date().addingTimeInterval(300)),
        MyModel(timestamp: Date().addingTimeInterval(100)),
        MyModel(timestamp: Date().addingTimeInterval(500))
    ]

    var sortedModels: [MyModel] {
        get {
            models.sorted(by: { $0.timestamp > $1.timestamp })
        }
        set {
            models = newValue
        }
    }
}

struct MyView: View {
    @State var viewModel = ViewModel()

    var body: some View {
        List {
            ForEach(viewModel.sortedModels) { model in
                Text("\(model.timestamp)")
            }
            .onDelete(perform: { indexSet in
                for index in indexSet {
                    viewModel.sortedModels.remove(at: index)
                }
            })
        }
    }
}

Answer 2

无需创建计算属性。当您的列表出现时，您可以简单地对模型进行排序。如果模型已经排序，则无需在每次删除模型时对其进行排序。您还应该使您的模型符合可比较的协议：

import SwiftUI

struct ContentView: View {
    @State var viewModel = ViewModel()
    var body: some View {
        List {
            ForEach(viewModel.models) {
                Text("\($0.timestamp)")
            }
            .onDelete {
                $0.reversed().forEach { viewModel.models.remove(at: $0) }
            }
        }.onAppear {
            viewModel.models.sort(by: >)
        }
    }
}

---

struct MyModel: Identifiable {
    let id = UUID()
    let timestamp: Date
}

extension MyModel: Comparable {
    static func < (lhs: Self, rhs: Self) -> Bool {
        lhs.timestamp < rhs.timestamp
    }
}

---

struct ViewModel {
    var models = [
        MyModel(timestamp: Date().addingTimeInterval(300)),
        MyModel(timestamp: Date().addingTimeInterval(100)),
        MyModel(timestamp: Date().addingTimeInterval(500))
    ]
}

---

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

Answer 3

除了其他两个答案之外，我想添加更多关于您打算如何使用 ViewModel 的信息。

本质上，您希望有一个 ViewModel，它是一个 ObservableObject 和一个 @Published 属性，用于您希望更改的值。这样你就可以在 ViewModel 中封装任何重要的逻辑。

拥有一个结构 ViewModel 没有任何意义，因为结构不是可变的。

此外，您可以在模型类型上实现Comparable，允许您将排序绑定到类型，而不是在代码中的随机位置。现在，如果您的模型已经排序，那么当您删除单个模型时，如何也不必重新排序内容。

如果你有插入，你会想在插入时对它们进行排序。

最后，您应该只对 UI 状态使用 @State 变量，而不是 (View)Model 状态。

import SwiftUI

struct MyModel: Identifiable, Equatable, Comparable {
    let id = UUID()
    let timestamp: Date

    static func < (lhs: MyModel, rhs: MyModel) -> Bool {
        return lhs.timestamp > rhs.timestamp
    }
}

class ViewModel: ObservableObject {
    @Published
    private(set) var models: [MyModel]

    init() {
        let now = Date()
        models = [
            MyModel(timestamp: now.addingTimeInterval(300)),
            MyModel(timestamp: now.addingTimeInterval(100)),
            MyModel(timestamp: now.addingTimeInterval(500))
        ].sorted()
    }

    func remove(at indicies: IndexSet) {
        indicies.forEach { index in
            models.remove(at: index)
        }
    }
}

struct ContentView: View {
    @ObservedObject
    var viewModel = ViewModel()

    var body: some View {
        List {
            ForEach(viewModel.models) { model in
                Text("\(model.timestamp)")
            }
            .onDelete(perform: { indexSet in
                viewModel.remove(at: indexSet)
            })
        }
    }
}