वादे और वेधशाला के बीच अंतर क्या है?


1395

बीच क्या अंतर है PromiseऔरObservable कोणीय में ?

प्रत्येक पर एक उदाहरण दोनों मामलों को समझने में मददगार होगा। किस परिदृश्य में हम प्रत्येक मामले का उपयोग कर सकते हैं?


23
मैं आपको इस पोस्ट को पढ़ने का सुझाव दूंगा; Angular2 वादा बनाम अवलोकन योग्य
erolkaya84


3
इस प्रश्नोत्तर को पढ़ने वाले किसी भी व्यक्ति के रूप में - कोई ऐसा व्यक्ति जो एक अनुचर, वक्ता और लंबे समय के उपयोगकर्ता PoV से दोनों दुनिया में शामिल है, मैं आपको आधिकारिक RxJS डॉक्स और वादों पर MDN प्रलेखन पढ़ने के लिए प्रोत्साहित करता हूं। मैं व्यक्तिगत रूप से यहां के जवाबों को पूरी तरह से भ्रामक और गलत मानता हूं और विश्वास करता हूं कि वे मदद करने की कोशिश कर रहे लोगों के अच्छे इरादों के साथ बहुत हानिकारक हैं।
बेंजामिन ग्रुएनबाम

1
मैं आपको इस कोणीय आधिकारिक दस्तावेज angular.io/guide/comparing-observables
fgul

और यही कारण है कि लिंक को जवाब के रूप में अस्वीकार्य माना जाता है।
डेव

जवाबों:


1547

वादा

एक एकल घटना कोPromise संभालता है है जब एक async आपरेशन पूर्ण करता है या विफल रहता है।

नोट: वहाँ Promiseपुस्तकालय हैं जो रद्द करने का समर्थन करते हैं, लेकिन ES6Promise अब तक ऐसा नहीं करता है।

नमूदार

एक Observableजैसा हैStream (कई भाषाओं में) और शून्य या अधिक घटनाओं जहां कॉलबैक प्रत्येक घटना के लिए कहा जाता है पारित करने के लिए अनुमति देता है।

अक्सर इसे Observableअधिक पसंद किया जाता है Promiseक्योंकि यह Promiseऔर अधिक की सुविधाएँ प्रदान करता है । इसके साथ Observableयदि आप 0, 1, या कई ईवेंट को हैंडल करना चाहते हैं तो कोई बात नहीं। आप प्रत्येक मामले में एक ही एपीआई का उपयोग कर सकते हैं।

Observableनिरस्तPromise होने का भी फायदा है । एक सर्वर या कुछ अन्य महंगा async संचालन के लिए एक HTTP अनुरोध का परिणाम अब कोई आवश्यकता नहीं है, तो एक की है, जबकि एक, सदस्यता को रद्द करने की अनुमति देता है तब भी जब आप अधिसूचना की जरूरत नहीं है अंततः सफलता या विफल कॉलबैक कॉल करेंगे या परिणाम यह अब प्रदान करता है।SubscriptionObservablePromise

नमूदार प्रदान करता है ऑपरेटरों की तरह map, forEach, reduce, ... एक सरणी के समान

वहाँ भी शक्तिशाली ऑपरेटरों की तरह हैं retry(), या replay(), ... कि अक्सर काफी काम कर रहे हैं।


180
तो क्या सिंगल कॉलबैक मामले में ऑब्जर्वेबल के बजाय प्रॉमिस का उपयोग करने का एक अच्छा कारण है या वे वहाँ भी काम कर सकते हैं क्योंकि वे वेधशालाओं का उपयोग किया जाना चाहिए? मूल रूप से, क्या "सभी चीज़ों का पालन करना" अच्छा है या क्या वादा अब भी अपना स्थान रखता है?
जोश वार्ट्स

75
यदि आप प्रतिक्रियाशील शैली का उपयोग करना चाहते हैं, तो बस हर जगह वेधशाला का उपयोग करें। यदि आपके पास केवल वेधशालाएं हैं तो आप आसानी से रचना कर सकते हैं। यदि आप उन्हें मिलाते हैं तो यह इतना साफ नहीं है। यदि आप प्रतिक्रियाशील शैली के बारे में परवाह नहीं करते हैं, तो आप एकल घटनाओं के लिए वादे का उपयोग कर सकते हैं जहां आप घटनाओं की धाराओं के लिए रद्द करने योग्य और अवलोकन के बारे में परवाह नहीं करते हैं।
गुंटर ज़ोचबॉयर

35
@ GünterZöchbauer हे - मैं वेधशाला या कार्यात्मक प्रोग्रामिंग के खिलाफ कोई तर्क नहीं है। मैं केवल यह कह रहा हूं कि मेरा मानना ​​है कि NG2 में http के माध्यम से मुख्य रूप से वेधशालाओं में चलने वाले लोगों के पास कॉल करने के लिए वादों पर वेधशालाओं का उपयोग करने का कोई वास्तविक कारण नहीं है। वे वादों का उपयोग करके कुछ भी नहीं खो देते हैं। डिब्यू और रिट्री ऑपरेटर अप्रासंगिक हैं - आप एनजी-बहस के साथ बहस कर सकते हैं और यदि कॉल विफल होने की उम्मीद है, तो आमतौर पर, कोड के साथ एक समस्या है। केवल उसी समय जब मुझे एचवीटी के लिए अस्थिर तीसरे पक्ष के एपीआई को क्वेरी करते हुए कॉल रिट्रीट करने के साथ काम करने की आवश्यकता थी।
VSO

92
लेकिन कृपया भूल जाइए Promise, साथ में async/ awaitआपके कोड को फिर से सपाट बना देता है! अधिकांश स्थितियों में, और ऐसी परियोजनाओं में जो रॉकेट साइंस के साथ सौदा नहीं करते हैं, उन भयानक नेस्टेड फ़ंक्शन को अनावश्यक रूप से जटिल श्रृंखलाओं के साथ लिखने की आवश्यकता नहीं है। आप किसी भी बायलरप्लेट के बिना वास्तविक मानव-पठनीय फ्लैट कोड को ट्रांसपॉयलर के साथ async/ awaitआज उपयोग कर सकते हैं TypeScriptऔर लिख सकते हैं rxjs। आपको शायद अभी भी rxjsकभी-कभी कुछ चुनिंदा स्थितियों में ज़रूरत होगी , क्योंकि इसमें वास्तव में बहुत सी चीज़ें हैं।
बड्डकोस

