SwiftUI：如何仅让栈顶视图响应定时器状态更新？

你的问题核心在于：当前定时器通过.autoconnect()自动启动后，即便视图被导航到后台（不在导航栈顶部），订阅也不会自动取消，所以到10秒时依然会触发Alert。以下是几种针对性的解决方案：

方案一：通过onAppear/onDisappear手动控制订阅 #

适合iOS13+版本，核心逻辑是不在初始化时自动连接定时器，而是在视图出现时订阅、消失时取消：

struct ScreenA: View { // 建议重命名视图，避免与系统NavigationView冲突
    // 移除.autoconnect()，手动控制定时器连接
    let timer = Timer.publish(every: 1, on: .main, in: .default)
        .receive(on: DispatchQueue.main)
        .scan(0) { counter, _ in counter + 1 }
    
    @State private var counter = "Seconds"
    @State private var alert: AlertConfiguration?
    @State private var timerCancellable: AnyCancellable? // 保存订阅实例，用于取消

    var body: some View {
        ZStack {
            HStack(alignment: .top) {
                Text(counter)
                Spacer()
            }
            
            NavigationLink(destination: ScreenB()) {
                Button("跳转到详情") {
                    // 你的navigationAction逻辑
                }
            }
        }
        .onAppear {
            // 视图出现时启动定时器订阅
            timerCancellable = timer.sink { count in
                if count == 10 {
                    makeAlert()
                }
                setSeconds(with: count)
            }
        }
        .onDisappear {
            // 视图消失时取消订阅，停止定时器
            timerCancellable?.cancel()
            // 可选：返回后重置计数器
            counter = "Seconds"
        }
        .setAlert(with: $alert)
    }

    private func makeAlert() {
        alert = AlertConfiguration()
    }

    private func setSeconds(with count: Int) {
        counter = "seconds_counter".pluralLocalization(count: count)
    }
}

struct ScreenB: View {
    var body: some View {
        Text("屏幕B")
    }
}

方案二：iOS16+用NavigationStack监测导航状态 #

如果项目支持iOS16及以上，可以通过isActive绑定的导航状态，直接跳过后台视图的定时器逻辑：

struct ScreenA: View {
    let timer = Timer.publish(every: 1, on: .main, in: .default)
        .autoconnect()
        .receive(on: DispatchQueue.main)
        .scan(0) { counter, _ in counter + 1 }
    
    @State private var counter = "Seconds"
    @State private var alert: AlertConfiguration?
    @State private var isNavigatedToB = false // 绑定导航状态

    var body: some View {
        NavigationStack {
            ZStack {
                HStack(alignment: .top) {
                    Text(counter)
                    Spacer()
                }
                
                Button("跳转到详情") {
                    isNavigatedToB = true
                }
            }
            .navigationDestination(isPresented: $isNavigatedToB) {
                ScreenB()
            }
            .onReceive(timer) { count in
                // 仅当视图在栈顶时处理逻辑
                guard !isNavigatedToB else { return }
                
                if count == 10 {
                    makeAlert()
                }
                setSeconds(with: count)
            }
            .setAlert(with: $alert)
        }
    }

    // 其他方法保持不变
}

方案三：用@StateObject封装定时器逻辑 #

把定时器的启停逻辑封装到ObservableObject中，让视图只负责状态响应：

class TimerManager: ObservableObject {
    let timer = Timer.publish(every: 1, on: .main, in: .default)
        .receive(on: DispatchQueue.main)
        .scan(0) { counter, _ in counter + 1 }
    
    @Published var counter = 0
    private var cancellable: AnyCancellable?

    func start() {
        cancellable = timer.sink { [weak self] count in
            self?.counter = count
        }
    }

    func stop() {
        cancellable?.cancel()
        counter = 0 // 重置计数器
    }
}

struct ScreenA: View {
    @StateObject private var timerManager = TimerManager()
    @State private var alert: AlertConfiguration?
    @State private var counterText = "Seconds"

    var body: some View {
        ZStack {
            HStack(alignment: .top) {
                Text(counterText)
                Spacer()
            }
            
            NavigationLink(destination: ScreenB()) {
                Button("跳转到详情") {
                    // 你的navigationAction逻辑
                }
            }
        }
        .onAppear {
            timerManager.start()
        }
        .onDisappear {
            timerManager.stop()
        }
        .onReceive(timerManager.$counter) { count in
            if count == 10 {
                makeAlert()
            }
            setSeconds(with: count)
        }
        .setAlert(with: $alert)
    }

    private func makeAlert() {
        alert = AlertConfiguration()
    }

    private func setSeconds(with count: Int) {
        counterText = "seconds_counter".pluralLocalization(count: count)
    }
}

以上方案的核心都是在视图离开导航栈顶部时，停止定时器订阅或跳过状态处理，确保Alert只会在视图可见时触发。

内容的提问来源于stack exchange，提问作者Ahmed Ben Henda