почему CONCAT никогда() в rxswift

Question

func signup(_ username: String, password: String) -> Observable<Bool> { 
    // this is also just a mock 
    let signupResult = arc4random() % 5 == 0 ? false : true 
    return Observable.just(signupResult) 
     .concat(Observable.never()) 
     .throttle(0.4, scheduler: MainScheduler.instance) 
     .take(1) 
} 

Я вижу некоторый код в RxSwift, но я не мог понять, почему нужно concat(Observable.never())

Answer 1

Я осмысление этого самого, поэтому возьмите его с зерном соли :)

• Observable.just Издает значение один раз и немедленно завершается; это практически не требует времени;
• .throttle(0.4, scheduler: MainScheduler.instance) вводит время в последовательность, с + 0.4 сек, чтобы определить значения для возврата, и
• concat(Observable.never()) делает входную последовательность затянувшейся так throttle что-то делать в первую очередь.

Теперь return Observable.just(signupResult) будет достаточным для реализации этой функции. Для чего лучше всего?

Другие три оператора приводят к задержке. Поскольку конкатенированный Observable бесконечен, throttle будет ждать не менее 0,4 секунды, чтобы определить, какое значение испускать для первого дросселируемого «куска». take(1) затем завершает последовательность после того, как первое значение испускается после 0.4 сек

Ко мне, это, кажется, очень трудоемкий способ реализовать отложенный ответ :)

Answer 2

Это просто пример. Fui, never создать Observable, который не выделяет никаких предметов и не прекращает (описание от official documentation)

Answer 3

Ответ от @ctietze кажется правильным. Но после проведения теста я понимаю, что throttle убивает всю концепцию. В основном throttle вернет значение сразу после наблюдаемого старта. Это означает, что он не будет ждать, пока 0.4s не испустит первое значение.

func testWithThrottle() -> Observable<Int> { 
     return 
      Observable.just(7) // 1 
       .concat(Observable.never()) // 2 
       .throttle(3.0, scheduler: Schedulers.background) // 3 
       .take(1) // 4 

     // 1. -7--|-> 
     // 2. -7-------------------------------> 
     // 3. -7-------------------------------> 
     // 4. -7--|-> 
} 

... 

print("[\(Date())] Start!") 
testWithThrottle().subscribe({ (event) in 
    print("[\(Date())] event: \(event)") 
}).addDisposableTo(disposeBag) 
print("[\(Date())] End!") 

... 

[2017-06-03 03:14:00 +0000] Start! 
[2017-06-03 03:14:00 +0000] event: next(7) 
[2017-06-03 03:14:00 +0000] event: completed 
[2017-06-03 03:14:00 +0000] End! 

ТАК, какое решение? Легко, вместо этого вам нужно использовать debounce.

func testWithDebounce() -> Observable<String> { 
     return 
      Observable.of("A") // 1 
       .concat(Observable.never()) // 2 
       .debounce(3.0, scheduler: Schedulers.background) // 3 
       .take(1) // 4 

     // 1. -A-|-> 
     // 2. -A------------------------------> 
     // 3. ---------------A----------------> 
     // 4. ---------------A-|-> 
} 

... 

[2017-06-03 03:24:21 +0000] Start Thrrotle! 
[2017-06-03 03:24:21 +0000] Finish Thrrotle! 
[2017-06-03 03:24:24 +0000] event: next(A) 
[2017-06-03 03:24:24 +0000] event: completed