15
यह उत्तर भ्रामक है, एक अवलोकन एक धारा की तरह नहीं है यह एक फ़ंक्शन की तरह है जो एक धारा देता है
बेंजामिन ग्रुएनबाम

333

दोनों 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करने के लिए सेवा को इंजेक्ट कर रहे हैं । सूचना है कि हम फोन आदेश में एक से प्राप्त करने के लिए एक करने के लिए । आखिरकार हमारी खोज विधि के रिटर्न प्रकार के रूप में समाप्त होता है ।GETtoPromiseObservable<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 का उपयोग कर रहा हूं, मैं मानता हूं कि सामान्य उपयोग के मामलों में ऑब्जर्वेबल ओवर प्रॉमिस का उपयोग करते समय बहुत अंतर नहीं है। व्यवहार में यहां कोई भी लाभ वास्तव में प्रासंगिक नहीं है। आशा है कि मैं भविष्य में कुछ उन्नत उपयोग मामला देख सकता हूँ :)


और अधिक जानें


31
मैं Http सेवा को ऑब्जर्वेबल आधारित में बदलने के निर्णय को पूरी तरह से नहीं खरीदता। मेरे द्वारा सुना गया प्रत्येक विवरण एक ही उदाहरण पर निर्भर करता है: शब्द खोज। लेकिन यह एक ब्राउज़र घटनाओं को संभालने के बारे में है। मैं सुनना चाहता हूं कि अतुल्यकालिक http अनुरोधों के साथ काम करने में इसका क्या फायदा है।
एलेक्स पोलन

1
क्या मिश्रित पैटर्न से बचने के लिए निर्णय आकस्मिक था?
एलेक्स पोलन

6
@AlexPollan, वास्तव में बेन लैश के साथ इस पॉडकास्ट पर अवलोकन को लौटाने वाली http सेवा के लाभों के लिए एक अच्छी व्याख्या है: devchat.tv/js-jabber/… । अंत में, प्रमुख लाभ यह है कि आप एक अवलोकन योग्य को रद्द कर सकते हैं, और इसके लिए एक उपयोग का मामला ऊपर दिए गए लिंक में वर्णित है - जबकि एक छोटी सी बात है - यदि आप कई एपिस को कॉल करते हैं और केवल पहली प्रतिक्रिया के बारे में परवाह करते हैं, तो कोई बात नहीं आपके द्वारा बुलाया गया एपिस पहले आपके पास वापस आ जाता है, फिर आप दूसरों के अनुरोधों को रद्द कर सकते हैं।
निकोलसब्लांक

2
@nikolasleblanc, Im बहुत यकीन है कि आप इसके लिए $ q.race () का उपयोग कर सकते हैं?
jameslouiz

2
@AlexPollan, लाभ यह है कि एक अवलोकन आधारित HTTP सेवा मध्य उड़ान HTTP अनुरोधों को रद्द करना आसान बनाती है। Trungk18 के उत्तर में दौड़ की स्थिति को बाद में अनुरोध करने से पहले HTTP पर्यवेक्षित से अप्रकाशित करके हल किया जा सकता है। RXJS स्विचपॉइंट का उपयोग HTTP के अनुरोधों के लिए किया जा सकता है जो एक अन्य अवलोकनीय (उदाहरण के मान) द्वारा ट्रिगर किया गया है। स्टैंडअलोन HTTP वेधशालाओं के लिए, आप मैन्युअल रूप से सदस्यता समाप्त और फिर से सदस्यता ले सकते हैं।
स्टीवेमेचेगागुए

234

दोनों वादे और वेधशालाएँ हमें जावास्क्रिप्ट में अतुल्यकालिक कार्यात्मकताओं के साथ काम करने में मदद करेंगे । वे कई मामलों में बहुत समान हैं, हालांकि, दोनों के बीच अभी भी कुछ मतभेद हैं, वादे ऐसे मूल्य asynchronousहैं जो http कॉल जैसे तरीकों से हल होंगे । दूसरी ओर, वेधशालाएँ अतुल्यकालिक घटनाओं के अनुक्रम से निपटती हैं । उनके बीच मुख्य अंतर नीचे सूचीबद्ध हैं:

वादा:

  • एक पाइपलाइन होना
  • आमतौर पर केवल async डेटा रिटर्न के साथ उपयोग करते हैं
  • रद्द करना आसान नहीं है

नमूदार:

  • रद्द करने योग्य हैं
  • पुन: प्रयास करने और पुन: प्रयास करने जैसे स्वभाव से पुन: प्रयोज्य हैं
  • कई पाइपलाइनों में डेटा स्ट्रीम करें
  • नक्शा, फिल्टर आदि जैसे सरणी की तरह संचालन करना
  • घटनाओं जैसे अन्य स्रोतों से बनाया जा सकता है
  • वे कार्य हैं, जिन्हें बाद में सब्सक्राइब किया जा सकता है

इसके अलावा, मैंने अंतर दिखाने के लिए आपके लिए नीचे दी गई चित्रमय छवि बनाई है:

वादे और वेधशालाएँ छवि


4
वादा "रद्द करना आसान नहीं", क्या उन्हें रद्द करना संभव है?
परदीप जैन

10
हाँ, साथ ही उन्हें रद्द करने का एक तरीका है ... कुछ लोग ब्लूबर्ड या थर्ड पार्टी लाइब्रेरी का उपयोग करते हैं ... एंगुलर में क्यू लाइब्रेरी का भी उपयोग करते हैं, इसे रद्द करने के तरीके हैं ... लेकिन जैसा कि मैंने कहा कि बहुत आसान नहीं है
अलिरेरा

