बीच क्या अंतर है Promise
औरObservable
कोणीय में ?
प्रत्येक पर एक उदाहरण दोनों मामलों को समझने में मददगार होगा। किस परिदृश्य में हम प्रत्येक मामले का उपयोग कर सकते हैं?
बीच क्या अंतर है Promise
औरObservable
कोणीय में ?
प्रत्येक पर एक उदाहरण दोनों मामलों को समझने में मददगार होगा। किस परिदृश्य में हम प्रत्येक मामले का उपयोग कर सकते हैं?
जवाबों:
वादा
एक एकल घटना कोPromise
संभालता है है जब एक async आपरेशन पूर्ण करता है या विफल रहता है।
नोट: वहाँ Promise
पुस्तकालय हैं जो रद्द करने का समर्थन करते हैं, लेकिन ES6Promise
अब तक ऐसा नहीं करता है।
नमूदार
एक Observable
जैसा हैStream
(कई भाषाओं में) और शून्य या अधिक घटनाओं जहां कॉलबैक प्रत्येक घटना के लिए कहा जाता है पारित करने के लिए अनुमति देता है।
अक्सर इसे Observable
अधिक पसंद किया जाता है Promise
क्योंकि यह Promise
और अधिक की सुविधाएँ प्रदान करता है । इसके साथ Observable
यदि आप 0, 1, या कई ईवेंट को हैंडल करना चाहते हैं तो कोई बात नहीं। आप प्रत्येक मामले में एक ही एपीआई का उपयोग कर सकते हैं।
Observable
निरस्तPromise
होने का भी फायदा है । एक सर्वर या कुछ अन्य महंगा async संचालन के लिए एक HTTP अनुरोध का परिणाम अब कोई आवश्यकता नहीं है, तो एक की है, जबकि एक, सदस्यता को रद्द करने की अनुमति देता है तब भी जब आप अधिसूचना की जरूरत नहीं है अंततः सफलता या विफल कॉलबैक कॉल करेंगे या परिणाम यह अब प्रदान करता है।Subscription
Observable
Promise
नमूदार प्रदान करता है ऑपरेटरों की तरह map
, forEach
, reduce
, ... एक सरणी के समान
वहाँ भी शक्तिशाली ऑपरेटरों की तरह हैं retry()
, या replay()
, ... कि अक्सर काफी काम कर रहे हैं।
Promise
, साथ में async
/ await
आपके कोड को फिर से सपाट बना देता है! अधिकांश स्थितियों में, और ऐसी परियोजनाओं में जो रॉकेट साइंस के साथ सौदा नहीं करते हैं, उन भयानक नेस्टेड फ़ंक्शन को अनावश्यक रूप से जटिल श्रृंखलाओं के साथ लिखने की आवश्यकता नहीं है। आप किसी भी बायलरप्लेट के बिना वास्तविक मानव-पठनीय फ्लैट कोड को ट्रांसपॉयलर के साथ async
/ await
आज उपयोग कर सकते हैं TypeScript
और लिख सकते हैं rxjs
। आपको शायद अभी भी rxjs
कभी-कभी कुछ चुनिंदा स्थितियों में ज़रूरत होगी , क्योंकि इसमें वास्तव में बहुत सी चीज़ें हैं।
दोनों Promises
और Observables
हमें अमूर्तता प्रदान करते हैं जो हमारे अनुप्रयोगों की अतुल्यकालिक प्रकृति से निपटने में हमारी मदद करते हैं। उनके बीच का अंतर @ गुंटर और @ रेलू द्वारा स्पष्ट रूप से इंगित किया गया था।
चूंकि एक कोड स्निपेट एक हजार शब्दों के लायक है, उन्हें आसान समझने के लिए नीचे दिए गए उदाहरण के माध्यम से जाने दें।
धन्यवाद @Christoph Burgdorf भयानक लेख के लिए
कोणीय HTTP से निपटने के वादे के बजाय Rx.js वेधशाला का उपयोग करता है।
मान लीजिए कि आप एक खोज फ़ंक्शन का निर्माण कर रहे हैं, जो आपको लिखते ही आपको तुरंत परिणाम दिखाना चाहिए। ध्वनि परिचित है लेकिन उस कार्य के साथ बहुत सारी चुनौतियाँ हैं।
HTTP
अनुरोधों के तूफान के साथ बाढ़ देना चाहिए । मूल रूप से, हम केवल इसे हिट करना चाहते हैं, जब उपयोगकर्ता ने प्रत्येक कीस्ट्रोक के साथ टाइप करना बंद कर दिया है।डेमो में बस दो फाइलें होंगी: app.ts
और wikipedia-service.ts
। एक वास्तविक दुनिया के परिदृश्य में, हम सबसे अधिक संभावना है कि चीजों को आगे विभाजित करेंगे, हालांकि।
नीचे वादा-आधारित कार्यान्वयन है जो वर्णित किनारे के मामलों में से किसी को भी संभाल नहीं करता है।
wikipedia-service.ts
import { Injectable } from '@angular/core';
import { URLSearchParams, Jsonp } from '@angular/http';
@Injectable()
export class WikipediaService {
constructor(private jsonp: Jsonp) {}
search (term: string) {
var search = new URLSearchParams()
search.set('action', 'opensearch');
search.set('search', term);
search.set('format', 'json');
return this.jsonp
.get('http://en.wikipedia.org/w/api.php?callback=JSONP_CALLBACK', { search })
.toPromise()
.then((response) => response.json()[1]);
}
}
हम दिए गए खोज शब्द के साथ विकिपीडिया एपीआई के खिलाफ अनुरोध Jsonp
करने के लिए सेवा को इंजेक्ट कर रहे हैं । सूचना है कि हम फोन आदेश में एक से प्राप्त करने के लिए एक करने के लिए । आखिरकार हमारी खोज विधि के रिटर्न प्रकार के रूप में समाप्त होता है ।GET
toPromise
Observable<Response>
Promise<Response>
Promise<Array<string>>
app.ts
// check the plnkr for the full list of imports
import {...} from '...';
@Component({
selector: 'my-app',
template: `
<div>
<h2>Wikipedia Search</h2>
<input #term type="text" (keyup)="search(term.value)">
<ul>
<li *ngFor="let item of items">{{item}}</li>
</ul>
</div>
`
})
export class AppComponent {
items: Array<string>;
constructor(private wikipediaService: WikipediaService) {}
search(term) {
this.wikipediaService.search(term)
.then(items => this.items = items);
}
}
यहाँ बहुत आश्चर्य की बात नहीं है। हम अपने इंजेक्षन करते हैं WikipediaService
और इसे खोज विधि के माध्यम से कार्यक्षमता को उजागर करते हैं। टेम्पलेट बस कीप और कॉल के लिए बांधता है search(term.value)
।
हम वादे के नतीजे को उजागर करते हैं कि विकिपीडिया सेवा की खोज पद्धति वापस लौटती है और इसे टेम्पलेट के सरल एरे के रूप में उजागर करती है ताकि हम *ngFor
इसके माध्यम से लूप कर सकें और हमारे लिए एक सूची तैयार कर सकें।
प्लंकर पर वादा आधारित कार्यान्वयन का उदाहरण देखें
जहां वेधशालाएं वास्तव में चमकती हैं
आइए प्रत्येक कोडस्ट्रोक के साथ समापन बिंदु को हथौड़ा न करने के लिए अपना कोड बदलें लेकिन इसके बजाय केवल एक अनुरोध भेजें जब उपयोगकर्ता ने 400 एमएस के लिए लिखना बंद कर दिया हो
ऐसी महाशक्तियों का अनावरण करने के लिए, हमें सबसे पहले एक Observable<string>
खोज शब्द की आवश्यकता होती है, जो उपयोगकर्ता प्रकारों की खोज करता है। बजाय कीपर घटना के मैन्युअल रूप से बाध्य होने के कारण, हम कोणीय के formControl
निर्देश का लाभ उठा सकते हैं । इस निर्देश का उपयोग करने के लिए, हमें सबसे पहले ReactiveFormsModule
अपने एप्लिकेशन मॉड्यूल में आयात करना होगा ।
app.ts
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { JsonpModule } from '@angular/http';
import { ReactiveFormsModule } from '@angular/forms';
@NgModule({
imports: [BrowserModule, JsonpModule, ReactiveFormsModule]
declarations: [AppComponent],
bootstrap: [AppComponent]
})
export class AppModule {}
एक बार आयात होने के बाद, हम अपने टेम्पलेट के भीतर से फॉर्मकंट्रोल का उपयोग कर सकते हैं और इसे "टर्म" नाम पर सेट कर सकते हैं।
<input type="text" [formControl]="term"/>
हमारे घटक में, हम का एक उदाहरण बनाने FormControl
से @angular/form
और हमारे घटक पर नाम अवधि के तहत एक क्षेत्र के रूप में यह बेनकाब।
पर्दे के पीछे, शब्द स्वचालित Observable<string>
रूप से एक संपत्ति के रूप में उजागर करता है valueChanges
जिसे हम सदस्यता ले सकते हैं। अब जब हमारे पास एक है Observable<string>
, तो उपयोगकर्ता इनपुट पर काबू पाना debounceTime(400)
हमारे लिए कॉल करने जितना आसान है Observable
। यह एक नया रिटर्न Observable<string>
देगा जो केवल एक नए मूल्य का उत्सर्जन करेगा जब 400ms के लिए नए मान नहीं आ रहे हैं।
export class App {
items: Array<string>;
term = new FormControl();
constructor(private wikipediaService: WikipediaService) {
this.term.valueChanges
.debounceTime(400) // wait for 400ms pause in events
.distinctUntilChanged() // ignore if next search term is same as previous
.subscribe(term => this.wikipediaService.search(term).then(items => this.items = items));
}
}
यह एक खोज शब्द के लिए एक और अनुरोध भेजने के लिए संसाधनों की बर्बादी होगी जो हमारे ऐप पहले से ही परिणाम दिखाता है। वांछित व्यवहार को प्राप्त करने के लिए हमें बस इतना करना है कि हम कॉल करने के distinctUntilChanged
बाद ऑपरेटर को कॉल करेंdebounceTime(400)
प्लंकर पर अवलोकन योग्य कार्यान्वयन का उदाहरण देखें
आदेश-प्रतिसाद प्रतिक्रियाओं से निपटने के लिए, कृपया पूरा लेख देखें http://blog.thoughtram.io/angular/2016/01/06/taking- नुकसान- of-observables-in- angular2.html
जहां तक मैं एंगुलर में Http का उपयोग कर रहा हूं, मैं मानता हूं कि सामान्य उपयोग के मामलों में ऑब्जर्वेबल ओवर प्रॉमिस का उपयोग करते समय बहुत अंतर नहीं है। व्यवहार में यहां कोई भी लाभ वास्तव में प्रासंगिक नहीं है। आशा है कि मैं भविष्य में कुछ उन्नत उपयोग मामला देख सकता हूँ :)
और अधिक जानें
दोनों वादे और वेधशालाएँ हमें जावास्क्रिप्ट में अतुल्यकालिक कार्यात्मकताओं के साथ काम करने में मदद करेंगे । वे कई मामलों में बहुत समान हैं, हालांकि, दोनों के बीच अभी भी कुछ मतभेद हैं, वादे ऐसे मूल्य asynchronous
हैं जो http कॉल जैसे तरीकों से हल होंगे । दूसरी ओर, वेधशालाएँ अतुल्यकालिक घटनाओं के अनुक्रम से निपटती हैं । उनके बीच मुख्य अंतर नीचे सूचीबद्ध हैं:
वादा:
नमूदार:
इसके अलावा, मैंने अंतर दिखाने के लिए आपके लिए नीचे दी गई चित्रमय छवि बनाई है:
Promise
वादे को रद्द करने का तरीका गलत है। Promise
की जिम्मेदारी यह एक async संगत रास्ते में ही संभाल सफलता या विफलता के लिए .. आप एक HTTP अनुरोध आप अनुरोध, नहीं वादा रद्द रद्द, और या तो रद्द कर पूरा या वादा अस्वीकार का परिणाम बनाना चाहते हैं। jsfiddle.net/greggman/ea0yhd4p
वादे
observables
एक ऑपरेटर पुन: प्रयास भी करता है, तो हम कुछ शर्तों के आधार पर नमूदार पुन: प्रयास करने की जरूरत है, जब भी जरूरत पुन: प्रयास किया जा सकता है retryWhen इस्तेमाल किया जा सकता।
नोट : उनके इंटरएक्टिव आरेखों के साथ ऑपरेटरों की एक सूची यहां RxMarbles.com पर उपलब्ध है
जवाबों में वेधशालाओं की कमी है। वादे ES7 async / प्रतीक्षा कार्यों का उपयोग करने की अनुमति देते हैं। उनके साथ आप अतुल्यकालिक कोड लिख सकते हैं जैसे यह एक सिंक्रोनस फ़ंक्शन कॉल होगा, इसलिए आपको अब कॉलबैक की आवश्यकता नहीं है। वेधशालाओं के ऐसा करने की एकमात्र संभावना, उन्हें वादों में परिवर्तित करना है। लेकिन जब आप उन्हें वादा करने के लिए परिवर्तित करते हैं, तो आपके पास केवल एक वापसी मूल्य हो सकता है:
async function getData(){
const data = await observable.first().toPromise();
//do stuff with 'data' (no callback function needed)
}
वादे और वेधशालाएँ दोनों ही अतुल्यकालिक कॉल को संभालते हैं।
यहाँ उन दोनों के बीच अंतर हैं:
नमूदार
वादा
एक बार में केवल एक मूल्य का उत्सर्जन करता है
.Thatch और .catch के बिना सेवाओं को कॉल करता है
रद्द नहीं किया जा सकता
कोई भी ऑपरेटर प्रदान नहीं करता है
भले ही यह उत्तर देर से आया हो, मैंने नीचे दिए मतभेदों को संक्षेप में प्रस्तुत किया है,
नमूदार:
function
जो लेता है an observer
और वापस लौटता है function Observer: an object with next, error.
subscribe/unsubscribe
अपनी डेटा स्ट्रीम को अनुमति देता है , प्रेक्षक के लिए अगला मान उत्सर्ग करता है, notify
पर्यवेक्षक के बारे में errors
और पर्यवेक्षक को सूचित करता हैstream completion
function to handle next value
, त्रुटियों और धारा के अंत (ui घटनाओं, http प्रतिक्रियाओं, वेब सॉकेट के साथ डेटा) प्रदान करता है।multiple values
समय के साथ काम करता हैcancel-able/retry-able
जैसे ऑपरेटरों का समर्थन करता है map,filter,reduce
।Observable.create()
- वे अवलोकन योग्य जो उन तरीकों को लागू कर सकता है - - Observer Observable.from()
एक सरणी को परिवर्तित करता है या उसमें पुनरावृत्ति करता है - Observable Observable.fromEvent()
- एक घटना को ऑब्जर्वेबल में Observable.fromPromise()
परिवर्तित करता है - - एक प्रॉमिस को ऑब्जर्वेबल में कनवर्ट करता है - Observable.range()
- विशेषांक में पूर्णांकों के अनुक्रम को लौटाता है।वादा :
एक वादा एक कार्य का प्रतिनिधित्व करता है जो भविष्य में समाप्त होगा;
वादे बन जाते हैं resolved by a value
;
वादे अपवादों से खारिज हो जाते हैं;
नहीं cancellable
और यह लौटता हैa single value
एक वादा एक समारोह का पर्दाफाश करता है (then)
-तब एक नया रिटर्न promise
;
-उसके लिए सभी attachment
के आधार पर क्रियान्वित किया जाएगा
state
;
- handlers
में guaranteed
निष्पादित करने के लिए कर रहे हैं order attached
;
मैंने अभी एक ऐसे मुद्दे से निपटा है जहां वादे सबसे अच्छा समाधान थे, और मैं इसे यहाँ किसी के लिए साझा कर रहा हूँ इस घटना में यह सवाल उपयोगी है (यह ठीक वही जवाब था जो मैं पहले देख रहा था):
एक Angular2 परियोजना में मेरे पास एक सेवा है जो कुछ मापदंडों को लेती है और एक फॉर्म पर ड्रॉप डाउन मेनू को पॉप्युलेट करने के लिए एक मूल्य सूची देता है। जब प्रपत्र घटक प्रारंभ हो जाता है, तो मुझे कई ड्रॉपडाउन मेनू की एक संख्या को परिभाषित करने के लिए विभिन्न मापदंडों के साथ एक ही सेवा को कई बार कॉल करने की आवश्यकता होती है, हालांकि अगर मैं सेवा को कॉल करने के लिए सभी चर को कतार में रखता हूं, तो केवल अंतिम एक सफल होता है और बाकी त्रुटि। बाहर। डेटाबेस से लाने वाली सेवा एक समय में केवल एक अनुरोध को संभाल सकती है।
सभी ड्रॉपडाउन मेनू वेरिएबल्स को सफलतापूर्वक पॉप्युलेट करने का एकमात्र तरीका सेवा को इस तरह से कॉल करना था जो एक नए अनुरोध को अंतिम अनुरोध पूरा होने तक संसाधित होने से रोकता था, और प्रोमिस / .then तंत्र ने समस्या को अच्छी तरह से हल किया।
fetchValueList(listCode): Promise<any> {
return this.dataSvc.getValueList(listCode, this.stateSvc.currentContext, this.stateSvc.currentLanguageCode)
.map(response => response.json())
.toPromise();
}
initializeDropDowns() {
this.fetchValueList('First-Val-List')
.then(data => {
this.firstValList = data;
return this.fetchValueList('Second-Val-List')
}).then(data => {
this.secondValList = data;
return this.fetchValueList('Third-Val-List')
}).then(data => {
this.thirdValList = data;
}) }
मैंने घटक में कार्यों को परिभाषित किया, और फिर ngOnInit में initializeDropDowns () कहा।
FetchValueList फ़ंक्शन एक वादा लौटाता है, इसलिए पहला कॉल पहली सूची को पास करता है और जब वादा होता है, तो वापसी मान .then ब्लॉक में डेटा वैरिएबल में होता है, जहाँ हम इसे इस .filValList वैरिएबल को असाइन कर सकते हैं। चूंकि फ़ंक्शन ने डेटा वापस कर दिया है, हम जानते हैं कि सेवा समाप्त हो गई है और दूसरी लिस्टकोड के साथ फिर से कॉल करना सुरक्षित है। रिटर्न वैल्यू अगले .then ब्लॉक में डेटा वैरिएबल में है और हम इसे इस .secondValLive वैरिएबल पर असाइन करते हैं।
सभी चरों को पॉप्युलेट करने के लिए हम इसे कई बार श्रृंखलाबद्ध कर सकते हैं, और अंतिम कोड ब्लॉक पर हम केवल रिटर्न स्टेटमेंट को छोड़ देते हैं और ब्लॉक को समाप्त कर देते हैं।
यह एक बहुत ही विशिष्ट उपयोग का मामला है, जहां हमारे पास एक एकल सेवा है जिसे घटक को प्रारंभ करने के साथ कई बार कॉल करने की आवश्यकता होती है, और जहां सेवा को अपना भ्रूण पूरा करना होता है और एक मूल्य वापस करने से पहले इसे फिर से बुलाया जा सकता है, लेकिन इस मामले में, वादा / .then विधि आदर्श थी।
scan()
अनुक्रमिक वेधशालाओं की एक धारा बनाने के लिए उपयोग कर सकते हैं। हालाँकि, आपका दृष्टिकोण शायद अधिक स्पष्ट और समझने में आसान है।
मेरा मानना है कि अन्य सभी उत्तरों से आपकी शंकाएँ दूर होनी चाहिए। फिर भी, मैं बस यह जोड़ना चाहता था कि वेधशालाएं कार्यात्मक प्रोग्रामिंग पर आधारित हैं, और मुझे बहुत उपयोगी कार्य मिलते हैं जो इसके साथ आते हैं जैसे कि नक्शा, फ्लैटमैप, कम, ज़िप। वेब विशेष रूप से तब प्राप्त होता है जब यह एपीआई अनुरोधों पर निर्भर करता है एक क्रूर सुधार है।
मैं इस दस्तावेज की दृढ़ता से अनुशंसा करता हूं , क्योंकि यह रिएक्टिवएक्स का आधिकारिक दस्तावेज है और मुझे लगता है कि यह सबसे स्पष्ट है।
यदि आप वेधशाला में जाना चाहते हैं, तो मैं इस 3-भाग पोस्ट का सुझाव दूंगा : http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/
यद्यपि यह RxJava के लिए है, अवधारणाएं समान हैं, और यह वास्तव में अच्छी तरह से समझाया गया है। रिएक्टिवएक्स प्रलेखन में, आपके पास प्रत्येक फ़ंक्शन के लिए समतुल्य है। आपको RxJS की तलाश करनी चाहिए।
आप हमेशा एसिंक्रोनस व्यवहार से निपटने के लिए एक अवलोकन का उपयोग कर सकते हैं क्योंकि एक अवलोकन योग्य में सभी कार्यक्षमता होती है जो एक वादा प्रदान करता है (+ अतिरिक्त)। हालांकि, कभी-कभी यह अतिरिक्त कार्यक्षमता कि वेधशालाओं की पेशकश की आवश्यकता नहीं होती है। फिर इसका उपयोग करने के लिए एक पुस्तकालय आयात करने के लिए यह अतिरिक्त ओवरहेड होगा।
वादों का उपयोग तब करें जब आपके पास एक एकल ऑपरेशन हो, जिसमें आप परिणाम को संसाधित करना चाहते हैं। उदाहरण के लिए:
var promise = new Promise((resolve, reject) => {
// do something once, possibly async
// code inside the Promise constructor callback is getting executed synchronously
if (/* everything turned out fine */) {
resolve("Stuff worked!");
}
else {
reject(Error("It broke"));
}
});
//after the promise is resolved or rejected we can call .then or .catch method on it
promise.then((val) => console.log(val)) // logs the resolve argument
.catch((val) => console.log(val)); // logs the reject argument
तो एक वादा कुछ कोड निष्पादित करता है जहां यह या तो हल करता है या अस्वीकार करता है। यदि या तो हल या अस्वीकार किया जाता है, तो वादा एक लंबित राज्य से या तो एक हल या अस्वीकार किए गए राज्य में चला जाता है । जब वादा राज्य हल हो then()
जाता है तो विधि कहा जाता है। जब वादा राज्य अस्वीकार कर दिया जाता है, तोcatch()
विधि कहा जाता है।
समय के साथ एक स्ट्रीम (डेटा का) होने पर वेधशालाओं का उपयोग करें जिन्हें आपको संभालने की आवश्यकता है। एक धारा डेटा तत्वों का एक क्रम है जो समय के साथ उपलब्ध कराया जा रहा है । धाराओं के उदाहरण हैं:
ऑब्जर्वेबल में ही निर्दिष्ट किया जाता है कि अगली घटना कब हुई, जब कोई त्रुटि होती है , या जब अवलोकन पूरा हो जाता है । फिर हम इस अवलोकन के लिए सदस्यता ले सकते हैं, जो इसे सक्रिय करता है और इस सदस्यता में, हम 3 कॉलबैक में पारित कर सकते हैं (हमेशा सभी को पास नहीं करना पड़ता है)। सफलता के लिए एक कॉलबैक निष्पादित किया जाएगा, त्रुटि के लिए एक कॉलबैक, और पूरा होने के लिए एक कॉलबैक। उदाहरण के लिए:
const observable = Rx.Observable.create(observer => {
// create a single value and complete
observer.onNext(1);
observer.onCompleted();
});
source.subscribe(
x => console.log('onNext: %s', x), // success callback
e => console.log('onError: %s', e), // error callback
() => console.log('onCompleted') // completion callback
);
// first we log: onNext: 1
// then we log: onCompleted
अवलोकन करते समय इसे एक कॉलबैक फ़ंक्शन की आवश्यकता होती है जो एक पर्यवेक्षक को एक तर्क के रूप में आपूर्ति करता है। इस पर्यवेक्षक पर, आप तो कॉल कर सकते हैं onNext
, onCompleted
, onError
। फिर जब ऑब्जर्वेबल को सब्सक्राइब किया जाता है तो वह सब्सक्रिप्शन में पास की गई कॉलबैक को कॉल करेगा।
वादा - एकल भविष्य का मूल्य प्रदान करें। आलसी नहीं । रद्द-सक्षम नहीं। यह या तो अस्वीकार या हल होगा।
अवलोकनीय - भविष्य के कई मूल्य प्रदान करें। आलसी । रद्द करने में सक्षम। यह अन्य तरीकों को लाइव मैप, फिल्टर, कम प्रदान करता है।
const promise = new Promise(resolve => {
setTimeout(() => {
resolve("Hello from a Promise!");
}, 2000);
});
promise.then(value => console.log(value));
अब देखने योग्य उदाहरण है। यहाँ हम एक समारोह भी पास करते हैं, अवलोकनीय कार्य को संभालने के लिए एक पर्यवेक्षक को। वादे में हल के विपरीत यह निम्न विधि है और तब के स्थान पर सदस्यता।
तो दोनों async कार्य संभालता है। अब अंतर देखते हैं।
const observable = new Observable(observer => {
setTimeout(() => {
observer.next('Hello from a Observable!');
}, 2000);
});
observable.subscribe(value => console.log(value));
वादा
नमूदार
वादे और वेधशाला दोनों हमें अतुल्यकालिक संचालन से निपटने में मदद करते हैं। जब इन अतुल्यकालिक ऑपरेशन किए जाते हैं तो वे कुछ कॉलबैक कह सकते हैं।
कोणीय वेधशाला का उपयोग करता है जो HTTP से निपटने के वादे के बजाय RxJS से है
Below are some important differences in promises & Observables.
एक Async गतिविधि समाप्त या विफल होने पर एक एकल घटना का वादा करता है।
एक ऑब्जर्वेबल एक स्ट्रीम की तरह है (कई भाषाओं में) और कम से कम शून्य या अधिक घटनाओं को पारित करने की अनुमति देता है जहां हर घटना के लिए कॉलबैक की आवश्यकता होती है।
प्रॉमिस पर अक्सर ऑब्जर्वेबल को प्राथमिकता दी जाती है क्योंकि यह प्रोमिस और अधिक के हाइलाइट देता है। ऑब्जर्वेबल के साथ यह मायने नहीं रखता है कि आपको 0, 1, या विभिन्न घटनाओं को संभालने की आवश्यकता है। आप प्रत्येक मामले के लिए समान API का उपयोग कर सकते हैं।
वादा: वादा एक मूल्य का उत्सर्जन करता है
उदाहरण के लिए:
const numberPromise = new Promise((resolve) => {
resolve(5);
resolve(10);
});
numberPromise.then(value => console.log(value));
// still prints only 5
अवलोकनीय: समय की अवधि में कई मूल्यों का उत्सर्जन करता है
उदाहरण के लिए:
const numberObservable = new Observable((observer) => {
observer.next(5);
observer.next(10);
});
numberObservable.subscribe(value => console.log(value));
// prints 5 and 10
हम एक स्ट्रीम की तरह एक ऑब्जर्वेबल के बारे में सोच सकते हैं जो समय की अवधि में कई मानों का उत्सर्जन करता है और एक ही कॉलबैक फ़ंक्शन को उत्सर्जित प्रत्येक आइटम के लिए कहा जाता है ताकि हम एक ही एपीआई का उपयोग अतुल्यकालिक डेटा को संभालने के लिए कर सकें। चाहे वह डेटा एक ही मूल्य के रूप में या समय के कुछ खिंचाव पर कई मूल्यों के रूप में प्रेषित किया जाता है।
वादा:
नमूदार:
वादा एकल मूल्य का उत्सर्जन करता है जबकि ऑब्जर्वेबल कई मूल्यों का उत्सर्जन करता है। इसलिए, HTTP रिक्वेस्ट को हैंडल करते समय, प्रॉमिस उसी रिक्वेस्ट के लिए सिंगल रिस्पॉन्स को मैनेज कर सकता है, लेकिन क्या होगा अगर एक ही रिक्वेस्ट पर मल्टीपल रिस्पॉन्स हो, तो हमें ऑब्जर्वेबल का इस्तेमाल करना होगा। हां, ऑब्जर्वेबल एक ही अनुरोध के लिए कई प्रतिक्रियाओं को संभाल सकता है।
वादा
const promise = new Promise((data) =>
{ data(1);
data(2);
data(3); })
.then(element => console.log(‘Promise ‘ + element));
उत्पादन
Promise 1
नमूदार
const observable = new Observable((data) => {
data.next(1);
data.next(2);
data.next(3);
}).subscribe(element => console.log('Observable ' + element));
उत्पादन
Observable 1
Observable 2
Observable 3
नीचे वादों और वेधशालाओं में कुछ महत्वपूर्ण अंतर हैं।
वादा
नमूदार
बेहतर समझ के लिए https://stackblitz.com/edit/observable-vs-promises को देखें
मैं इस तर्क का उपयोग करने वाले बहुत से लोगों को देखता हूं कि ऑब्जर्वेबल "रद्द करने योग्य" हैं, लेकिन यह वादा "रद्द" करने के बजाय तुच्छ है।
function cancellablePromise(body) {
let resolve, reject;
const promise = new Promise((res, rej) => {
resolve = res; reject = rej;
body(resolve, reject)
})
promise.resolve = resolve;
promise.reject = reject;
return promise
}
// Example 1: Reject a promise prematurely
const p1 = cancellablePromise((resolve, reject) => {
setTimeout(() => resolve('10', 100))
})
p1.then(value => alert(value)).catch(err => console.error(err))
p1.reject(new Error('denied')) // expect an error in the console
// Example: Resolve a promise prematurely
const p2 = cancellablePromise((resolve, reject) => {
setTimeout(() => resolve('blop'), 100)
})
p2.then(value => alert(value)).catch(err => console.error(err))
p2.resolve(200) // expect an alert with 200
संक्षिप्त जवाब :
नमूदार है बेहतर , यह सब है वादे सुविधाओं के साथ साथ अतिरिक्त सुविधाओं।
लंबा जवाब:
वादे:
नमूदार:
जबकि स्वीकृत उत्तर सामान्य रूप से अच्छा है, मुझे नहीं लगता कि यह जोर देता है कि जब कोणीय घटकों के साथ काम करते हैं तो आप लगभग हमेशा एक अवलोकन का उपयोग करना चाहते हैं क्योंकि यह रद्द करने का समर्थन करता है। वादे को रद्द नहीं किया जा सकता है और भले ही आपका घटक नष्ट हो जाए। कोणीय तब तक क्षमा करने की प्रवृत्ति रखता है जब तक कि वह नहीं।
उदाहरण के लिए किसी नष्ट हुए घटक पर किसी भी मैनुअल परिवर्तन का पता लगाना अपवाद का कारण होगा:
ngOnInit() {
// promise api
this.service.getData().then(d => {
this.data = d;
this.changeDetectorRef.detectChanges();
});
// observable api
this.service.getData().pipe(takeUntil(this.unsubscribe)).subscribe((d) => {
this.data = d;
this.changeDetectorRef.detectChanges();
});
}
यदि वादा पूरा होने से पहले आपका घटक नष्ट हो जाता है, तो आपको मिल जाएगा attempt to use destroyed view
त्रुटि ।
वैकल्पिक रूप से, यदि आप टेकउंटिल के साथ वेधशालाओं का उपयोग करते हैं पैटर्न के , तो जैसे ही आपका घटक नष्ट हो जाएगा, सदस्यता रद्द हो जाएगी।
यह एक आकस्मिक उदाहरण का एक सा है, लेकिन नष्ट कर दिया गया है कि एक घटक के लिए कोड निष्पादित शायद कीड़े के लिए नेतृत्व करने के लिए जा रहा है। जब तक आप वास्तव में किसी कारण से ऐसा नहीं करना चाहते हैं: पी
ट्यूटोरियल और डॉक्स की पहली रीडिंग से जो कुछ मैंने देखा वह स्पष्ट नहीं था, यह मल्टीकास्टिंग का विचार था।
सुनिश्चित करें कि आप इस बात से अवगत हैं कि डिफ़ॉल्ट रूप से, कई सब्स्क्रिप्शन एक ऑब्जर्वेबल में कई निष्पादन को ट्रिगर करेंगे। जब तक आप एक से अधिक HTTP कॉल नहीं करेंगे तब तक एक ही HTTP कॉल के लिए कई सदस्यताएँ अवलोकन योग्य हो जाएंगी.share()
(मल्टीकास्टिंग को सक्षम करें) ।
एक वादा आपको एक समय में एक चीज से निपटने के लिए मजबूर करता है, इसके डेटा को अनचेक करें, अपवादों को संभालें, इसमें async / प्रतीक्षा जैसी ठंडी चीजों के लिए भाषा का समर्थन है, और अन्यथा बहुत नंगे हैं।
एक वेधशाला में बहुत सी घंटियाँ और सीटी होती हैं, लेकिन आपको उस शक्ति को समझने की आवश्यकता होती है जिसके साथ आप काम कर रहे हैं या इसका दुरुपयोग किया जा सकता है।
वादा:
एक Async इवेंट हैंडलर - वादा वस्तु एक अतुल्यकालिक ऑपरेशन के अंतिम समापन (या विफलता) का प्रतिनिधित्व करती है, और इसके परिणामस्वरूप मूल्य।
सिंटैक्स: नया वादा (निष्पादक);
उदाहरण के लिए:
var promise_eg = new Promise(function(resolve, reject) {
setTimeout(function() {
resolve('foo');
}, 300);
});
promise_eg.then(function(value) {
console.log(value);
// expected output: "foo"
});
console.log(promise_eg);
प्रॉमिस के बारे में: इसकी एक पाइपलाइन है, इसलिए यह केवल एक बार मूल्यों को लौटाएगा जब इसे बुलाया जाएगा। इसके एक तरह से हैंडलर को एक बार कॉल करने पर आप रद्द नहीं कर सकते। उपयोगी सिंटैक्स आप तब खेल सकते हैं, जब () और फिर ()
observables:
वेधशालाएँ समय के साथ कई मूल्यों के आलसी संग्रह हैं। यह वास्तव में async संचालन के लिए एक महान दृष्टिकोण है। यह आरएक्सजे के साथ किया जा सकता है जिसमें क्रॉस प्लेटफॉर्म समर्थन है जो कोणीय / प्रतिक्रिया आदि के साथ उपयोग कर सकता है।
स्ट्रीम लाइनर की तरह इसका कार्य। मल्टी पाइप लाइन हो सकती है। इसलिए एक बार परिभाषित करने के बाद आप कई स्थानों पर रिटर्न परिणाम प्राप्त करने के लिए सदस्यता ले सकते हैं।
सिंटेक्स: import * as Rx from "@reactivex/rxjs";
इनिट:
Rx.Observable.fromEvent(button, "click"),
Rx.Subject()
आदि
सदस्य बनना: RxLogger.getInstance();
उदाहरण के लिए:
import { range } from 'rxjs';
import { map, filter } from 'rxjs/operators';
range(1, 200).pipe(
filter(x => x % 2 === 1),
map(x => x + x)
).subscribe(x => console.log(x));
चूंकि यह बहु पाइपलाइन का समर्थन करता है इसलिए आप विभिन्न स्थानों में परिणाम की सदस्यता ले सकते हैं, इसमें वादों की तुलना में बहुत अधिक संभावनाएं हैं।
उपयोग:
इसमें अधिक संभावनाएं हैंmap, filter, pipe, map, concatMap etc
वेधशालाओं की अक्सर वादों से तुलना की जाती है। यहाँ कुछ महत्वपूर्ण अंतर हैं:
वेधशालाएं घोषणात्मक हैं; गणना सदस्यता तक शुरू नहीं होती है। सृजन पर तुरंत अमल करने का वादा करता है। यह पर्यवेक्षकों को उन व्यंजनों को परिभाषित करने के लिए उपयोगी बनाता है जिन्हें जब भी आपको परिणाम की आवश्यकता हो, चलाया जा सकता है।
वेधशालाएँ कई मान प्रदान करती हैं। वादे एक प्रदान करते हैं। यह समय के साथ कई मूल्यों को प्राप्त करने के लिए वेधशालाओं को उपयोगी बनाता है।
वेधशालाएँ जंजीर और सदस्यता के बीच अंतर करती हैं। वादे केवल .then () खंड होते हैं। यह सिस्टम के अन्य भागों द्वारा उपयोग किए जाने वाले जटिल परिवर्तन व्यंजनों को बनाने के लिए वेधशालाओं को उपयोगी बनाता है, जिससे कार्य निष्पादित नहीं होता है।
त्रुटियों को संभालने के लिए वेधशाला सदस्यता () जिम्मेदार है। बच्चे के वादों को धक्का त्रुटियों का वादा करता है। यह वेधशालाओं को केंद्रीकृत और पूर्वानुमेय त्रुटि से निपटने के लिए उपयोगी बनाता है।
यह सबसे सरल अंतर है जो आपको ANGULAR.IO डॉक्स पर मिल सकता है। बाकी का जवाब ज्यादातर अपनी जगह पर सही है
वादे केवल एकल मूल्यों या संकल्पों के लिए केंद्रित होते हैं, वेधशालाएँ डेटा की धारा होती हैं।
वेधशालाएं रद्द की जा सकती हैं लेकिन वादे रद्द नहीं किए जा सकते।
सबसे कम ज्ञात एक, मेरे लिए कम से कम है
वेधशाला और वादे हमें जावास्क्रिप्ट / टाइपस्क्रिप्ट में अतुल्यकालिक कार्यात्मकताओं के साथ काम करने में मदद कर रहे हैं। वे कई मामलों में बहुत समान हैं, हालांकि, उनके बीच अभी भी कुछ मतभेद हैं।
इस विषय पर पहले से ही बहुत सारे उत्तर हैं इसलिए मैं एक अतिरेक नहीं जोड़ूंगा।
लेकिन किसी ऐसे व्यक्ति ने जो अभी-अभी ऑब्जर्वेबल / एंगुलर और अजूबों को सीखना शुरू किया है, जिन्हें प्रोमिस के साथ तुलना करना है , मैं तुम्हें प्रत्यक्ष करने के लिए अपनी परियोजना में प्रत्यक्ष सब कुछ रखने के लिए और सभी मौजूदा वादे परिवर्तित की सिफारिश करेंगे।
केवल इसलिए कि कोणीय ढांचा और यह समुदाय सभी ऑब्जर्वेबल का उपयोग कर रहे हैं। इसलिए यह फायदेमंद होगा जब आप फ्रेमवर्क सेवाओं या तीसरे पक्ष के मॉड्यूल को एकीकृत करते हैं और सब कुछ एक साथ करते हैं।
हालांकि मैं सभी डाउनवोट की सराहना करता हूं लेकिन मैं अभी भी ऊपर अपनी राय रखता हूं जब तक कि कोई व्यक्ति कुछ परिदृश्यों को सूचीबद्ध करने के लिए एक उचित टिप्पणी नहीं करता है जो अभी भी ऑब्जर्वल्स पर प्रॉमिस का उपयोग करने के लिए आपके कोणीय प्रोजेक्ट में उपयोगी हो सकते हैं।
बेशक, सभी मामलों में कोई राय 100% सही नहीं है, लेकिन कम से कम मुझे लगता है कि नियमित वाणिज्यिक परियोजनाओं के लिए 98% समय कोणीय ढांचे में लागू किया गया है, ऑब्जर्वेबल जाने का सही तरीका है।
यहां तक कि अगर आप अपने सरल शौक परियोजना के शुरुआती बिंदु पर इसे पसंद नहीं करते हैं, तो आपको जल्द ही लगभग सभी घटकों का एहसास होगा, जो आप कोणीय में बातचीत करते हैं, और अधिकांश कोणीय दोस्ताना 3 पार्टी फ्रेमवर्क वेधशालाओं का उपयोग कर रहे हैं, और फिर आप उनके साथ संवाद करने के लिए अपने प्रॉमिस को ऑब्जर्व करने के लिए लगातार परिवर्तित करना समाप्त कर दिया।
उन घटकों में शामिल हैं लेकिन सीमित नहीं हैं: HttpClient, फॉर्म बिल्डर, कोणीय सामग्री मॉड्यूल / संवाद, Ngrx स्टोर / प्रभाव और एनजीएक्स-बूटस्ट्रैप।
वास्तव में, पिछले 2 वर्षों में से निपटने वाले एकमात्र पर्यावरणीय प्रणाली से एकमात्र वादा है APP_INITIALIZER
।