मैं देरी से अवलोकन कैसे कर सकता हूं

Question

सवाल

परीक्षण उद्देश्यों के लिए, मैं ऐसी Observableवस्तुओं का निर्माण कर रहा हूं जो देखने योग्य को प्रतिस्थापित करती हैं जिन्हें वास्तविक http कॉल के साथ वापस किया जाएगा Http।

मेरा अवलोकन निम्नलिखित कोड के साथ बनाया गया है:

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

बात यह है, यह अवलोकनीय तुरंत लागू होता है। क्या इसके उत्सर्जन में कस्टम विलंब को जोड़ने का कोई तरीका है?

---

धावन पथ

मैंने यह कोशिश की:

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

लेकिन यह काम नहीं लगता है।

Comments

github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/…

— Günter Zöchbauer

मैंने इसके .create(...)साथ श्रृंखला बनाने की कोशिश की .delay(1000)लेकिन यह काम नहीं किया: Observable_1.Observable.create (...)। विलंब एक फ़ंक्शन नहीं है।

— एड्रिएन ब्रुनेलैट

वास्तव में आप क्या हासिल करने की कोशिश कर रहे हैं?

— गुंटर ज़ोचबॉयर

क्या आप अवलोकनीय हैं?

— shusson

अपने स्वयं के अवलोकन के साथ Http प्रतिक्रिया देरी से नकली। @shusson हाँ, मैं जिस कक्षा का परीक्षण कर रहा हूँ, वह सेवा को कॉल कर रहा है (मैं इसका पालन करने की कोशिश कर रहा हूँ)।

— एड्रिएन ब्रुनेलैट

Answer 1

निम्नलिखित आयातों का उपयोग करना:

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

इसे इस्तेमाल करे:

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

अद्यतन: RXJS 6

उपरोक्त समाधान वास्तव में RXJS के नए संस्करणों में काम नहीं करता है (और उदाहरण के लिए कोणीय)।

तो परिदृश्य यह है कि मेरे पास एपीआई के साथ जांचने के लिए मदों की एक सरणी है। एपीआई केवल एक ही आइटम को स्वीकार करता है, और मैं एक बार में सभी अनुरोध भेजकर एपीआई को मारना नहीं चाहता। इसलिए मुझे बीच में एक छोटी सी देरी के साथ ऑब्जर्वेबल स्ट्रीम पर वस्तुओं की समयबद्ध रिलीज की आवश्यकता है।

निम्नलिखित आयातों का उपयोग करें:

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

फिर निम्नलिखित कोड का उपयोग करें:

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

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

यह मूल रूप से आपके सरणी में प्रत्येक आइटम के लिए एक नया 'विलंबित' अवलोकन योग्य बनाता है। इसे करने के कई अन्य तरीके हैं, लेकिन यह मेरे लिए ठीक है, और 'नए' आरएक्सजेएस प्रारूप का अनुपालन करता है।

Comments

टाइप 'ऑब्जर्वेबल' टाइप पर 'की प्रॉपर्टी' मौजूद नहीं है। क्या आप अपने अवलोकन को आयात करते हैं import {Observable} from 'rxjs/Observable';?

— एड्रियन ब्रुनेलैट

इस पेज से: npmjs.com/package/rxjs । मैंने कहा कि मुझे स्पष्ट रूप से आयात करना पड़ा import 'rxjs/add/observable/of';। क्या आप भी ऐसा ही करते हैं? यह अभी भी अजीब है, क्योंकि यह .delay (...) के साथ चेन नहीं करेगा और जब मैं कोशिश करता हूं तो यह एक त्रुटि दिखाता है rxjs/add/observable/delay...

— Adrien Brunelat

चाहिए of(item.pipe ( delay( 1000 ) ))जा of(item))).pipe(delay(1000)पाइप की कोशिश कर रहा सरणी मुझे त्रुटियों दे दी है

— डॉन थॉमस बॉयल

यह मेरे लिए rxjs6 के साथ काम करता है: ([1, 2, 3, 4, 5, 6, 7]) से। पाइप (concatMap (num => of (num) .pipe (विलंब (1000))))। सदस्यता (x => कंसोल.लॉग (x));

— रोबर्ट

@MikeOne के समाधान ने मेरे लिए भी काम किया। दु: ख है कि इतने सरल मामले के लिए इतना कोड आवश्यक है ...

— कोड्व

Answer 2

RxJS 5+ में आप इसे इस तरह से कर सकते हैं

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

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

RxJS में 6+

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

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

यदि आप प्रत्येक उत्सर्जित मूल्य प्रयास में देरी करना चाहते हैं

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

Comments

मेरी राय में सबसे साफ समाधान।

— 14

यह "समाधान" केवल तभी काम करता है जब आप एक आइटम का उत्सर्जन करते हैं। अवलोकन ऑपरेटर को प्रत्येक तत्व के लिए अवलोकन योग्य नहीं माना जाता है। यही कारण है कि भयानक कॉनकटैब समाधान की आवश्यकता है।

— रिक ओ'शे

@ रिकोशे, सवाल एक उत्सर्जित मूल्य के बारे में है, इसलिए यह समाधान है।

— एड्रियन बेर

इतना ताजा और इतना साफ!

— नन्ह

मैंने अपने उत्तर को कई देरी के लिए अद्यतन किया है @ रिको'शिआ

— एड्रियन बेर

Answer 3

आप जो चाहते हैं वह एक टाइमर है:

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

Comments

अच्छा जवाब, सदस्यता समाप्त करने के लिए मत भूलना

— सामी

Answer 4

इसका उत्तर देने में बहुत देर हो चुकी है ... लेकिन हो सकता है कि कोई व्यक्ति इस प्रश्न का उत्तर देने के लिए वापस लौटे

'देरी' एक ऑब्जर्वेबल की संपत्ति (कार्य) है

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

यह मेरे लिए काम किया ...

Comments

import 'rxjs/add/operator/delay' अब यह त्रुटि देता है: मॉड्यूल नहीं मिला: त्रुटि: 'rxjs / ऐड / ऑपरेटर / विलंब को हल नहीं कर सकता'

— 87

जब यह काफी वास्तविक है तो आप इसे अश्लील क्यों कहेंगे? :)

— लैगोमैन

Answer 5

import * as Rx from 'rxjs/Rx';

हमें ब्लो कोड को काम करने के लिए उपरोक्त आयात को जोड़ना चाहिए

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

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