एक पाइप लाइन होने से कभी-कभी आउपरेंज, एक्स। APP_INITIALIZER में, यदि आपके पास कई पाइपलाइन हैं, तो यह कभी-कभी खत्म नहीं हो सकती है या कई बार खत्म हो सकती है।
हवामामो

6
Promiseवादे को रद्द करने का तरीका गलत है। Promiseकी जिम्मेदारी यह एक async संगत रास्ते में ही संभाल सफलता या विफलता के लिए .. आप एक HTTP अनुरोध आप अनुरोध, नहीं वादा रद्द रद्द, और या तो रद्द कर पूरा या वादा अस्वीकार का परिणाम बनाना चाहते हैं। jsfiddle.net/greggman/ea0yhd4p
gman

2
@gman बिल्कुल वादा बस कुछ भविष्य के मूल्य का प्रतिनिधित्व करता है । यह उस ऑपरेशन का प्रतिनिधित्व नहीं करता है जो मूल्य उत्पन्न करता है । आप कोई मान रद्द नहीं कर सकते। आप किसी मान को पुनः प्राप्त नहीं कर सकते। यह सिर्फ एक मूल्य है। यह या नहीं हो सकता वर्तमान अभी तक, और यह हो सकता है कभी नहीं मौजूद हैं, क्योंकि एक अपवाद हुई, लेकिन बस इतना ही।
योना एप्लेट्री

75

वादे

  1. परिभाषा: आपको एसिंक्रोनस रूप से फ़ंक्शन चलाने में मदद करता है, और उनके रिटर्न मान (या अपवाद) का उपयोग करता है लेकिन केवल एक बार निष्पादित होने पर।
  2. आलसी नहीं
  3. रद्द करने योग्य नहीं (कैंसिलेशन का समर्थन करने वाले प्रोमिस लाइब्रेरी हैं, लेकिन ES6 प्रॉमिस अब तक नहीं हुआ है)। दो संभावित निर्णय हैं
    • अस्वीकार
    • हल
  4. नहीं किया जा सकता पुन: प्रयास (वादे मूल कार्य उस वादे को लौट आए एक पुनः प्रयास क्षमता, एक बुरी बात है जो करने के लिए तक पहुंच होनी चाहिए)

observables

  1. परिभाषा: आपको एसिंक्रोनस रूप से फ़ंक्शंस चलाने में मदद करता है, और निष्पादित होने पर एक निरंतर अनुक्रम ( कई बार ) में उनके रिटर्न मान का उपयोग करता है ।
  2. डिफ़ॉल्ट रूप से, यह आलसी है क्योंकि यह समय बढ़ने पर मूल्यों का उत्सर्जन करता है।
  3. बहुत सारे ऑपरेटर हैं जो कोडिंग के प्रयास को सरल बनाते हैं।
  4. एक ऑपरेटर पुन: प्रयास भी करता है, तो हम कुछ शर्तों के आधार पर नमूदार पुन: प्रयास करने की जरूरत है, जब भी जरूरत पुन: प्रयास किया जा सकता है retryWhen इस्तेमाल किया जा सकता।

    नोट : उनके इंटरएक्टिव आरेखों के साथ ऑपरेटरों की एक सूची यहां RxMarbles.com पर उपलब्ध है


67

जवाबों में वेधशालाओं की कमी है। वादे ES7 async / प्रतीक्षा कार्यों का उपयोग करने की अनुमति देते हैं। उनके साथ आप अतुल्यकालिक कोड लिख सकते हैं जैसे यह एक सिंक्रोनस फ़ंक्शन कॉल होगा, इसलिए आपको अब कॉलबैक की आवश्यकता नहीं है। वेधशालाओं के ऐसा करने की एकमात्र संभावना, उन्हें वादों में परिवर्तित करना है। लेकिन जब आप उन्हें वादा करने के लिए परिवर्तित करते हैं, तो आपके पास केवल एक वापसी मूल्य हो सकता है:

async function getData(){
    const data = await observable.first().toPromise();
    //do stuff with 'data' (no callback function needed)
}

आगे पढ़े: आरएक्स ऑब्जर्वेबल पर मैं 'वेट' कैसे कर सकता हूं?


21
यह भी आश्चर्य की बात है कि किसी ने वादा के इस हत्यारे पर्क को इंगित क्यों नहीं किया - async / प्रतीक्षा के लिए सादगी और पारदर्शिता धन्यवाद। मैंने फ्लैट कोड लिखने की क्षमता के लिए वादे पर स्विच किया। सरल व्यापार तर्क और यूआई इंटरैक्शन कोड को रॉकेट साइंस की तरह नहीं देखना चाहिए और प्रतिक्रियाशील एक्सटेंशन के नेस्टेड नरक से प्रदूषित होना चाहिए। इसके अलावा, async / प्रतीक्षा केवल भविष्य में ही नहीं है, आप इसे सार्वजनिक उत्पादन ऐप में अब ट्रांसपैरर्स का उपयोग कर सकते हैं। मैं टाइपस्क्रिप्ट 2.3 का उपयोग करता हूं और यह एक वास्तविक भाषा की तरह भयानक है।
दुष्टकोल

अच्छा है, लेकिन एक प्रतिक्रियात्मक तरीके से और सभी RxOperators के साथ सोच रहा है कि शायद यह एक हत्यारे की विशेषता नहीं है
JorgeTovar

37

वादे और वेधशालाएँ दोनों ही अतुल्यकालिक कॉल को संभालते हैं।

यहाँ उन दोनों के बीच अंतर हैं:

नमूदार

  1. समय की अवधि में कई मूल्यों का उत्सर्जन करता है
  2. तब तक नहीं कहा जाता है जब तक हम ऑब्जर्वेबल की सदस्यता नहीं लेते हैं
  3. सदस्यता समाप्त () विधि का उपयोग करके रद्द किया जा सकता है
  4. मानचित्र प्रदान करता है, forEach, फ़िल्टर, कम करें, पुनः प्रयास करें, और फिर से चलाएं जब ऑपरेटर

