warum concat nie() in 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) 
} 

Ich sehe einige Code in RxSwift, aber ich konnte nicht verstehen, warum zu concat(Observable.never())

Answer 1

Ich mache Sinn für diese selbst, so nehmen Sie es mit einem Körnchen Salz :)

• Observable.just aussendet der Wert einmal und schließt sofort ab; es dauert praktisch keine Zeit;
• .throttle(0.4, scheduler: MainScheduler.instance) führt Zeit in die Sequenz, 0,4s + nehmen den Wert zu bestimmen, zurückzukehren, und
• concat(Observable.never()) macht die Eingangssequenz mit langer Laufzeit, so hat throttle etwas in erster Linie zu tun.

Jetzt würde return Observable.just(signupResult) ausreichen, um diese Funktion zu implementieren. Wofür ist der Rest gut?

Die anderen drei Operatoren führen zu einer Verzögerung. Da das verkettete Observable niemals endet, wartet throttle mindestens 0,4 Sekunden, um zu bestimmen, welcher Wert für den ersten gedrosselten "Chunk" ausgegeben werden soll. take(1) vervollständigt dann die Sequenz, sobald der erste Wert nach 0,4s

Für mich emittiert wird, scheint dies ein sehr mühsamer Weg, um eine verzögerte Antwort :)

Answer 2

brauchen Dies ist nur Beispiel. FUI, never eine beobachtbare erstellen, die keine Artikel abgibt und nicht terminiert (Beschreibung von official documentation)

Answer 3

Die Antwort von @ctietze scheint richtig zu implementieren. Aber nachdem ich einen Test gemacht habe, merke ich, dass throttle das ganze Konzept tötet. Grundsätzlich throttle wird den Wert direkt nach dem beobachtbaren Start zurückgeben. Das heißt, es wird nicht bis 0.4s warten, um den ersten Wert auszugeben.

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! 

SO, was ist die Lösung? Einfach, Sie müssen stattdessen debounce verwenden.

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