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就会正常结束。

Combine 时间控制