Jak mogę utworzyć obserwowalne z opóźnieniem

Pytanie

Do celów testowych tworzę Observableobiekty, które zastępują obserwowalne, które byłyby zwracane przez rzeczywiste wywołanie http z Http.

Moje obserwowalne jest tworzone za pomocą następującego kodu:

fakeObservable = Observable.create(obs => {
  obs.next([1, 2, 3]);
  obs.complete();
});

Rzecz w tym, że to obserwowalne emituje natychmiast. Czy istnieje sposób na dodanie niestandardowego opóźnienia do jego emisji?

Tor

Próbowałem tego:

fakeObservable = Observable.create(obs => {
  setTimeout(() => {
    obs.next([1, 2, 3]);
    obs.complete();
  }, 100);
});

Ale to nie działa.

Korzystając z następujących importów:

import {Observable} from 'rxjs/Observable';
import 'rxjs/add/observable/of';
import 'rxjs/add/operator/delay';

Spróbuj tego:

let fakeResponse = [1,2,3];
let delayedObservable = Observable.of(fakeResponse).delay(5000);
delayedObservable.subscribe(data => console.log(data));

AKTUALIZACJA: RXJS 6

Powyższe rozwiązanie tak naprawdę już nie działa w nowszych wersjach RXJS (i np. Angular).

Tak więc scenariusz jest taki, że mam tablicę elementów do sprawdzenia za pomocą interfejsu API. API akceptuje tylko jeden element i nie chcę go zabijać, wysyłając wszystkie żądania naraz. Więc potrzebuję czasowego wydania elementów w strumieniu Observable z niewielkim opóźnieniem między nimi.

Użyj następujących importów:

import { from, of } from 'rxjs';
import { delay } from 'rxjs/internal/operators';
import { concatMap } from 'rxjs/internal/operators';

Następnie użyj następującego kodu:

const myArray = [1,2,3,4];

from(myArray).pipe(
        concatMap( item => of(item).pipe ( delay( 1000 ) ))
    ).subscribe ( timedItem => {
        console.log(timedItem)
    });

Zasadniczo tworzy nowe „opóźnione” obserwowalne dla każdego elementu w tablicy. Prawdopodobnie jest na to wiele innych sposobów, ale to zadziałało dobrze i jest zgodne z „nowym” formatem RXJS.

W RxJS 5+ możesz to zrobić w ten sposób

import { Observable } from "rxjs/Observable";
import { of } from "rxjs/observable/of";
import { delay } from "rxjs/operators";

fakeObservable = of('dummy').pipe(delay(5000));

W RxJS 6+

import { of } from "rxjs";
import { delay } from "rxjs/operators";

fakeObservable = of('dummy').pipe(delay(5000));

Jeśli chcesz opóźnić każdą emitowaną wartość, spróbuj

from([1, 2, 3]).pipe(concatMap(item => of(item).pipe(delay(1000))));

To, czego chcesz, to minutnik:

// RxJS v6+
import { timer } from 'rxjs';

//emit [1, 2, 3] after 1 second.
const source = timer(1000).map(([1, 2, 3]);
//output: [1, 2, 3]
const subscribe = source.subscribe(val => console.log(val));

Trochę za późno na odpowiedź ... ale na wszelki wypadek może ktoś wróci do tego pytania w poszukiwaniu odpowiedzi

„opóźnienie” jest właściwością (funkcją) obserwowalnego

fakeObservable = Observable.create(obs => {
  obs.next([1, 2, 3]);
  obs.complete();
}).delay(3000);

To zadziałało dla mnie ...

import * as Rx from 'rxjs/Rx';

Powinniśmy dodać powyższy import, aby kod Blow działał

Let obs = Rx.Observable
    .interval(1000).take(3);

obs.subscribe(value => console.log('Subscriber: ' + value));