RxJS के साथ JavaScript (Node.js) में रिएक्टिव प्रोग्रामिंग

RxJS के साथ JavaScript (Node.js) में रिएक्टिव प्रोग्रामिंग

रिएक्टिव प्रोग्रामिंग एक ऐसी प्रतिमान है जो एसिंक्रोनस डेटा स्ट्रीम और परिवर्तनों के प्रसार पर केंद्रित है। JavaScript (Node.js) इकोसिस्टम में इस प्रतिमान को लागू करने के लिए सबसे शक्तिशाली लाइब्रेरी RxJS (Reactive Extensions for JavaScript) है। यह Observable (निरीक्षणीय अनुक्रम) के साथ काम करने के लिए उपकरण प्रदान करती है, जिससे डेवलपर्स इवेंट, HTTP रिक्वेस्ट, टाइमर और अन्य एसिंक्रोनस डेटा स्रोतों को कुशलतापूर्वक संभाल सकते हैं।

RxJS की मुख्य अवधारणाएँ

RxJS के मूल में तीन प्रमुख घटक हैं:

• Observable (निरीक्षणीय ऑब्जेक्ट) — एक डेटा स्ट्रीम का प्रतिनिधित्व करता है जो समय के साथ मान उत्पन्न कर सकता है।
• Observer (निरीक्षक) — एक ऑब्जेक्ट जो Observable पर सब्सक्राइब करता है और नए डेटा (next), त्रुटियों (error), या स्ट्रीम के समाप्त होने (complete) पर प्रतिक्रिया करता है।
• Subscription (सब्सक्रिप्शन) — subscribe() मेथड को कॉल करने का परिणाम। यह सब्सक्रिप्शन के जीवनचक्र को प्रबंधित करने (जैसे, इसे रद्द करने) की अनुमति देता है।

ऑपरेटर भी महत्वपूर्ण भूमिका निभाते हैं — ये शुद्ध फंक्शन हैं जो डेटा स्ट्रीम को ट्रांसफॉर्म, फ़िल्टर, मर्ज और कंबाइन करने की अनुमति देते हैं।

इंस्टॉलेशन और सेटअप

Node.js प्रोजेक्ट में RxJS का उपयोग करने के लिए, npm के माध्यम से पैकेज इंस्टॉल करें:

npm install rxjs

इंस्टॉलेशन के बाद, लाइब्रेरी उपयोग के लिए तैयार है। आवश्यक घटकों को इम्पोर्ट करें:

const { Observable, of, from, interval } = require('rxjs');
const { map, filter, take } = require('rxjs/operators');

Observable बनाना

डेटा स्ट्रीम बनाने के कई तरीके हैं। आइए बुनियादी तरीकों पर नज़र डालें:

1. ऐरे से Observable बनाना

const { from } = require('rxjs');

const numbers$ = from([1, 2, 3, 4, 5]);
numbers$.subscribe({
    next: value => console.log(`प्राप्त: ${value}`),
    complete: () => console.log('स्ट्रीम समाप्त')
});

आउटपुट:

प्राप्त: 1
प्राप्त: 2
प्राप्त: 3
प्राप्त: 4
प्राप्त: 5
स्ट्रीम समाप्त

2. समय-समय पर मान उत्पन्न करना

const { interval } = require('rxjs');
const { take } = require('rxjs/operators');

const timer$ = interval(1000).pipe(
    take(4) // केवल 4 मानों तक सीमित
);

timer$.subscribe({
    next: value => console.log(`टिक ${value}`),
    complete: () => console.log('टाइमर समाप्त')
});

आउटपुट (1 सेकंड के अंतराल पर):

टिक 0
टिक 1
टिक 2
टिक 3
टिक 4
टाइमर समाप्त

ऑपरेटरों के साथ काम करना

ऑपरेटर RxJS का दिल हैं। वे डेटा को तुरंत बदलने की अनुमति देते हैं। आइए दो लोकप्रिय ऑपरेटरों पर नज़र डालें:

• map — स्ट्रीम के प्रत्येक मान को बदलता है।
• filter — केवल उन मानों को पास करता है जो शर्त को पूरा करते हैं।

const { of } = require('rxjs');
const { map, filter } = require('rxjs/operators');

const source$ = of(1, 2, 3, 4, 5, 6);

source$.pipe(
    filter(value => value % 2 === 0), // केवल सम संख्याएँ रखें
    map(value => value * 10)          // प्रत्येक को 10 से गुणा करें
).subscribe({
    next: value => console.log(`परिणाम: ${value}`),
    complete: () => console.log('तैयार')
});

आउटपुट:

परिणाम: 20
परिणाम: 40
परिणाम: 60
तैयार

रिएक्टिव स्ट्रीम में त्रुटियों को संभालना

RxJS त्रुटियों को संभालने के लिए अंतर्निहित तंत्र प्रदान करता है। उदाहरण के लिए, catchError ऑपरेटर अपवाद को पकड़ने और निष्पादन जारी रखने की अनुमति देता है:

const { throwError, of } = require('rxjs');
const { catchError } = require('rxjs/operators');

const error$ = throwError(() => new Error('कुछ गलत हो गया'));

error$.pipe(
    catchError(err => {
        console.error('त्रुटि पकड़ी गई:', err.message);
        return of('डिफ़ॉल्ट मान');
    })
).subscribe({
    next: value => console.log(`प्राप्त: ${value}`),
    complete: () => console.log('समाप्त')
});

आउटपुट:

त्रुटि पकड़ी गई: कुछ गलत हो गया
प्राप्त: डिफ़ॉल्ट मान
समाप्त