वादा

  1. एक बार में केवल एक मूल्य का उत्सर्जन करता है

  2. .Thatch और .catch के बिना सेवाओं को कॉल करता है

  3. रद्द नहीं किया जा सकता

  4. कोई भी ऑपरेटर प्रदान नहीं करता है


2
आप वास्तव में वादे से क्या मतलब रखते हैं, केवल एकल मूल्य का उत्सर्जन करते हैं, जबकि अवलोकन योग्य कई का उत्सर्जन करता है
हाबिल

2
एक वादा सब पर एक मूल्य के उत्सर्जन नहीं - एक वादा है समय के साथ एक मूल्य। एक वादा मल्टीकास्ट जो कई ग्राहकों के लिए मूल्य है - एक बार जब आप वादा करते हैं कि आपके पास पहले से ही एक मूल्य है। एक अवलोकनीय एक फ़ंक्शन की तरह है, जो इसे सब्सक्राइब करके कार्रवाई को आमंत्रित करता है।
बेंजामिन ग्रुएनबाम

1
@BenjaminGruenbaum फिर भी मुझे ऐसे कई सब्सक्राइबर नहीं मिले जो आप लिंक या उदाहरण प्रदान कर सकें। धन्यवाद
दीपक पाटीदार

2
observable1.subscribe (सब्सक्राइबर 1), observable1.subscribe (सब्स्क्राइबर 2) - यह फ़ंक्शन को कई बार आमंत्रित करता है ।
बेंजामिन ग्रुएनबाम

2
कृपया अपनी पोस्ट को संपादित करें और स्क्रीनशॉट के बजाय वास्तविक पाठ दिखाएं। अन्य लोग आपकी छवियों से कॉपी और पेस्ट नहीं कर सकते हैं, और आपको कई व्याकरण त्रुटियों को ठीक करने में भी मदद नहीं कर सकते हैं। विवरण के लिए यहां देखें। धन्यवाद।
पंग

25

भले ही यह उत्तर देर से आया हो, मैंने नीचे दिए मतभेदों को संक्षेप में प्रस्तुत किया है,

नमूदार:

  1. अवलोकनीय केवल एक है functionजो लेता है an observerऔर वापस लौटता है function Observer: an object with next, error.
  2. प्रेक्षक subscribe/unsubscribeअपनी डेटा स्ट्रीम को अनुमति देता है , प्रेक्षक के लिए अगला मान उत्सर्ग करता है, notifyपर्यवेक्षक के बारे में errorsऔर पर्यवेक्षक को सूचित करता हैstream completion
  3. प्रेक्षक एक function to handle next value, त्रुटियों और धारा के अंत (ui घटनाओं, http प्रतिक्रियाओं, वेब सॉकेट के साथ डेटा) प्रदान करता है।
  4. multiple valuesसमय के साथ काम करता है
  5. यह आदि cancel-able/retry-ableजैसे ऑपरेटरों का समर्थन करता है map,filter,reduce
  6. एक ऑब्जर्वेबल का निर्माण किया जा सकता है - Observable.create()- वे अवलोकन योग्य जो उन तरीकों को लागू कर सकता है - - Observer Observable.from()एक सरणी को परिवर्तित करता है या उसमें पुनरावृत्ति करता है - Observable Observable.fromEvent()- एक घटना को ऑब्जर्वेबल में Observable.fromPromise()परिवर्तित करता है - - एक प्रॉमिस को ऑब्जर्वेबल में कनवर्ट करता है - Observable.range()- विशेषांक में पूर्णांकों के अनुक्रम को लौटाता है।

वादा :

  1. एक वादा एक कार्य का प्रतिनिधित्व करता है जो भविष्य में समाप्त होगा;

  2. वादे बन जाते हैं resolved by a value;

  3. वादे अपवादों से खारिज हो जाते हैं;

  4. नहीं cancellableऔर यह लौटता हैa single value

  5. एक वादा एक समारोह का पर्दाफाश करता है (then)

    -तब एक नया रिटर्न promise;

    -उसके लिए सभी attachmentके आधार पर क्रियान्वित किया जाएगा state ;

    - handlersमें guaranteedनिष्पादित करने के लिए कर रहे हैं order attached;


20

मैंने अभी एक ऐसे मुद्दे से निपटा है जहां वादे सबसे अच्छा समाधान थे, और मैं इसे यहाँ किसी के लिए साझा कर रहा हूँ इस घटना में यह सवाल उपयोगी है (यह ठीक वही जवाब था जो मैं पहले देख रहा था):

एक 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 विधि आदर्श थी।


3
यह (उच्च-क्रम) वेधशालाओं के साथ निश्चित रूप से संभव है। उदाहरण के लिए आप scan()अनुक्रमिक वेधशालाओं की एक धारा बनाने के लिए उपयोग कर सकते हैं। हालाँकि, आपका दृष्टिकोण शायद अधिक स्पष्ट और समझने में आसान है।
lex82

1
आप "स्विचपाइप" के साथ "फिर" को बदल सकते हैं और ठीक उसी चीज़ को w / वेधशालाओं में कर सकते हैं।
डॉ। सी। हिलरियस

1
स्विचपाइप के साथ समस्या, जैसा कि मैं इसे समझता हूं, यह है कि यह समानांतर में सभी अनुरोधों को शुरू करेगा और तब तक इंतजार करेगा जब तक वे सभी वापस नहीं आ जाते हैं, फिर कॉलिंग फ़ंक्शन के मूल्यों को वापस कर दें जबकि मेरी स्थिति में, मेरे पास एक एकल सर्वर है जिसे मैं नहीं कर सकता समानांतर में कई बार कॉल करें (जैसा कि नया आने पर सर्वर अधूरा अनुरोध छोड़ देगा), इसलिए मुझे एक नई कॉल शुरू करने से पहले पूरा डेटाबेस सेवा में प्रत्येक कॉल को सुनिश्चित करना था, और वादा / फिर सबसे अच्छा लग रहा था और शायद इसे हल करने का एकमात्र तरीका है।
स्टीफन आर। स्मिथ

