SwiftData过滤与视图更新性能问题优化咨询

针对你遇到的计算属性频繁调用、旧设备卡顿崩溃的问题，核心优化思路是缓存计算结果，仅在依赖数据变化时重新计算，同时优化过滤排序逻辑的执行效率。

1. 替换计算属性为缓存变量 #

将原本每次访问都会重新计算的data计算属性，改为@Published修饰的缓存变量，避免重复计算：

// 替换原计算属性data
@Published private var groupedEvents: [Date: [Event]] = [:]
// 保留原视图可见性控制的布尔值
@State private var isViewVisible = true

2. 用Combine监听依赖变化，按需更新缓存 #

通过Combine合并所有影响过滤结果的数据源（CoreData的events）和过滤参数，仅当其中任意一项变化时，才触发一次过滤排序计算，并将结果赋值给缓存变量。同时将计算逻辑放到后台线程，避免阻塞主线程：

import Combine

struct YourView: View {
    @Query(sort: \Event.startTime) private var events: [Event]
    @ObservedObject var filterManager: FilterManager
    private var cancellables = Set<AnyCancellable>()
    
    init(filterManager: FilterManager) {
        self.filterManager = filterManager
        setupCombinePipeline()
    }
    
    private func setupCombinePipeline() {
        // 合并所有影响过滤结果的参数
        Publishers.CombineLatest7(
            events.publisher,
            filterManager.$selectedCategories,
            filterManager.$distance,
            filterManager.$maxPrice,
            filterManager.$startDate,
            filterManager.$endDate,
            filterManager.$searchText
        )
        // 切换到后台线程执行计算
        .subscribe(on: DispatchQueue.global(qos: .userInitiated))
        // 执行过滤和排序，同时判断视图是否可见
        .map { [weak self] events, categories, distance, maxPrice, startDate, endDate, searchText in
            guard let self = self, self.isViewVisible else { return [:] }
            let filteredEvents = self.filterManager.filteredEvents(events: events)
            return self.filterManager.sortedEventsByDay(events: filteredEvents)
        }
        // 切回主线程更新UI缓存
        .receive(on: DispatchQueue.main)
        .assign(to: \.groupedEvents, on: self)
        .store(in: &cancellables)
    }
    
    // 视图Body中直接使用groupedEvents即可
    var body: some View {
        // ... 你的视图代码，使用groupedEvents渲染
    }
}

3. 优化过滤排序逻辑的执行效率 #

优化分组排序方法 #

用系统内置的Dictionary(grouping:by:)替代手动循环分组，系统实现经过性能优化，代码更简洁高效：

func sortedEventsByDay(events: [Event]) -> [Date: [Event]] {
    guard !events.isEmpty else { return [:] }
    // 按当天起始时间分组
    let groupedDict = Dictionary(grouping: events) { event in
        Calendar.current.startOfDay(for: event.startTime)
    }
    // 对每个分组内的事件按时间排序（可选，因@Query已排序，可根据需求保留）
    return groupedDict.mapValues { $0.sorted(by: { $0.startTime < $1.startTime }) }
}

优化过滤方法 #

用filter高阶函数替代手动循环，代码更简洁，且系统实现的过滤逻辑性能更优：

func filteredEvents(events: [Event]) -> [Event] {
    guard !events.isEmpty else { return [] }
    let locationManager = AppDelegate.instance.locationManager
    let publishedStatusId = StatusType.PUBLISHED.id
    
    return events.filter { event in
        // 距离过滤
        if distance < 1000, event.distanceFromCurrentLocation(locationManager) > distance {
            return false
        }
        // 分类过滤
        if !selectedCategories.isEmpty, let category = event.category, !selectedCategories.contains(category) {
            return false
        }
        // 状态过滤
        if event.statusId != publishedStatusId {
            return false
        }
        // 价格过滤
        if maxPrice < 1000, event.price > maxPrice {
            return false
        }
        // 时间范围过滤
        if event.startTime < startDate || event.endTime > endDate {
            return false
        }
        // 搜索文本过滤
        if !searchText.isEmpty,
           !event.name.localizedStandardContains(searchText),
           !event.desc.localizedStandardContains(searchText) {
            return false
        }
        return true
    }
}

优化效果说明 #

• 缓存变量groupedEvents仅在依赖数据变化时更新一次，彻底解决计算属性被频繁调用的问题。
• 后台线程执行计算，避免主线程阻塞，消除旧设备卡顿崩溃的情况。
• 系统内置方法的使用进一步提升了过滤排序的执行效率。

内容的提问来源于stack exchange，提问作者Luuk D. Jansen