SwiftUI疑难：修改@State变量为何无法触发视图刷新？

问题背景 #

我在SwiftUI开发中遇到一个奇怪的现象：FootprintView里的@State变量jdNow用于计算Canvas绘制的Path，通过定时器更新jdNow后，主视图却不会自动刷新——只有在视图层级中保留一个引用jdNow的透明Text时，Canvas才会定期重绘。已经确认onReceive确实在修改jdNow，计算逻辑也完全正确，目前只能靠透明Text作为临时解决方案，希望搞清楚@State的工作机制到底哪里理解错了。

原代码示例：

struct FootprintView: View {

    @State private var jdNow: Double = Date.now.julianDate

    var body: some View {

        Text("\(jdNow)").opacity(0.0)   //## 需要保留才能触发重绘（原因是什么）..

        Canvas { context, size in
            let mercatorContext = context.mercatorCoords(size)    // 转换为墨卡托坐标..

            let visualGroup =  . . .

            for elements in visualGroup. . . {
                let satellite = Satellite(elements: elements)

                let minsAfterEpoch = (jdNow - JD.epoch1950 - satellite.t₀Days1950) * 1440.0
                let satCel = satellite.position(minsAfterEpoch: minsAfterEpoch)
                let satLLH = eci2geo(julianDays: jdNow, celestial: satCel)

                let footprintPath = drawFootprint(satGeo: satLLH)
                mercatorContext.stroke(footprintPath, with: .color(.white), lineWidth: 0.2)
            }
        }
        .onReceive(global5SecTimer) { _ in
            jdNow = Date.now.julianDate
        }
    }
}

原因剖析 #

SwiftUI的视图刷新核心是依赖追踪机制：只有当视图body中直接引用的可观察变量（如@State、@ObservedObject）发生变化时，才会触发body的重建和视图刷新。

但Canvas的绘制闭包属于“黑盒”——SwiftUI的依赖追踪系统无法穿透这个闭包内部的变量引用。也就是说，虽然你在Canvas闭包里用到了jdNow，但SwiftUI无法感知到这个依赖关系，所以当jdNow变化时，SwiftUI会认为当前body没有依赖这个变量，也就不会触发body的重建，Canvas自然不会更新。

而那个透明Text直接在body层级引用了jdNow，让SwiftUI明确感知到变量和视图的依赖关系，所以jdNow变化时会触发body重建，Canvas也会跟着重新绘制。

解决方案 #

方案1：给Canvas添加.id(jdNow)修饰符 #

这是最简单的替代方案，通过修改Canvas的唯一标识id，强制SwiftUI在jdNow变化时重建整个Canvas视图：

struct FootprintView: View {

    @State private var jdNow: Double = Date.now.julianDate

    var body: some View {
        Canvas { context, size in
            let mercatorContext = context.mercatorCoords(size)
            let visualGroup = ...

            for elements in visualGroup... {
                let satellite = Satellite(elements: elements)
                let minsAfterEpoch = (jdNow - JD.epoch1950 - satellite.t₀Days1950) * 1440.0
                let satCel = satellite.position(minsAfterEpoch: minsAfterEpoch)
                let satLLH = eci2geo(julianDays: jdNow, celestial: satCel)
                let footprintPath = drawFootprint(satGeo: satLLH)
                
                mercatorContext.stroke(footprintPath, with: .color(.white), lineWidth: 0.2)
            }
        }
        .id(jdNow) // 用jdNow作为Canvas的唯一标识，变化时强制重建
        .onReceive(global5SecTimer) { _ in
            jdNow = Date.now.julianDate
        }
    }
}

方案2：使用ObservableObject封装状态 #

把jdNow放到ObservableObject中，在Canvas闭包里显式引用这个对象，让SwiftUI能追踪到依赖：

class TimerData: ObservableObject {
    @Published var jdNow: Double = Date.now.julianDate
}

struct FootprintView: View {
    @StateObject private var timerData = TimerData()

    var body: some View {
        Canvas { context, size in
            // 显式引用timerData，让SwiftUI感知到依赖
            let currentJD = timerData.jdNow
            let mercatorContext = context.mercatorCoords(size)
            let visualGroup = ...

            for elements in visualGroup... {
                let satellite = Satellite(elements: elements)
                let minsAfterEpoch = (currentJD - JD.epoch1950 - satellite.t₀Days1950) * 1440.0
                let satCel = satellite.position(minsAfterEpoch: minsAfterEpoch)
                let satLLH = eci2geo(julianDays: currentJD, celestial: satCel)
                let footprintPath = drawFootprint(satGeo: satLLH)
                
                mercatorContext.stroke(footprintPath, with: .color(.white), lineWidth: 0.2)
            }
        }
        .onReceive(global5SecTimer) { _ in
            timerData.jdNow = Date.now.julianDate
        }
    }
}

方案3：自定义ViewModifier封装绘制逻辑 #

把Canvas的绘制逻辑封装成依赖jdNow的ViewModifier，让SwiftUI能追踪到变量和视图的关联：

struct FootprintModifier: ViewModifier {
    let jdNow: Double

    func body(content: Content) -> some View {
        content
            .overlay(
                Canvas { context, size in
                    let mercatorContext = context.mercatorCoords(size)
                    let visualGroup = ...

                    for elements in visualGroup... {
                        let satellite = Satellite(elements: elements)
                        let minsAfterEpoch = (jdNow - JD.epoch1950 - satellite.t₀Days1950) * 1440.0
                        let satCel = satellite.position(minsAfterEpoch: minsAfterEpoch)
                        let satLLH = eci2geo(julianDays: jdNow, celestial: satCel)
                        let footprintPath = drawFootprint(satGeo: satLLH)
                        
                        mercatorContext.stroke(footprintPath, with: .color(.white), lineWidth: 0.2)
                    }
                }
            )
    }
}

struct FootprintView: View {
    @State private var jdNow: Double = Date.now.julianDate

    var body: some View {
        Color.clear
            .modifier(FootprintModifier(jdNow: jdNow))
            .onReceive(global5SecTimer) { _ in
                jdNow = Date.now.julianDate
            }
    }
}

总结 #

SwiftUI的依赖追踪只会关注body层级直接引用的可观察变量，闭包内部的引用无法被自动感知。解决这类问题的核心是让SwiftUI明确感知到状态变量和视图的依赖关系，以上三种方案都能达到这个目的，其中方案1是最轻量化的临时替代，方案2更适合复杂状态的管理。

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