1
आपने जंजीर मर्ज मैप का उपयोग क्यों नहीं किया? जहाँ तक मैंने आपके कोड को समझा, यह बहुत सरल है और आपके उदाहरण के अनुसार काम करता है। @ StephenR.Smith
Ore

1
@ क्या आप उस समस्या का एक अन्य उदाहरण के रूप में उसी समस्या का एक कोड उदाहरण जोड़ सकते हैं? एक अच्छा संदर्भ होगा और भविष्य में एक अच्छा रिफैक्टिंग अवसर हो सकता है। आवश्यकता यह है कि जो भी कोड समानांतर में बैकएंड सेवा को कॉल नहीं कर सकता है, उसे कॉल करना होगा, रिटर्न वैल्यू की प्रतीक्षा करनी होगी और फिर से कॉल करना होगा।
स्टीफन आर। स्मिथ

20

मेरा मानना ​​है कि अन्य सभी उत्तरों से आपकी शंकाएँ दूर होनी चाहिए। फिर भी, मैं बस यह जोड़ना चाहता था कि वेधशालाएं कार्यात्मक प्रोग्रामिंग पर आधारित हैं, और मुझे बहुत उपयोगी कार्य मिलते हैं जो इसके साथ आते हैं जैसे कि नक्शा, फ्लैटमैप, कम, ज़िप। वेब विशेष रूप से तब प्राप्त होता है जब यह एपीआई अनुरोधों पर निर्भर करता है एक क्रूर सुधार है।

मैं इस दस्तावेज की दृढ़ता से अनुशंसा करता हूं , क्योंकि यह रिएक्टिवएक्स का आधिकारिक दस्तावेज है और मुझे लगता है कि यह सबसे स्पष्ट है।

यदि आप वेधशाला में जाना चाहते हैं, तो मैं इस 3-भाग पोस्ट का सुझाव दूंगा : http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

यद्यपि यह RxJava के लिए है, अवधारणाएं समान हैं, और यह वास्तव में अच्छी तरह से समझाया गया है। रिएक्टिवएक्स प्रलेखन में, आपके पास प्रत्येक फ़ंक्शन के लिए समतुल्य है। आपको RxJS की तलाश करनी चाहिए।


18

वादा:

  • एक एकल भविष्य मूल्य प्रदान करें;
  • आलसी नहीं;
  • रद्द करने योग्य नहीं;

नमूदार:

  • समय के साथ कई मूल्यों का उत्सर्जन करता है;
  • आलसी;
  • रद्द करने योग्य;
  • मानचित्र, फ़िल्टर, कम करने और समान ऑपरेटरों का समर्थन करता है

यदि आप चाहें तो HTTP को Angular में कॉल करते समय वेधशालाओं के बजाय वादों का उपयोग कर सकते हैं।


16

अवलोकन:

  • वादे और वेधशाला दोनों हमें अतुल्यकालिक संचालन से निपटने में मदद करते हैं। जब इन अतुल्यकालिक ऑपरेशन किए जाते हैं तो वे कुछ कॉलबैक कह सकते हैं।
  • एक वादा केवल एक घटना को संभाल सकता है, वेधशालाएं समय के साथ घटनाओं की धाराओं के लिए हैं
  • एक बार लंबित होने के बाद वादे रद्द नहीं किए जा सकते
  • ऑपरेटरों का उपयोग करके डेटा वेधशाला उत्सर्जन को परिवर्तित किया जा सकता है

आप हमेशा एसिंक्रोनस व्यवहार से निपटने के लिए एक अवलोकन का उपयोग कर सकते हैं क्योंकि एक अवलोकन योग्य में सभी कार्यक्षमता होती है जो एक वादा प्रदान करता है (+ अतिरिक्त)। हालांकि, कभी-कभी यह अतिरिक्त कार्यक्षमता कि वेधशालाओं की पेशकश की आवश्यकता नहीं होती है। फिर इसका उपयोग करने के लिए एक पुस्तकालय आयात करने के लिए यह अतिरिक्त ओवरहेड होगा।

वादे का उपयोग कब करें:

वादों का उपयोग तब करें जब आपके पास एक एकल ऑपरेशन हो, जिसमें आप परिणाम को संसाधित करना चाहते हैं। उदाहरण के लिए:

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() विधि कहा जाता है।

वेधशालाओं का उपयोग कब करें:

समय के साथ एक स्ट्रीम (डेटा का) होने पर वेधशालाओं का उपयोग करें जिन्हें आपको संभालने की आवश्यकता है। एक धारा डेटा तत्वों का एक क्रम है जो समय के साथ उपलब्ध कराया जा रहा है । धाराओं के उदाहरण हैं:

  1. उपयोगकर्ता ईवेंट्स, उदाहरण के लिए क्लिक करें, या कीप इवेंट्स। उपयोगकर्ता समय के साथ घटनाओं (डेटा) उत्पन्न करता है।
  2. Websockets, क्लाइंट द्वारा समय-समय पर डेटा पुश करने वाले सर्वर से WebSocket कनेक्शन बनाता है।

ऑब्जर्वेबल में ही निर्दिष्ट किया जाता है कि अगली घटना कब हुई, जब कोई त्रुटि होती है , या जब अवलोकन पूरा हो जाता है । फिर हम इस अवलोकन के लिए सदस्यता ले सकते हैं, जो इसे सक्रिय करता है और इस सदस्यता में, हम 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। फिर जब ऑब्जर्वेबल को सब्सक्राइब किया जाता है तो वह सब्सक्रिप्शन में पास की गई कॉलबैक को कॉल करेगा।


9

वादा - एकल भविष्य का मूल्य प्रदान करें। आलसी नहीं । रद्द-सक्षम नहीं। यह या तो अस्वीकार या हल होगा।

अवलोकनीय - भविष्य के कई मूल्य प्रदान करें। आलसी । रद्द करने में सक्षम। यह अन्य तरीकों को लाइव मैप, फिल्टर, कम प्रदान करता है।


8

