这一个比我想象的要简单...你所需要的只是一个简单的过滤器：

let sink = source
    .combineLatest(boundary)
    .filter { $0.1 }
    .map { $0.0 }

换句话说：

$value
    .dropFirst()
    .removeDuplicates()
    .trim()
    .filter { $0.contains("@") && $0.contains(".") }
    .combineLatest(boundary)
    .filter { $0.1 }
    .map { $0.0 }
    .debounce(for: 1, scheduler: RunLoop.main)
    .flatMap { value in
        Future { [weak self] promise in
            self?.loading = true
            Task {
                Firebase.validate(email: value) { error in
                    self?.loading = false
                    promise(.success(error != nil ? nil : value))
                }
            }
        }
    }
    .eraseToAnyPublisher()

为了不使事情过于复杂，我将展示一个如何实现条件去抖动的最小示例。

更新：

如果你想要一个100%被动的方法，你可以这样做：

var subscription: AnyCancellable

subscription = $value
    .map { val in
        if <condition> {
            Just(val)
                .debounce(for: 1, scheduler: RunLoop.main)
                .eraseToAnyPublisher()
        } else {
            Just(val)
                .eraseToAnyPublisher()
        }
    }
    .switchToLatest() // You might not need this but most probably you do
    .sink {
      // Do whatever you need
    }

在这里，我们根据条件将一个发布者转换为另一个发布者，然后使用.switchToLatest()跳转到最新的发布者，丢弃之前的发布者。

原始答案：

这种方法不是完全被动的（还没有使用.debounce方法），但它可以完成任务：

var timer: Timer?
var subscription: AnyCancellable

subscription = $value
    .sink {
        // Invalidating timer before condition check to not let it
        // trigger the debounced function after the `value` has changed
        timer?.invalidate()

        if <condition> {
            timer = Timer.scheduledTimer(
                 withTimeInterval: 0.5,
                 repeats: false
            ) { _ in
                // Do the stuff you need with debounce
            }
        } else {
            // Do the stuff you need without debounce
        }
    }