Debounce
debounce 又叫做“防抖”：Publisher 在接收到第一个值后，并不是立即将它发布出去，而是会开启一个内部计时器，当一定时间内没有新的事件来到，再将这个值进行发布。如果在计时期间有新的事件，则重置计时器并重复上述等待过程。
场景：
- 处理搜索框过于频繁发起网络请求的问题，每当用户输入一个字符的时候，都发起网络请求，会浪费一部分网络资源，通过debounce，可以实现，当用户停止输入0.5秒再发送请求。
- 处理按钮的连续点击问题，debounce只接收0.5秒后的最后一次点击事件，因此自动忽略了中间的多次连续点击事件
struct Response: Decodable {
struct Foo: Decodable {
var foo: String
}
let args: Foo?
}
let urlStr = "https://httpbin.org/get?foo="
let search = PassthroughSubject<String, Never>()
search
.scan("") { "\($0) \($1)"}
.compactMap { $0.trimmingCharacters(in: .whitespaces).addingPercentEncoding(withAllowedCharacters:.urlQueryAllowed) }
.debounce(for: .seconds(1), scheduler: RunLoop.main)
.flatMap { text in
return URLSession.shared
.dataTaskPublisher(for: URL(string: "\(urlStr)\(text)")!)
.map { data, _ in data }
.decode(type: Response.self, decoder: JSONDecoder())
.compactMap { $0.args?.foo }
.replaceError(with: "")
}
.subscribe(on: RunLoop.main)
.print()
.sink { _ in }
delay(0.1) { search.send("I") }
delay(0.2) { search.send("Love") }
delay(0.5) { search.send("SwiftUI") }
delay(1.6) { search.send("And") }
delay(2.0) { search.send("Combine") }
// Output:
// receive subscription: (SubscribeOn)
// request unlimited
// receive value: (I Love SwiftUI)
// receive value: (I Love SwiftUI And Combine)
Throttle
它会设定一个固定时间间隔的时间窗口，当时间窗口结束后，就发送数据。
注意，latest可以指定发送的数据是该窗口内的第一个数据还是最后一个数据。当publisher发送的数据刚好在时间窗口边缘的时候，结果是不确定的。
上图中就是分别在0.5秒，1.0秒，1.5秒的时刻发送数据。
let bounces:[(Int,TimeInterval)] = [
(1, 0.2),
(2, 1),
(3, 1.2),
(4, 1.4),
]
let subject = PassthroughSubject<Int, Never>()
cancellable = subject
.throttle(for: 0.5,
scheduler: RunLoop.main,
latest: true)
.sink { index in
print ("Received index \(index) in \(Date().timeIntervalSince1970)")
}
for bounce in bounces {
DispatchQueue.main.asyncAfter(deadline: .now() + bounce.1) {
subject.send(bounce.0)
}
}
delay
能够让pipline在收到publisher发送的数据后，等待一定的时长，然后再发送数据到下游。
measureInterval
能够记录publisher发送数据的间隔时间。
以下图为例，当publisher发送数据0时，我们获得的时间间隔大约 0.2秒，发送数据1时，时间间隔大约为1.3秒，measureInterval返回的数据的类型是SchedulerTimeType.Stride,它表示两者之间的距离。
注意，时间间隔不是严格准确的，存在一定范围的偏差。
let bounces:[(Int,TimeInterval)] = [
(0, 0.2),
(1, 1.5)
]
let subject = PassthroughSubject<Int, Never>()
cancellable = subject
.measureInterval(using: RunLoop.main)
.sink { print($0) }
for bounce in bounces {
DispatchQueue.main.asyncAfter(deadline: .now() + bounce.1) {
subject.send(bounce.0)
}
}
// Output:
// Stride(magnitude: 0.25349903106689453)
// Stride(magnitude: 1.2467479705810547)
timeout
用于设置pipline的超时时间，通常以秒为单位。
enum MyError: Error {
case timeout
}
let subject = PassthroughSubject<Int, Never>()
cancellable = subject
.setFailureType(to: MyError.self)
.timeout(.seconds(1),
scheduler: RunLoop.main,
customError: {
MyError.timeout
})
.sink(receiveCompletion: { print($0) }, receiveValue: { print($0) })
DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) {
subject.send(1)
}
当发生超时的时候，customError就会调用，然后返回一个错误。
它返回的错误类型跟上游publisher返回的错误类型需保持一致，上边的代码中，如果我们想要返回我们自定义的错误类型，就要使用.setFailureType(to: MyError.self)把PassthroughSubject<Int, Never>()的Never错误类型设置成MyError。
如果指定了customError，则pipline返回该闭包中的错误，如果没有指定，pipline就会正常结束。