वादा बनाम अवलोकन योग्य समानता पहले

  1. दोनों ही async कोड को हैंडल करते थे।
  2. कृपया वादा उदाहरण के लिए देखें। प्रोमिस कंस्ट्रक्टर एक रिज़ॉल्यूशन रेफ़रेंस फंक्शन पास करता है, जो तब मिलता है जब इसे कुछ एसिंक्स टास्क पूरा होने पर कुछ वैल्यू के साथ बुलाया जाता है।

const promise = new Promise(resolve => {
  setTimeout(() => {
    resolve("Hello from a Promise!");
  }, 2000);
});

promise.then(value => console.log(value));

  1. अब देखने योग्य उदाहरण है। यहाँ हम एक समारोह भी पास करते हैं, अवलोकनीय कार्य को संभालने के लिए एक पर्यवेक्षक को। वादे में हल के विपरीत यह निम्न विधि है और तब के स्थान पर सदस्यता।

  2. तो दोनों async कार्य संभालता है। अब अंतर देखते हैं।


const observable = new Observable(observer => {
  setTimeout(() => {
    observer.next('Hello from a Observable!');
  }, 2000);
});

observable.subscribe(value => console.log(value));

वादा बनाम अवलोकन योग्य अंतर

वादा

  1. यह एकल मूल्य को हल करता है या अस्वीकार करता है और एक बार में एक ही मूल्य के async कार्य को संभाल सकता है।
  2. एक बार एक वादा पूरा हो जाने के बाद, यह अब उपयोग नहीं किया जा सकता है और यहाँ यह कम हो जाता है।
  3. रद्द करने योग्य नहीं
  4. कोई rxjs ऑपरेटरों के लिए समर्थन नहीं करता है।

नमूदार

  1. कई अतुल्यकालिक मूल्यों का उत्सर्जन करने की क्षमता।
  2. घटनाओं या मूल्यों की धारा को संभालने के लिए उपयोग किया जाता है। विचार करें कि आपके पास कई कार्यों या मूल्यों की एक सरणी है, और आप चाहते हैं कि हर बार मूल्य इसमें डाला जाए, इसे स्वचालित रूप से नियंत्रित किया जाना चाहिए। जब भी आप इस सरणी में किसी मान को आगे बढ़ाते हैं, तो उसके सभी ग्राहक अपने आप नवीनतम मूल्य प्राप्त कर लेंगे।
  3. वेधशालाएँ इनपुट परिवर्तन, बार-बार अंतराल, सभी बाल घटकों के प्रसारण मूल्यों, वेब सॉकेट पुश सूचनाओं आदि के लिए उपयोगी हैं।
  4. किसी भी समय सदस्यता समाप्त विधि का उपयोग करके रद्द किया जा सकता है।
  5. एक और अंतिम अच्छा हिस्सा जो वादा करता है कि आरएक्सजे ऑपरेटरों के लिए समर्थन है। सब्सक्राइब करने से पहले अवलोकन योग्य डेटा को बदलने के लिए आपके पास कई पाइप ऑपरेटर प्रमुख रूप से मैप, फिल्टर, स्विचपाइप, कम्बाइनटेस्ट आदि हैं।

यहां छवि विवरण दर्ज करें



6

वादे और वेधशाला दोनों हमें अतुल्यकालिक संचालन से निपटने में मदद करते हैं। जब इन अतुल्यकालिक ऑपरेशन किए जाते हैं तो वे कुछ कॉलबैक कह सकते हैं।

कोणीय वेधशाला का उपयोग करता है जो HTTP से निपटने के वादे के बजाय RxJS से है

Below are some important differences in promises & Observables.

वादे और वेधशाला के बीच अंतर


1
सारणीबद्ध डेटा गलत लगता है, शीर्षक को स्वैप किया जाना चाहिए
Derrick.X

1
कृपया अपनी पोस्ट संपादित करें और स्क्रीनशॉट के बजाय वास्तविक सामग्री को टेक्स्ट के रूप में दिखाएं। अन्य आपकी छवियों से कॉपी और पेस्ट नहीं कर सकते हैं। विवरण के लिए यहां देखें। धन्यवाद।
पेंग

6

एक 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

हम एक स्ट्रीम की तरह एक ऑब्जर्वेबल के बारे में सोच सकते हैं जो समय की अवधि में कई मानों का उत्सर्जन करता है और एक ही कॉलबैक फ़ंक्शन को उत्सर्जित प्रत्येक आइटम के लिए कहा जाता है ताकि हम एक ही एपीआई का उपयोग अतुल्यकालिक डेटा को संभालने के लिए कर सकें। चाहे वह डेटा एक ही मूल्य के रूप में या समय के कुछ खिंचाव पर कई मूल्यों के रूप में प्रेषित किया जाता है।

वादा:

  • एक वादा आलसी नहीं है
  • एक वादा रद्द नहीं किया जा सकता है

नमूदार:

  • अवलोकनीय आलसी है। "अवलोकनीय" धीमी है। इसे तब तक नहीं कहा जाता है जब तक हम इसके लिए सदस्यता नहीं लेते हैं।
  • एक अवलोकन योग्य को सदस्यता समाप्त () विधि का उपयोग करके रद्द किया जा सकता है
  • एक अतिरिक्त अवलोकन कई शक्तिशाली ऑपरेटरों को प्रदान करता है जैसे कि मानचित्र, फ़ॉरच, फ़िल्टर, कम करना, पुनः प्रयास करना, पुनः प्रयास करना आदि।

कोणीय वादा बनाम वेधशाला


5

वादा एकल मूल्य का उत्सर्जन करता है जबकि ऑब्जर्वेबल कई मूल्यों का उत्सर्जन करता है। इसलिए, 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

3

नीचे वादों और वेधशालाओं में कुछ महत्वपूर्ण अंतर हैं।

वादा

  • केवल एक मूल्य का उत्सर्जन करता है
  • रद्द करने योग्य नहीं
  • हिलाने योग्य नहीं
  • हमेशा अतुल्यकालिक

