Wie kann ich ein Observable mit einer Verzögerung erstellen?

Frage

Zu Testzwecken erstelle ich ObservableObjekte, die das Observable ersetzen, durch das ein tatsächlicher http-Aufruf zurückgegeben wird Http.

Mein Observable wird mit folgendem Code erstellt:

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

Die Sache ist, dieses beobachtbare strahlt sofort aus. Gibt es eine Möglichkeit, der Emission eine benutzerdefinierte Verzögerung hinzuzufügen?

Spur

Ich habe es versucht:

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

Aber es scheint nicht zu funktionieren.

Verwenden der folgenden Importe:

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

Versuche dies:

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

UPDATE: RXJS 6

Die obige Lösung funktioniert in neueren Versionen von RXJS (und beispielsweise von Angular) nicht mehr wirklich.

Das Szenario ist also, dass ich eine Reihe von Elementen habe, mit denen ich eine API überprüfen kann. Die API akzeptiert nur ein einzelnes Element, und ich möchte die API nicht beenden, indem alle Anforderungen gleichzeitig gesendet werden. Daher benötige ich eine zeitgesteuerte Veröffentlichung von Elementen im Observable-Stream mit einer kleinen Verzögerung dazwischen.

Verwenden Sie die folgenden Importe:

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

Verwenden Sie dann den folgenden Code:

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

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

Grundsätzlich wird für jedes Element in Ihrem Array ein neues "verzögertes" Observable erstellt. Es gibt wahrscheinlich viele andere Möglichkeiten, dies zu tun, aber dies hat für mich gut funktioniert und entspricht dem 'neuen' RXJS-Format.

In RxJS 5+ können Sie dies so tun

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

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

In RxJS 6+

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

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

Wenn Sie jeden ausgegebenen Wert verzögern möchten, versuchen Sie es

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

Was Sie wollen, ist ein Timer:

// 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));

Es ist etwas spät zu beantworten ... aber für den Fall, dass jemand zu dieser Frage zurückkehrt und nach einer Antwort sucht

'Verzögerung' ist eine Eigenschaft (Funktion) eines Observable

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

Das hat bei mir funktioniert ...

import * as Rx from 'rxjs/Rx';

Wir sollten den obigen Import hinzufügen, damit der Blow-Code funktioniert

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

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