Como posso criar um observável com atraso

Questão

Para fins de teste, estou criando Observableobjetos que substituem o observável que seria retornado por uma chamada real de http com Http.

Meu observável é criado com o seguinte código:

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

A questão é que este observável emite imediatamente. Existe uma maneira de adicionar um atraso personalizado à sua emissão?

Track

Eu tentei isso:

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

Mas não parece funcionar.

Usando as seguintes importações:

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

Experimente isto:

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

ATUALIZAÇÃO: RXJS 6

A solução acima realmente não funciona mais nas versões mais recentes do RXJS (e do angular, por exemplo).

Portanto, o cenário é que tenho uma série de itens para verificar com uma API. A API aceita apenas um único item e não quero encerrar a API enviando todas as solicitações de uma vez. Portanto, preciso de uma liberação cronometrada de itens no fluxo Observável com um pequeno atraso no meio.

Use as seguintes importações:

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

Em seguida, use o seguinte código:

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

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

Basicamente, ele cria um novo Observable 'atrasado' para cada item em sua matriz. Provavelmente existem muitas outras maneiras de fazer isso, mas funcionou bem para mim e está em conformidade com o 'novo' formato RXJS.

No RxJS 5+, você pode fazer assim

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

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

Em RxJS 6+

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

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

Se você quiser atrasar cada valor emitido, tente

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

O que você quer é um cronômetro:

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

É um pouco tarde para responder ... mas no caso de alguém voltar a esta questão procurando uma resposta

'atraso' é propriedade (função) de um observável

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

Isso funcionou para mim ...

import * as Rx from 'rxjs/Rx';

Devemos adicionar a importação acima para fazer o código de sopro funcionar

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

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