नमूदार

  • कई मूल्यों का उत्सर्जन करता है
  • केवल तभी बुलाया जाता है जब उसे बुलाया जाता है या कोई सदस्यता ले रहा होता है
  • रद्द किया जा सकता है
  • साझा किया जा सकता है और कई ग्राहकों द्वारा उस साझा मूल्य की सदस्यता ली जा सकती है। और सभी ग्राहक एक ही समय में निष्पादित करेंगे।
  • संभवतः अतुल्यकालिक

बेहतर समझ के लिए https://stackblitz.com/edit/observable-vs-promises को देखें


3

मैं इस तर्क का उपयोग करने वाले बहुत से लोगों को देखता हूं कि ऑब्जर्वेबल "रद्द करने योग्य" हैं, लेकिन यह वादा "रद्द" करने के बजाय तुच्छ है।

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


2

संक्षिप्त जवाब :

नमूदार है बेहतर , यह सब है वादे सुविधाओं के साथ साथ अतिरिक्त सुविधाओं।


लंबा जवाब:

वादे:

  • वन टाइम यूज "रिटर्न डेटा एक बार"
  • कोई रद्द नहीं
  • एक श्रोता
  • कोई सॉकेट समर्थन एक श्रोता

नमूदार:

  • डेटा परिवर्तन के रूप में कई बार डेटा लौटाएं
  • समर्थन रद्द
  • सॉकेट का समर्थन करें
  • कई श्रोता का समर्थन करें और डेटा बदलने पर उन्हें सूचित करें
  • समर्थन मानचित्र, फ़िल्टर, कम करें

मुझे नहीं लगता कि आप कह सकते हैं कि ऑब्जर्वबल्स उद्देश्यपूर्ण रूप से बेहतर हैं। यहाँ के विभिन्न उत्तरों में नोट किए गए वेधशालाओं की संख्या में गिरावट देखी गई है। जो लोग मेरे लिए खड़े हैं वे ऑब्जर्वेबल की जटिलता हैं, और वे सीधे प्रतीक्षा / एसिंक्स के साथ काम नहीं करते हैं। मुझे व्यक्तिगत रूप से उनके साथ काम करने में बहुत मुश्किल है क्योंकि आप इसका उपयोग करते समय एक ऑब्जर्वेबल के व्यवहार को निर्धारित नहीं कर सकते हैं - आपको उस कोड को देखना होगा जो इसे उत्पन्न करता है। जबकि एक वादा के साथ, आप वास्तव में जानते हैं कि वे कैसे काम करते हैं, हमेशा। उदाहरण के लिए, कभी-कभी एक ऑब्जर्वेबल की सदस्यता लेने के साइड इफेक्ट्स होते हैं (उदाहरण के लिए http अनुरोध), लेकिन कभी-कभी नहीं।
योना एप्लेट्री

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

2

जबकि स्वीकृत उत्तर सामान्य रूप से अच्छा है, मुझे नहीं लगता कि यह जोर देता है कि जब कोणीय घटकों के साथ काम करते हैं तो आप लगभग हमेशा एक अवलोकन का उपयोग करना चाहते हैं क्योंकि यह रद्द करने का समर्थन करता है। वादे को रद्द नहीं किया जा सकता है और भले ही आपका घटक नष्ट हो जाए। कोणीय तब तक क्षमा करने की प्रवृत्ति रखता है जब तक कि वह नहीं।

उदाहरण के लिए किसी नष्ट हुए घटक पर किसी भी मैनुअल परिवर्तन का पता लगाना अपवाद का कारण होगा:

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 त्रुटि ।

वैकल्पिक रूप से, यदि आप टेकउंटिल के साथ वेधशालाओं का उपयोग करते हैं पैटर्न के , तो जैसे ही आपका घटक नष्ट हो जाएगा, सदस्यता रद्द हो जाएगी।

यह एक आकस्मिक उदाहरण का एक सा है, लेकिन नष्ट कर दिया गया है कि एक घटक के लिए कोड निष्पादित शायद कीड़े के लिए नेतृत्व करने के लिए जा रहा है। जब तक आप वास्तव में किसी कारण से ऐसा नहीं करना चाहते हैं: पी


2

ट्यूटोरियल और डॉक्स की पहली रीडिंग से जो कुछ मैंने देखा वह स्पष्ट नहीं था, यह मल्टीकास्टिंग का विचार था।

सुनिश्चित करें कि आप इस बात से अवगत हैं कि डिफ़ॉल्ट रूप से, कई सब्स्क्रिप्शन एक ऑब्जर्वेबल में कई निष्पादन को ट्रिगर करेंगे। जब तक आप एक से अधिक HTTP कॉल नहीं करेंगे तब तक एक ही HTTP कॉल के लिए कई सदस्यताएँ अवलोकन योग्य हो जाएंगी.share() (मल्टीकास्टिंग को सक्षम करें) ।

एक वादा आपको एक समय में एक चीज से निपटने के लिए मजबूर करता है, इसके डेटा को अनचेक करें, अपवादों को संभालें, इसमें async / प्रतीक्षा जैसी ठंडी चीजों के लिए भाषा का समर्थन है, और अन्यथा बहुत नंगे हैं।

एक वेधशाला में बहुत सी घंटियाँ और सीटी होती हैं, लेकिन आपको उस शक्ति को समझने की आवश्यकता होती है जिसके साथ आप काम कर रहे हैं या इसका दुरुपयोग किया जा सकता है।


2

वादा:

एक 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


2

अवलोकनीय और वादों के बीच बुनियादी अंतर हैं:

यहां छवि विवरण दर्ज करें


2
कृपया अपनी पोस्ट संपादित करें और स्क्रीनशॉट के बजाय वास्तविक सामग्री को टेक्स्ट के रूप में दिखाएं। अन्य आपकी छवियों से कॉपी और पेस्ट नहीं कर सकते हैं। विवरण के लिए यहां देखें। धन्यवाद।
पेंग

1

वेधशालाओं की अक्सर वादों से तुलना की जाती है। यहाँ कुछ महत्वपूर्ण अंतर हैं:

