ऑपरेटर से 'बनाम' का

Question

केवल के बीच का अंतर है Observable.ofऔर Observable.fromतर्क प्रारूप? Function.prototype.callऔर की तरह Function.prototype.apply?

Observable.of(1,2,3).subscribe(() => {})
Observable.from([1,2,3]).subscribe(() => {})

Answer 1

काफी नहीं। किसी सरणी को पास करते समय Observable.from, उसके बीच एकमात्र अंतर और Observable.ofतर्क पारित करने का तरीका होता है।

हालांकि, Observable.fromएक तर्क को स्वीकार करेंगे जो है

एक सब्स्क्राइब ऑब्जेक्ट, एक प्रॉमिस, एक ऑब्जर्वेबल-लाइक, एक ऐरे, एक इररेबल या एरे-जैसी ऑब्जेक्ट को कन्वर्ट करने के लिए

इसके लिए कोई समान व्यवहार नहीं है Observable.of- जो हमेशा केवल मूल्यों को स्वीकार करता है और कोई रूपांतरण नहीं करता है।

Answer 2

यह बीच का अंतर नोट करना महत्वपूर्ण है ofऔर fromजब एक सरणी की तरह (तार सहित) संरचना गुजर:

Observable.of([1, 2, 3]).subscribe(x => console.log(x));

एक बार में पूरे ऐरे को प्रिंट करेगा।

दूसरी ओर,

Observable.from([1, 2, 3]).subscribe(x => console.log(x));

तत्वों को 1 से 1 प्रिंट करता है।

तार के लिए व्यवहार समान है, लेकिन चरित्र स्तर पर।

Comments

क्या होगा अगर ऑब्जर्वेबल.ऑफ (1, 2, 3)। सदस्यता लें (x => कंसोल.लॉग (एक्स));

— xiaoke

@xiaoke तब निश्चित रूप से यह 3 अलग उत्सर्जन (1, फिर 2, फिर 3) है।

— Tsvetan Ovedenski

Answer 3

एक और दिलचस्प तथ्य यह है कि जब आप इसे सब्सक्राइब करते हैं तो ऑब्जर्वेबल.ऑफ ([]) एक खाली सरणी होगी। जब आप जब Observable.from ([]) की सदस्यता लेते हैं तो आपको कोई मूल्य नहीं मिलेगा।

यह महत्वपूर्ण है जब आप स्विचमैप के साथ लगातार ऑपरेशन करते हैं।

Ex: नीचे के उदाहरण में, मैं एक नौकरी और फिर साइटों को सहेज रहा हूं, और फिर एक धारा के रूप में टिप्पणी करता हूं।

.do((data) => {
            this.jobService.save$.next(this.job.id);
        })
        .switchMap(() => this.jobService.addSites(this.job.id, this.sites)
            .flatMap((data) => {
                if (data.length > 0) {
                    // get observables for saving
                    return Observable.forkJoin(jobSiteObservables);
                } else {
                    **return Observable.of([]);**
                }
            })).do((result) => {
            // ..
        })
        .switchMap(() => this.saveComments())
....

अगर बचाने के लिए कोई साइट नहीं है, यानी; add.ite अनुभाग में data.length = 0, उपरोक्त कोड Observable.of ([]) वापस आ रहा है और फिर टिप्पणियों को सहेजने के लिए जाता है। लेकिन अगर आप इसे Observable.from ([]) से बदल देते हैं, तो सफल होने के तरीकों को नहीं बुलाया जाएगा।

rxfiddle

Answer 4

एक पंक्ति अंतर:

       let fruits = ['orange','apple','banana']

से : सरणी के एक एक करके आइटम से बाहर निकलें। उदाहरण के लिए

    from(fruits).subscribe(console.log) // 'orange','apple','banana'

of : एक बार में पूरे ऐरे से बाहर निकलें। उदाहरण के लिए

 of(fruits).subscribe(console.log) //  ['orange','apple','banana']

नोट: के ऑपरेटर के रूप में व्यवहार कर सकते हैं से साथ ऑपरेटर प्रसार ऑपरेटर

 of(...fruits).subscribe(console.log) //  'orange','apple','banana'

Answer 5

1. विखंडन में रिटर्न अधिसूचना से यानी एक-एक करके। उदाहरण के लिए: से ("abcde") a => b => c => d => e वापस आएगा
2. पूर्ण अधिसूचना की वापसी। उदाहरण के लिए: ("abcde") में abcde लौटेगा।

https://stackblitz.com/edit/typescript-sckwsw?file=index.ts&devtoolsheight=100

Answer 6

from: सरणी, प्रतिज्ञा या पुनरावृत्ति से देखने योग्य बनाएं। केवल एक मूल्य लेता है। सरणियों, पुनरावृत्तियों और तारों के लिए, सभी निहित मूल्यों को एक अनुक्रम के रूप में उत्सर्जित किया जाएगा

const values = [1, 2, 3];
from(values); // 1 ... 2 ... 3

of: परिवर्तनीय मानों के साथ अवलोकन योग्य बनाएं, अनुक्रम में मानों का उत्सर्जन करें, लेकिन एकल मान के रूप में सरणियाँ

const values = [1, 2, 3];
of(values, 'hi', 4, 5); // [1, 2, 3] ... 'hi' ... 4 ... 5