Timer 是 Swift 和 Foundation 框架中的一个类，用于创建和管理定时任务。它可以在指定的时间间隔内重复执行某些任务，或者在指定的时间之后执行一次任务。
核心概念
1、定时器的功能
Timer 的主要作用是定期触发某个操作，常用于以下场景：
更新 UI，例如计时器显示或动画刷新。
定期执行任务，例如定时同步数据。
延时执行任务。
2、运行环境
Timer 通常依赖于运行循环（RunLoop）来调度任务。
可以指定在哪个运行循环模式（如 .default 或 .common）下触发任务。
Timer 的基本用法
1、创建一个定时器
Timer 提供了两种基本的创建方式：
1、使用静态方法：scheduledTimer
自动将定时器添加到当前运行循环中。
示例：
Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
print("Timer fired!")
}参数解析：
1）timeInterval: 1.0：每 1 秒触发一次。
2）repeats: true：表示是否重复触发。
3）闭包：当定时器触发时执行的代码。
示例：
import SwiftUI
struct ContentView: View {
@State private var counter = 0
var body: some View {
VStack {
Text("Counter: \(counter)")
.font(.largeTitle)
Button("Reset Counter") {
counter = 0
}
}
.onAppear {
Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
counter += 1
print("Counter is now \(counter)")
if counter >= 10 {
timer.invalidate() // 停止计时器
}
}
}
}
}需要在计时器中更新 UI，可以将计时器的副作用通过 @State 管理：
2、使用构造器：init(timeInterval:repeats:block:)
使用 Timer 的构造器 init(timeInterval:repeats:block:) 创建定时器时，需要手动将定时器添加到运行循环中（RunLoop），因为它不会自动开始工作。
示例：
import SwiftUI
struct ContentView: View {
@State private var counter = 0
private var timer: Timer?
var body: some View {
VStack {
Text("Counter: \(counter)")
.font(.largeTitle)
.padding()
Button("Start Timer") {
startTimer()
}
.padding()
Button("Stop Timer") {
stopTimer()
}
.padding()
}
}
private func startTimer() {
// 检查是否已有定时器在运行
if timer != nil {
return
}
// 创建定时器
timer = Timer(timeInterval: 1.0, repeats: true) { timer in
DispatchQueue.main.async {
counter += 1
print("Counter is now \(counter)")
}
}
// 将定时器添加到当前运行循环中
if let timer = timer {
RunLoop.current.add(timer, forMode: .common)
}
}
private func stopTimer() {
// 停止定时器
timer?.invalidate()
timer = nil
}
}
两种创建方式的区别
从功能上看，Timer 的两种创建方式（scheduledTimer 和 init(timeInterval:repeats:block:)）都可以用来创建一个定时器，且最终实现的功能相同。但它们的主要区别在于 使用方式 和 运行循环的处理方式。
1、使用静态方法：scheduledTimer
特点
1）自动管理运行循环：
Timer.scheduledTimer 会自动将创建的定时器添加到 当前运行循环（RunLoop.current） 中，并立即开始工作。
2）更方便：
不需要手动添加到运行循环，因此代码更简洁。
3）适合大多数场景：
如果不需要自定义运行循环或手动管理定时器的启动和暂停，推荐使用这种方式。
示例：
Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
print("Timer fired!")
}内部机制
等价于以下手动处理的代码：
let timer = Timer(timeInterval: 1.0, repeats: true) { timer in
print("Timer fired!")
}
RunLoop.current.add(timer, forMode: .default) // 自动添加到运行循环中
2、使用构造器：init(timeInterval:repeats:block:)
特点
1）手动管理运行循环：
需要显式调用 RunLoop.add(_:forMode:) 将定时器添加到运行循环，否则定时器不会启动。
2）更灵活：
适合需要将定时器绑定到 特定运行循环 或者 特定运行循环模式 的场景。例如：
在后台线程上运行定时器。
在自定义运行循环模式（如 .tracking）下运行。
3）更复杂：
因为需要手动添加和管理运行循环，代码稍显冗长，不适合简单任务。
示例：
let timer = Timer(timeInterval: 1.0, repeats: true) { timer in
print("Manual timer fired!")
}
RunLoop.current.add(timer, forMode: .common) // 手动添加到运行循环中实际使用选择建议
1、优先选择 scheduledTimer
适合绝大多数场景，因为它简单直接，自动管理运行循环，无需额外代码。
例如，在主线程上更新计时器、更新 UI 等常见任务时。
2、使用 init(timeInterval:repeats:block:) 的场景
自定义运行循环：需要绑定到后台线程的运行循环。
控制定时器的启动：如果想延迟定时器启动，可以先创建定时器但暂时不添加到运行循环中。
复杂运行循环模式：需要手动指定模式（如 .tracking）。
2、停止定时器
调用 invalidate() 方法可以停止定时器：
timer.invalidate()在 SwiftUI 中使用 Combine 的 Timer
在 SwiftUI 和 Combine 框架中，Timer.publish 提供了一种更现代化和响应式的方法来使用定时器。与传统的 Timer.scheduledTimer 或 Timer 构造器不同，它不是直接触发回调，而是返回一个 Combine 的 Publisher。这种机制更加适合 SwiftUI 的声明式和响应式编程风格。
Timer.publish
通过 Timer.publish，Timer 变成了一个 Combine Publisher，可以订阅它的时间更新。例如：
let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()1、every：时间间隔（以秒为单位）。
2、on：
可选值：
main：主线程运行循环（大部分 UI 更新的默认选择）。
自定义队列：可以通过 Combine 提供的自定义调度器（如后台线程）运行定时器。
Timer.publish(every: 1, on: DispatchQueue.global(), in: .common)该定时器会在全局队列上运行（非主线程）。
3、in：
指定定时器运行循环的模式。
常见值：
.common（推荐）：常见模式，适配各种场景。
.default：运行循环的默认模式。
.tracking：通常在滚动视图交互时使用。
自定义模式：可以定义自定义的运行循环模式。
4、使用 .autoconnect() 会自动连接并开始发布事件。
结合 SwiftUI 的 .onReceive，可以订阅这些事件：
.onReceive(timer) { time in
print("Timer triggered at \(time)")
}示例：
struct ContentView: View {
let timer = Timer.publish(every: 1, tolerance: 0.5, on: .main, in: .common).autoconnect()
@State private var counter = 0
var body: some View {
Text("Hello, World!")
.onReceive(timer) { time in
if counter == 5 {
timer.upstream.connect().cancel()
} else {
print("The time is now \(time)")
}
counter += 1
}
}
}
timer.upstream.connect().cancel()为什么 timer.upstream.connect().cancel() 能取消定时器？
这是因为 Timer.publish 创建的定时器是一个 ConnectablePublisher，它的 upstream 属性指向了它的上游数据流（即定时器本身）。当我们调用 autoconnect() 时，它会自动连接到上游数据流并开始发出事件。
工作原理
1、Timer.publish(every:tolerance:on:in:) 创建定时器：
它返回一个 Timer.TimerPublisher，这是一个 ConnectablePublisher。
2、autoconnect() 自动连接：
autoconnect() 方法使定时器在被订阅时自动连接到它的上游数据流，从而开始发布事件。
3、upstream.connect() 的作用：
如果不使用 autoconnect()，需要手动调用 connect() 来启动定时器。当 autoconnect() 被调用时，它隐式地调用了 upstream.connect()。
4、connect().cancel() 的作用：
调用 connect() 会返回一个 Cancellable 对象，该对象可以用来取消连接并停止发布事件。即使使用了 autoconnect()，我们仍然可以通过 timer.upstream.connect().cancel() 显式取消连接，从而停止定时器。
改进方式
直接存储 connect() 返回的 Cancellable 对象，可以更优雅地控制定时器：
import SwiftUI
import Combine
struct ContentView: View {
@State private var counter = 0
@State private var timerCancellable: Cancellable? // 用于控制 Timer 的生命周期
var body: some View {
VStack {
Text("Counter: \(counter)")
.font(.largeTitle)
HStack {
Button("Start Timer") {
startTimer()
}
.padding()
Button("Stop Timer") {
stopTimer()
}
.padding()
}
}
}
func startTimer() {
// 确保没有重复启动 Timer
stopTimer()
timerCancellable = Timer.publish(every: 1, on: .main, in: .common)
.autoconnect()
.sink { _ in
counter += 1
}
}
func stopTimer() {
timerCancellable?.cancel()
timerCancellable = nil
}
}关键点
1、使用 Cancellable 控制生命周期：
Timer 是通过 Timer.publish 创建的，它返回一个 ConnectablePublisher。当我们调用 .sink 订阅它时，会返回一个 Cancellable，通过取消这个对象来停止定时器。
2、调用 cancel() 方法：
停止 Timer 的关键是调用 timerCancellable?.cancel()，这会取消所有相关订阅，停止事件的发布。
3、避免重复启动：
在 startTimer() 中先调用 stopTimer()，确保没有重复的定时器运行。
注意事项
如果不手动停止 Timer，它会继续运行直到被系统销毁（例如当视图被销毁时）。
为了更好地管理资源，在定时器不再需要时，务必取消其订阅。
为什么要有 Timer.publish？
1、响应式设计
Combine 是一个响应式框架，Publisher 是其核心组件，用于异步数据流的管理。
SwiftUI 本质上依赖 Combine，视图通过订阅 Publisher 来响应状态的变化。
使用 Timer.publish，定时器的时间更新被包装成 Publisher，视图可以直接订阅这个数据流并更新 UI。
2、更好的结合 SwiftUI
SwiftUI 的数据驱动架构要求所有 UI 更新都基于状态，而状态的变化通常由事件（如定时器更新）驱动。
使用 Timer.publish，可以轻松地将定时器的事件流绑定到 SwiftUI 的状态中，从而触发界面的更新。
3、更清晰的生命周期管理
Timer.publish 结合了 Combine 的订阅机制，定时器的生命周期由订阅者管理。
不再需要手动添加到运行循环或显式地停止定时器（例如调用 invalidate()）。
区别于静态方法和构造器
1、传统 Timer（静态方法与构造器）
触发方式：通过闭包回调（block），定时器触发时直接执行闭包。
运行循环：依赖运行循环管理。
手动管理：需要手动处理生命周期（invalidate()）以及可能的线程切换（例如 UI 更新需要在主线程）。
// 传统方式的示例
Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
print("Timer fired!")
}2、Combine 的 Timer.publish
触发方式：通过 Combine 的 Publisher，将事件发布为数据流。
运行循环：运行循环隐式处理，通过 Combine 自动适配。
自动管理：使用 .autoconnect() 后自动连接，无需手动管理开始或停止。
链式处理：可以结合 Combine 的操作符（如 map, filter, debounce 等）对事件流进行链式处理，代码更加简洁优雅。
// Combine 的方式
let timer = Timer.publish(every: 1.0, on: .main, in: .common).autoconnect()
timer.sink { date in
print("The time is now \(date)")
}核心优点：响应式与声明式结合
通过 Timer.publish，可以直接将定时器事件与 SwiftUI 的状态绑定起来，简化代码并提升可读性。例如：
示例：在 SwiftUI 中使用 Timer.publish
struct ContentView: View {
@State private var currentTime = Date()
// 创建一个定时器 Publisher
let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()
var body: some View {
Text("Current Time: \(currentTime)")
.onReceive(timer) { time in
// 更新状态
currentTime = time
}
.font(.title)
.padding()
}
}
代码分析
Timer.publish：创建一个 Combine Publisher，定时发送当前时间。
autoconnect()：自动开始发布数据流。
onReceive：SwiftUI 提供的修饰符，用于订阅 Publisher，并在事件到来时更新状态。
优点
不需要手动管理 Timer 的开始、停止和生命周期。
将定时器事件与 SwiftUI 状态的绑定过程声明式化，更易读。
完全结合 Combine 的响应式操作符，支持复杂的数据流处理。
注意事项
1、性能影响：
定时器运行在主线程时，任务需要足够快地执行，避免阻塞主线程。
长时间运行的定时器可能影响设备的性能或电池寿命。
2、内存管理：
定时器会强引用目标对象，可能导致内存泄漏。为避免这种情况，可以使用弱引用或确保及时调用 invalidate()。
总结
Timer 是一个功能强大的工具，适合定时任务或延时操作。在 SwiftUI 和现代应用开发中，通常结合 Combine 和运行循环一起使用，以实现更灵活的时间调度。
传统的 Timer 方法：更适合独立的定时任务，需要手动处理运行循环和生命周期管理。
Timer.publish 和 Combine：为响应式设计而生，更适合与 SwiftUI 搭配，尤其是在涉及到状态绑定和复杂数据流处理的场景中。
推荐使用 Timer.publish：如果项目是基于 SwiftUI 和 Combine 的，使用 Timer.publish 会更加自然高效。
扩展知识
Timer.publish属于Combine还是属于Timer？
Timer.publish 属于 Timer 类，但它结合了 Combine 框架 的功能，用来创建一个 Combine 的 Publisher。可以理解为这是 Timer 和 Combine 的桥梁。
归属分析
1、为什么属于 Timer
定义位置：publish(every:on:in:) 是 Timer 的类方法，直接定义在 Timer 中。
作用本质：Timer.publish 是 Timer 的一种扩展方式，用来将传统的 Timer 与 Combine 的 Publisher 系统结合起来。
调用方式：必须通过 Timer 类调用，例如：
let timerPublisher = Timer.publish(every: 1, on: .main, in: .common)2、和 Combine 的关系
输出类型是 Combine 的 Publisher：
Timer.publish 返回一个 Combine 的 Publisher（Timer.TimerPublisher 类型）。
它符合 Combine 的 Publisher 协议，可以通过 sink、map 等 Combine 操作符处理。
功能依赖 Combine：
Timer.publish 本质上是 Timer 的扩展功能，用来与 Combine 的响应式机制配合。如果不使用 Combine（如 Swift 4 或更早版本），这个方法毫无意义。
结合点：Timer.TimerPublisher
类型：
Timer.TimerPublisher 是一个嵌套在 Timer 中的类型，符合 Combine 的 Publisher 协议。
作用：
允许将 Timer 的定时器事件流转为 Combine 的 Publisher 数据流。
实现方式：
当调用 Timer.publish(every:on:in:) 时，底层会创建一个 Timer.TimerPublisher 实例，并负责生成时间事件流。
Timer.TimerPublisher 定义示例：
extension Timer {
public struct TimerPublisher : ConnectablePublisher {
public typealias Output = Date
public typealias Failure = Never
}
}