वेधशालाएं घोषणात्मक हैं; गणना सदस्यता तक शुरू नहीं होती है। सृजन पर तुरंत अमल करने का वादा करता है। यह पर्यवेक्षकों को उन व्यंजनों को परिभाषित करने के लिए उपयोगी बनाता है जिन्हें जब भी आपको परिणाम की आवश्यकता हो, चलाया जा सकता है।

वेधशालाएँ कई मान प्रदान करती हैं। वादे एक प्रदान करते हैं। यह समय के साथ कई मूल्यों को प्राप्त करने के लिए वेधशालाओं को उपयोगी बनाता है।

वेधशालाएँ जंजीर और सदस्यता के बीच अंतर करती हैं। वादे केवल .then () खंड होते हैं। यह सिस्टम के अन्य भागों द्वारा उपयोग किए जाने वाले जटिल परिवर्तन व्यंजनों को बनाने के लिए वेधशालाओं को उपयोगी बनाता है, जिससे कार्य निष्पादित नहीं होता है।

त्रुटियों को संभालने के लिए वेधशाला सदस्यता () जिम्मेदार है। बच्चे के वादों को धक्का त्रुटियों का वादा करता है। यह वेधशालाओं को केंद्रीकृत और पूर्वानुमेय त्रुटि से निपटने के लिए उपयोगी बनाता है।

यह सबसे सरल अंतर है जो आपको ANGULAR.IO डॉक्स पर मिल सकता है। बाकी का जवाब ज्यादातर अपनी जगह पर सही है


1
  1. वादे केवल एकल मूल्यों या संकल्पों के लिए केंद्रित होते हैं, वेधशालाएँ डेटा की धारा होती हैं।

  2. वेधशालाएं रद्द की जा सकती हैं लेकिन वादे रद्द नहीं किए जा सकते।

सबसे कम ज्ञात एक, मेरे लिए कम से कम है

  1. वादे हमेशा अतुल्यकालिक प्रकृति के होते हैं, लेकिन वेधशालाएं तुल्यकालिक और अतुल्यकालिक दोनों हो सकती हैं।

0
  1. एक वादा उत्सुक है, जबकि एक अवलोकन आलसी है,
  2. एक वादा हमेशा अतुल्यकालिक होता है, जबकि एक ऑब्जर्वेबल या तो तुल्यकालिक या अतुल्यकालिक हो सकता है,
  3. एक वादा एक मूल्य प्रदान कर सकता है, जबकि एक अवलोकन एक है
    मूल्यों की धारा है (0 से कई मूल्यों तक),
  4. आप RxJS ऑपरेटरों को एक नई अनुरूप स्ट्रीम प्राप्त करने के लिए एक ऑब्जर्वेबल के लिए आवेदन कर सकते हैं।

-1

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

यहां छवि विवरण दर्ज करें


1
कृपया अपनी पोस्ट को संपादित करें और स्क्रीनशॉट के बजाय वास्तविक पाठ दिखाएं। अन्य आपकी छवियों से कॉपी और पेस्ट नहीं कर सकते हैं। विवरण के लिए यहां देखें। धन्यवाद।
पैंग

सिवाय इसके कि कोड नहीं बल्कि सादा जानकारी है, इसलिए मुझे लगता है कि इसे छवि के रूप में पोस्ट करना ठीक है
Alator

1
कुदवेंकट के यूट्यूब वीडियो से कॉपी पेस्ट करना बंद करें। मेरे नीचे से! :)
प्रतीक

-2

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

लेकिन किसी ऐसे व्यक्ति ने जो अभी-अभी ऑब्जर्वेबल / एंगुलर और अजूबों को सीखना शुरू किया है, जिन्हें प्रोमिस के साथ तुलना करना है , मैं तुम्हें प्रत्यक्ष करने के लिए अपनी परियोजना में प्रत्यक्ष सब कुछ रखने के लिए और सभी मौजूदा वादे परिवर्तित की सिफारिश करेंगे।

केवल इसलिए कि कोणीय ढांचा और यह समुदाय सभी ऑब्जर्वेबल का उपयोग कर रहे हैं। इसलिए यह फायदेमंद होगा जब आप फ्रेमवर्क सेवाओं या तीसरे पक्ष के मॉड्यूल को एकीकृत करते हैं और सब कुछ एक साथ करते हैं।


हालांकि मैं सभी डाउनवोट की सराहना करता हूं लेकिन मैं अभी भी ऊपर अपनी राय रखता हूं जब तक कि कोई व्यक्ति कुछ परिदृश्यों को सूचीबद्ध करने के लिए एक उचित टिप्पणी नहीं करता है जो अभी भी ऑब्जर्वल्स पर प्रॉमिस का उपयोग करने के लिए आपके कोणीय प्रोजेक्ट में उपयोगी हो सकते हैं।

बेशक, सभी मामलों में कोई राय 100% सही नहीं है, लेकिन कम से कम मुझे लगता है कि नियमित वाणिज्यिक परियोजनाओं के लिए 98% समय कोणीय ढांचे में लागू किया गया है, ऑब्जर्वेबल जाने का सही तरीका है।

यहां तक ​​कि अगर आप अपने सरल शौक परियोजना के शुरुआती बिंदु पर इसे पसंद नहीं करते हैं, तो आपको जल्द ही लगभग सभी घटकों का एहसास होगा, जो आप कोणीय में बातचीत करते हैं, और अधिकांश कोणीय दोस्ताना 3 पार्टी फ्रेमवर्क वेधशालाओं का उपयोग कर रहे हैं, और फिर आप उनके साथ संवाद करने के लिए अपने प्रॉमिस को ऑब्जर्व करने के लिए लगातार परिवर्तित करना समाप्त कर दिया।

उन घटकों में शामिल हैं लेकिन सीमित नहीं हैं: HttpClient, फॉर्म बिल्डर, कोणीय सामग्री मॉड्यूल / संवाद, Ngrx स्टोर / प्रभाव और एनजीएक्स-बूटस्ट्रैप।

वास्तव में, पिछले 2 वर्षों में से निपटने वाले एकमात्र पर्यावरणीय प्रणाली से एकमात्र वादा है APP_INITIALIZER

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.