ಎಲ್ಲರಿಗು ನಮಸ್ಖರ. ಸೆರ್ಗೆ ಒಮೆಲ್ನಿಟ್ಸ್ಕಿ ಸಂಪರ್ಕದಲ್ಲಿದ್ದಾರೆ. ಬಹಳ ಹಿಂದೆಯೇ ನಾನು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಹೋಸ್ಟ್ ಮಾಡಿದ್ದೇನೆ, ಅಲ್ಲಿ ನಾನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಅಸಿಂಕ್ರೊನಿ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇನೆ. ಇಂದು ನಾನು ಈ ವಸ್ತುವಿನ ಬಗ್ಗೆ ಟಿಪ್ಪಣಿಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಬಯಸುತ್ತೇನೆ.
ಆದರೆ ನಾವು ಮುಖ್ಯ ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನಾವು ಪರಿಚಯಾತ್ಮಕ ಟಿಪ್ಪಣಿಯನ್ನು ಮಾಡಬೇಕಾಗಿದೆ. ಆದ್ದರಿಂದ ವ್ಯಾಖ್ಯಾನಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ: ಸ್ಟಾಕ್ ಮತ್ತು ಕ್ಯೂ ಎಂದರೇನು?
ಸ್ಟಾಕ್ ಒಂದು ಸಂಗ್ರಹವಾಗಿದ್ದು, ಅದರ ಅಂಶಗಳನ್ನು ಕೊನೆಯ-ಇನ್, ಮೊದಲ-ಔಟ್ LIFO ಆಧಾರದ ಮೇಲೆ ಪಡೆಯಲಾಗುತ್ತದೆ
ಕ್ಯೂ ಒಂದು ಸಂಗ್ರಹವಾಗಿದ್ದು, ಅದರ ಅಂಶಗಳನ್ನು ಫಸ್ಟ್-ಇನ್, ಫಸ್ಟ್-ಔಟ್ FIFO ಆಧಾರದ ಮೇಲೆ ಪಡೆಯಲಾಗುತ್ತದೆ
ಸರಿ, ಮುಂದುವರಿಸೋಣ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಏಕ-ಥ್ರೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದೆ. ಇದರರ್ಥ ಕೇವಲ ಒಂದು ಥ್ರೆಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಮತ್ತು ಒಂದು ಸ್ಟಾಕ್ ಅದರ ಮೇಲೆ ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸರತಿಯಲ್ಲಿ ಇರಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮಾತ್ರ ಮಾಡಬಹುದು, ಆದರೆ ಇತರ ಕಾರ್ಯಾಚರಣೆಗಳು ಸ್ಟಾಕ್ ಅನ್ನು ಕರೆಯುವವರೆಗೆ ತಮ್ಮ ಸರದಿಯನ್ನು ಕಾಯುತ್ತವೆ.
ಕಾಲ್ ಸ್ಟಾಕ್ ಒಂದು ಡೇಟಾ ರಚನೆಯಾಗಿದ್ದು, ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ನಾವು ಇರುವ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿನ ಸ್ಥಳದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ದಾಖಲಿಸುತ್ತದೆ. ನಾವು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಹಾದು ಹೋದರೆ, ನಾವು ಅದರ ಪ್ರವೇಶವನ್ನು ಸ್ಟಾಕ್‌ನ ಮೇಲ್ಭಾಗಕ್ಕೆ ತಳ್ಳುತ್ತೇವೆ. ನಾವು ಫಂಕ್ಷನ್‌ನಿಂದ ಹಿಂತಿರುಗಿದಾಗ, ನಾವು ಸ್ಟಾಕ್‌ನಿಂದ ಉನ್ನತ ಅಂಶವನ್ನು ಪಾಪ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ನಾವು ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆಯುವ ಸ್ಥಳದಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತೇವೆ. ಸ್ಟಾಕ್ ಮಾಡಬಹುದಾದ ಎಲ್ಲವು ಇದು. ಮತ್ತು ಈಗ ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಪ್ರಶ್ನೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಅಸಮಕಾಲಿಕತೆಯು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ?
ವಾಸ್ತವವಾಗಿ, ಸ್ಟಾಕ್ ಜೊತೆಗೆ, ಬ್ರೌಸರ್ಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುವ WebAPI ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ವಿಶೇಷ ಕ್ಯೂ ಅನ್ನು ಹೊಂದಿವೆ. ಸ್ಟಾಕ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತೆರವುಗೊಳಿಸಿದ ನಂತರವೇ ಈ ಸರದಿಯಲ್ಲಿನ ಕಾರ್ಯಗಳನ್ನು ಕ್ರಮವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಇದರ ನಂತರವೇ ಅವರನ್ನು ಸರದಿಯಿಂದ ಸ್ಟಾಕ್‌ಗೆ ಮರಣದಂಡನೆಗಾಗಿ ತಳ್ಳಲಾಗುತ್ತದೆ. ಈ ಸಮಯದಲ್ಲಿ ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಕನಿಷ್ಠ ಒಂದು ಅಂಶವಿದ್ದರೆ, ಅವುಗಳನ್ನು ಸ್ಟಾಕ್‌ಗೆ ಸೇರಿಸಲಾಗುವುದಿಲ್ಲ. ಇದು ನಿಖರವಾಗಿ ಈ ಕಾರಣದಿಂದಾಗಿ ಸಮಯ ಮೀರುವ ಮೂಲಕ ಕಾರ್ಯಗಳನ್ನು ಕರೆಯುವುದು ಸಮಯಕ್ಕೆ ನಿಖರವಾಗಿರುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಕಾರ್ಯವು ಪೂರ್ಣವಾಗಿರುವಾಗ ಸರದಿಯಿಂದ ಸ್ಟಾಕ್‌ಗೆ ಹೋಗಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ ಮತ್ತು ಅದರ ಹಂತ-ಹಂತದ ಅನುಷ್ಠಾನದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಸಹ ನೋಡೋಣ.
console.log('Hi');
setTimeout(function cb1() {
console.log('cb1');
}, 5000);
console.log('Bye');
1) ಇನ್ನೂ ಏನೂ ಆಗುತ್ತಿಲ್ಲ. ಬ್ರೌಸರ್ ಕನ್ಸೋಲ್ ಸ್ಪಷ್ಟವಾಗಿದೆ, ಕರೆ ಸ್ಟಾಕ್ ಖಾಲಿಯಾಗಿದೆ.
2) ನಂತರ console.log('Hi') ಆಜ್ಞೆಯನ್ನು ಕರೆ ಸ್ಟಾಕ್‌ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ.
3) ಮತ್ತು ಅದು ಈಡೇರಿದೆ
4) ನಂತರ console.log('Hi') ಅನ್ನು ಕರೆ ಸ್ಟಾಕ್‌ನಿಂದ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.
5) ಈಗ setTimeout (ಫಂಕ್ಷನ್ cb1() {… }) ಆಜ್ಞೆಗೆ ತೆರಳಿ. ಇದನ್ನು ಕರೆ ಸ್ಟಾಕ್‌ಗೆ ಸೇರಿಸಲಾಗಿದೆ.
6) setTimeout(ಫಂಕ್ಷನ್ cb1() {… }) ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ. ಬ್ರೌಸರ್ ವೆಬ್ API ನ ಭಾಗವಾಗಿರುವ ಟೈಮರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು ಕೌಂಟ್‌ಡೌನ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
7) setTimeout(ಫಂಕ್ಷನ್ cb1() {... }) ಆಜ್ಞೆಯು ತನ್ನ ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದೆ ಮತ್ತು ಕರೆ ಸ್ಟಾಕ್‌ನಿಂದ ತೆಗೆದುಹಾಕಲಾಗಿದೆ.
8) console.log('ಬೈ') ಆಜ್ಞೆಯನ್ನು ಕರೆ ಸ್ಟಾಕ್‌ಗೆ ಸೇರಿಸಲಾಗಿದೆ.
9) console.log('Bye') ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ.
10) ಕರೆ ಸ್ಟಾಕ್‌ನಿಂದ console.log('ಬೈ') ಆಜ್ಞೆಯನ್ನು ತೆಗೆದುಹಾಕಲಾಗಿದೆ.
11) ಕನಿಷ್ಠ 5000 ms ಕಳೆದ ನಂತರ, ಟೈಮರ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಕಾಲ್‌ಬ್ಯಾಕ್ cb1 ಅನ್ನು ಕಾಲ್‌ಬ್ಯಾಕ್ ಕ್ಯೂನಲ್ಲಿ ಇರಿಸುತ್ತದೆ.
12) ಈವೆಂಟ್ ಲೂಪ್ ಕಾಲ್‌ಬ್ಯಾಕ್ ಕ್ಯೂನಿಂದ cb1 ಕಾರ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕರೆ ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ.
13) ಕಾರ್ಯ cb1 ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಕರೆ ಸ್ಟಾಕ್‌ಗೆ console.log('cb1') ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.
14) console.log('cb1') ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ.
15) ಕರೆ ಸ್ಟಾಕ್‌ನಿಂದ console.log('cb1') ಆಜ್ಞೆಯನ್ನು ತೆಗೆದುಹಾಕಲಾಗಿದೆ.
16) ಫಂಕ್ಷನ್ cb1 ಅನ್ನು ಕರೆ ಸ್ಟಾಕ್‌ನಿಂದ ತೆಗೆದುಹಾಕಲಾಗಿದೆ.
ಡೈನಾಮಿಕ್ಸ್ನಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ:
ಸರಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಅಸಿಂಕ್ರೊನಿಯನ್ನು ಹೇಗೆ ಅಳವಡಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ. ಈಗ ಅಸಿಂಕ್ರೋನಸ್ ಕೋಡ್‌ನ ವಿಕಾಸದ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಮಾತನಾಡೋಣ.
ಅಸಮಕಾಲಿಕ ಕೋಡ್‌ನ ವಿಕಾಸ.
a(function (resultsFromA) {
b(resultsFromA, function (resultsFromB) {
c(resultsFromB, function (resultsFromC) {
d(resultsFromC, function (resultsFromD) {
e(resultsFromD, function (resultsFromE) {
f(resultsFromE, function (resultsFromF) {
console.log(resultsFromF);
})
})
})
})
})
});ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ನಮಗೆ ತಿಳಿದಿರುವಂತೆ ಅಸಮಕಾಲಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಕಾರ್ಯಗಳಿಂದ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಅವುಗಳನ್ನು ಇತರ ಕಾರ್ಯಗಳಿಗೆ ಯಾವುದೇ ವೇರಿಯಬಲ್‌ನಂತೆ ರವಾನಿಸಬಹುದು. ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು ಹುಟ್ಟಿದ್ದು ಹೀಗೆ. ಮತ್ತು ಅದು ದುಃಖ, ವಿಷಣ್ಣತೆ ಮತ್ತು ದುಃಖವಾಗಿ ಬದಲಾಗುವವರೆಗೆ ಅದು ತಂಪಾಗಿರುತ್ತದೆ, ವಿನೋದ ಮತ್ತು ತಮಾಷೆಯಾಗಿರುತ್ತದೆ. ಏಕೆ? ಇದು ಸರಳವಾಗಿದೆ:
- ಕೋಡ್‌ನ ಸಂಕೀರ್ಣತೆಯು ಹೆಚ್ಚಾದಂತೆ, ಯೋಜನೆಯು ತ್ವರಿತವಾಗಿ ಅಸ್ಪಷ್ಟ, ಪದೇ ಪದೇ ನೆಸ್ಟೆಡ್ ಬ್ಲಾಕ್‌ಗಳಾಗಿ ಬದಲಾಗುತ್ತದೆ - “ಕಾಲ್‌ಬ್ಯಾಕ್ ಹೆಲ್”.
- ದೋಷ ನಿರ್ವಹಣೆಯು ತಪ್ಪಿಸಿಕೊಳ್ಳುವುದು ಸುಲಭ.
- ನೀವು ರಿಟರ್ನ್‌ನೊಂದಿಗೆ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಹಿಂತಿರುಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಪ್ರಾಮಿಸ್ ಆಗಮನದೊಂದಿಗೆ, ಪರಿಸ್ಥಿತಿ ಸ್ವಲ್ಪ ಉತ್ತಮವಾಯಿತು.
new Promise(function(resolve, reject) {
setTimeout(() => resolve(1), 2000);
}).then((result) => {
alert(result);
return result + 2;
}).then((result) => {
throw new Error('FAILED HERE');
alert(result);
return result + 2;
}).then((result) => {
alert(result);
return result + 2;
}).catch((e) => {
console.log('error: ', e);
});- ಪ್ರಾಮಿಸ್ ಚೈನ್‌ಗಳು ಕಾಣಿಸಿಕೊಂಡವು, ಇದು ಕೋಡ್ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಿತು
- ದೋಷಗಳನ್ನು ಹಿಡಿಯಲು ಪ್ರತ್ಯೇಕ ವಿಧಾನ ಕಾಣಿಸಿಕೊಂಡಿದೆ
- Promise.all ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಾನಾಂತರ ಮರಣದಂಡನೆಯ ಸಾಧ್ಯತೆಯನ್ನು ಸೇರಿಸಲಾಗಿದೆ
- ನಾವು ಅಸಿಂಕ್/ವೇಯ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೆಸ್ಟೆಡ್ ಅಸಿಂಕ್ರೊನಿಯನ್ನು ಪರಿಹರಿಸಬಹುದು
ಆದರೆ ಭರವಸೆಗಳು ತಮ್ಮ ಮಿತಿಗಳನ್ನು ಹೊಂದಿವೆ. ಉದಾಹರಣೆಗೆ, ತಂಬೂರಿಯೊಂದಿಗೆ ನೃತ್ಯ ಮಾಡದೆಯೇ ಭರವಸೆಯನ್ನು ರದ್ದುಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಅದು ಒಂದು ಮೌಲ್ಯದೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದು ಅತ್ಯಂತ ಮುಖ್ಯವಾದದ್ದು.
ಸರಿ, ನಾವು ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸರಾಗವಾಗಿ ಸಂಪರ್ಕಿಸಿದ್ದೇವೆ. ಸುಸ್ತಾಗಿದೆಯೇ? ಒಳ್ಳೆಯದು, ಅದೃಷ್ಟವಶಾತ್, ನೀವು ಸ್ವಲ್ಪ ಚಹಾ ಮಾಡಲು ಹೋಗಬಹುದು, ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸಿ ಮತ್ತು ಇನ್ನಷ್ಟು ಓದಲು ಹಿಂತಿರುಗಿ. ಮತ್ತು ನಾನು ಮುಂದುವರಿಯುತ್ತೇನೆ.
ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಡೇಟಾ ಹರಿವುಗಳು ಮತ್ತು ಬದಲಾವಣೆಯ ಪ್ರಚಾರದ ಮೇಲೆ ಕೇಂದ್ರೀಕೃತವಾಗಿರುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಯಾಗಿದೆ. ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಎಂದರೇನು ಎಂಬುದನ್ನು ಹತ್ತಿರದಿಂದ ನೋಡೋಣ.
// Получаем ссылку на элемент
const input = ducument.querySelector('input');
const eventsArray = [];
// Пушим каждое событие в массив eventsArray
input.addEventListener('keyup',
event => eventsArray.push(event)
);ನಾವು ಇನ್ಪುಟ್ ಕ್ಷೇತ್ರವನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಊಹಿಸೋಣ. ನಾವು ರಚನೆಯನ್ನು ರಚಿಸುತ್ತಿದ್ದೇವೆ ಮತ್ತು ಇನ್ಪುಟ್ ಈವೆಂಟ್‌ನ ಪ್ರತಿ ಕೀಅಪ್‌ಗಾಗಿ ನಾವು ಈವೆಂಟ್ ಅನ್ನು ನಮ್ಮ ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ನಮ್ಮ ಶ್ರೇಣಿಯನ್ನು ಸಮಯದಿಂದ ವಿಂಗಡಿಸಲಾಗಿದೆ ಎಂದು ನಾನು ಗಮನಿಸಲು ಬಯಸುತ್ತೇನೆ, ಅಂದರೆ. ನಂತರದ ಘಟನೆಗಳ ಸೂಚ್ಯಂಕವು ಹಿಂದಿನ ಘಟನೆಗಳ ಸೂಚ್ಯಂಕಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ. ಅಂತಹ ರಚನೆಯು ಡೇಟಾ ಹರಿವಿನ ಸರಳೀಕೃತ ಮಾದರಿಯಾಗಿದೆ, ಆದರೆ ಇದು ಇನ್ನೂ ಹರಿವಿನಲ್ಲ. ಈ ವ್ಯೂಹವನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಸ್ಟ್ರೀಮ್ ಎಂದು ಕರೆಯಲು, ಅದರಲ್ಲಿ ಹೊಸ ಡೇಟಾ ಬಂದಿದೆ ಎಂದು ಚಂದಾದಾರರಿಗೆ ಹೇಗಾದರೂ ತಿಳಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಹೀಗಾಗಿ ನಾವು ಹರಿವಿನ ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ಬರುತ್ತೇವೆ.
ಡೇಟಾ ಸ್ಟ್ರೀಮ್
const { interval } = Rx;
const { take } = RxOperators;
interval(1000).pipe(
take(4)
)
ಹರಿವು ಡೇಟಾ ಬದಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುವ ಸಮಯದ ಪ್ರಕಾರ ವಿಂಗಡಿಸಲಾದ ಡೇಟಾದ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ. ಒಂದು ಕ್ರಿಯೆಗೆ ಕೋಡ್‌ನ ವಿವಿಧ ಭಾಗಗಳಲ್ಲಿ ಹಲವಾರು ಈವೆಂಟ್‌ಗಳನ್ನು ಕರೆಯುವ ಅಗತ್ಯವಿರುವ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಎಷ್ಟು ಅನುಕೂಲಕರವಾಗಿದೆ ಎಂಬುದನ್ನು ಈಗ ಊಹಿಸಿ. ನಾವು ಸ್ಟ್ರೀಮ್‌ಗೆ ಚಂದಾದಾರರಾಗುತ್ತೇವೆ ಮತ್ತು ಬದಲಾವಣೆಗಳು ಸಂಭವಿಸಿದಾಗ ಅದು ನಮಗೆ ತಿಳಿಸುತ್ತದೆ. ಮತ್ತು RxJs ಲೈಬ್ರರಿ ಇದನ್ನು ಮಾಡಬಹುದು.
RxJS ವೀಕ್ಷಿಸಬಹುದಾದ ಅನುಕ್ರಮಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಸಮಕಾಲಿಕ ಮತ್ತು ಈವೆಂಟ್-ಆಧಾರಿತ ಕಾರ್ಯಕ್ರಮಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಗ್ರಂಥಾಲಯವಾಗಿದೆ. ಗ್ರಂಥಾಲಯವು ಮೂಲಭೂತ ಪ್ರಕಾರವನ್ನು ಒದಗಿಸುತ್ತದೆ ಗಮನಿಸಬಹುದಾದ, ಹಲವಾರು ಸಹಾಯಕ ವಿಧಗಳು (ವೀಕ್ಷಕರು, ಶೆಡ್ಯೂಲರ್‌ಗಳು, ವಿಷಯಗಳು) ಮತ್ತು ಸಂಗ್ರಹಣೆಗಳಂತೆ ಈವೆಂಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಿರ್ವಾಹಕರು (ನಕ್ಷೆ, ಫಿಲ್ಟರ್, ಕಡಿಮೆ, ಪ್ರತಿ ಮತ್ತು ಇದೇ ರೀತಿಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇ).
ಈ ಗ್ರಂಥಾಲಯದ ಮೂಲ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ.
ಗಮನಿಸಬಹುದಾದ, ವೀಕ್ಷಕ, ನಿರ್ಮಾಪಕ
ನಾವು ನೋಡುವ ಮೊದಲ ಮೂಲ ಪ್ರಕಾರವನ್ನು ಗಮನಿಸಬಹುದಾಗಿದೆ. ಈ ವರ್ಗವು RxJs ಅನುಷ್ಠಾನದ ಮುಖ್ಯ ಭಾಗವನ್ನು ಒಳಗೊಂಡಿದೆ. ಇದು ವೀಕ್ಷಿಸಬಹುದಾದ ಸ್ಟ್ರೀಮ್‌ಗೆ ಸಂಬಂಧಿಸಿದೆ, ಅದನ್ನು ಚಂದಾದಾರಿಕೆ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಚಂದಾದಾರರಾಗಬಹುದು.
ಗಮನಿಸಬಹುದಾದ ನವೀಕರಣಗಳನ್ನು ರಚಿಸಲು ಸಹಾಯಕ ಕಾರ್ಯವಿಧಾನವನ್ನು ಅಳವಡಿಸುತ್ತದೆ, ಎಂದು ಕರೆಯಲ್ಪಡುವ ಅಬ್ಸರ್ವರ್. ವೀಕ್ಷಕರಿಗೆ ಮೌಲ್ಯಗಳ ಮೂಲವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ನಿರ್ಮಾಪಕ. ಇದು ಅರೇ, ಪುನರಾವರ್ತಕ, ವೆಬ್ ಸಾಕೆಟ್, ಕೆಲವು ರೀತಿಯ ಈವೆಂಟ್, ಇತ್ಯಾದಿ ಆಗಿರಬಹುದು. ಆದ್ದರಿಂದ ನಾವು ಗಮನಿಸಬಹುದಾದವು ನಿರ್ಮಾಪಕ ಮತ್ತು ವೀಕ್ಷಕರ ನಡುವಿನ ವಾಹಕವಾಗಿದೆ ಎಂದು ಹೇಳಬಹುದು.
ಗಮನಿಸಬಹುದಾದ ಮೂರು ವಿಧದ ವೀಕ್ಷಕ ಘಟನೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:
- ಮುಂದಿನ - ಹೊಸ ಡೇಟಾ
- ದೋಷ - ಒಂದು ವಿನಾಯಿತಿಯಿಂದಾಗಿ ಅನುಕ್ರಮವು ಕೊನೆಗೊಂಡರೆ ದೋಷ. ಈ ಘಟನೆಯು ಅನುಕ್ರಮದ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯನ್ನು ಸಹ ಸೂಚಿಸುತ್ತದೆ.
- ಸಂಪೂರ್ಣ - ಅನುಕ್ರಮದ ಪೂರ್ಣಗೊಂಡ ಬಗ್ಗೆ ಸಂಕೇತ. ಇದರರ್ಥ ಇನ್ನು ಮುಂದೆ ಯಾವುದೇ ಹೊಸ ಡೇಟಾ ಇರುವುದಿಲ್ಲ.
ಡೆಮೊವನ್ನು ನೋಡೋಣ:
ಆರಂಭದಲ್ಲಿ ನಾವು 1, 2, 3 ಮತ್ತು 1 ಸೆಕೆಂಡಿನ ನಂತರ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತೇವೆ. ನಾವು 4 ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ನಮ್ಮ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತೇವೆ.
ಜೋರಾಗಿ ಯೋಚಿಸುತ್ತಿದೆ
ಮತ್ತು ಅದರ ಬಗ್ಗೆ ಬರೆಯುವುದಕ್ಕಿಂತ ಅದನ್ನು ಹೇಳುವುದು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ ಎಂದು ನಾನು ಅರಿತುಕೊಂಡೆ. 😀
ಚಂದಾದಾರಿಕೆ
ನಾವು ಸ್ಟ್ರೀಮ್‌ಗೆ ಚಂದಾದಾರರಾದಾಗ ನಾವು ಹೊಸ ತರಗತಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ ಚಂದಾದಾರಿಕೆಇದು ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನಮಗೆ ನೀಡುತ್ತದೆ ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್. ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಚಂದಾದಾರಿಕೆಗಳನ್ನು ಗುಂಪು ಮಾಡಬಹುದು ಸೇರಿಸು. ಸರಿ, ನಾವು ಬಳಸಿ ಎಳೆಗಳನ್ನು ಅನ್ಗ್ರೂಪ್ ಮಾಡಬಹುದು ಎಂಬುದು ತಾರ್ಕಿಕವಾಗಿದೆ ತೆಗೆದು. ಸೇರಿಸಿ ಮತ್ತು ತೆಗೆದುಹಾಕುವ ವಿಧಾನಗಳು ಮತ್ತೊಂದು ಚಂದಾದಾರಿಕೆಯನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸುತ್ತವೆ. ನಾವು ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ಮಾಡಿದಾಗ, ಅವರು ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿದಂತೆ ಎಲ್ಲಾ ಮಕ್ಕಳ ಚಂದಾದಾರಿಕೆಗಳಿಂದ ನಾವು ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ಮಾಡುತ್ತೇವೆ ಎಂಬುದನ್ನು ನಾನು ಗಮನಿಸಲು ಬಯಸುತ್ತೇನೆ. ಮುಂದುವರೆಯಿರಿ.
ಸ್ಟ್ರೀಮ್‌ಗಳ ವಿಧಗಳು
ಹಾಟ್
ಕೋಲ್ಡ್
ಉತ್ಪಾದಕವನ್ನು ಗಮನಿಸಬಹುದಾದ ಹೊರಗೆ ರಚಿಸಲಾಗಿದೆ
ನೋಡಬಹುದಾದ ಒಳಗೆ ನಿರ್ಮಾಪಕನನ್ನು ರಚಿಸಲಾಗಿದೆ
ಗಮನಿಸಬಹುದಾದದನ್ನು ರಚಿಸುವ ಸಮಯದಲ್ಲಿ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ
ಚಂದಾದಾರಿಕೆಯ ಸಮಯದಲ್ಲಿ ಡೇಟಾವನ್ನು ಒದಗಿಸಲಾಗುತ್ತದೆ
ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ಮಾಡಲು ಹೆಚ್ಚುವರಿ ಲಾಜಿಕ್ ಅಗತ್ಯವಿದೆ
ಥ್ರೆಡ್ ತನ್ನದೇ ಆದ ಮೇಲೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ
ಒಂದರಿಂದ ಹಲವು ಸಂಬಂಧಗಳನ್ನು ಬಳಸುತ್ತದೆ
ಒಂದಕ್ಕೊಂದು ಸಂಬಂಧವನ್ನು ಬಳಸುತ್ತದೆ
ಎಲ್ಲಾ ಚಂದಾದಾರಿಕೆಗಳು ಒಂದೇ ಅರ್ಥವನ್ನು ಹೊಂದಿವೆ
ಚಂದಾದಾರಿಕೆಗಳು ಸ್ವತಂತ್ರವಾಗಿವೆ
ನೀವು ಚಂದಾದಾರಿಕೆಯನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ ಡೇಟಾ ಕಳೆದುಹೋಗಬಹುದು
ಹೊಸ ಚಂದಾದಾರಿಕೆಗಾಗಿ ಎಲ್ಲಾ ಸ್ಟ್ರೀಮ್ ಮೌಲ್ಯಗಳನ್ನು ಮರುಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ
ಒಂದು ಸಾದೃಶ್ಯವನ್ನು ನೀಡಲು, ನಾನು ಥಿಯೇಟರ್ನಲ್ಲಿ ಚಲನಚಿತ್ರವಾಗಿ ಬಿಸಿ ಸ್ಟ್ರೀಮ್ ಎಂದು ಭಾವಿಸುತ್ತೇನೆ. ನೀವು ಯಾವ ಸಮಯದಲ್ಲಿ ಬಂದಿದ್ದೀರಿ, ಆ ಕ್ಷಣದಿಂದ ನೀವು ವೀಕ್ಷಿಸಲು ಪ್ರಾರಂಭಿಸಿದ್ದೀರಿ. ನಾನು ಕೋಲ್ಡ್ ಫ್ಲೋ ಅನ್ನು ತಂತ್ರಜ್ಞಾನದಲ್ಲಿ ಕರೆಗೆ ಹೋಲಿಸುತ್ತೇನೆ. ಬೆಂಬಲ. ಯಾವುದೇ ಕರೆ ಮಾಡುವವರು ಧ್ವನಿಮೇಲ್ ರೆಕಾರ್ಡಿಂಗ್ ಅನ್ನು ಪ್ರಾರಂಭದಿಂದ ಕೊನೆಯವರೆಗೆ ಆಲಿಸುತ್ತಾರೆ, ಆದರೆ ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಸ್ಥಗಿತಗೊಳಿಸಬಹುದು.
ಬೆಚ್ಚಗಿನ ಹರಿವುಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತವೆ ಎಂದು ನಾನು ಗಮನಿಸಲು ಬಯಸುತ್ತೇನೆ (ನಾನು ಈ ವ್ಯಾಖ್ಯಾನವನ್ನು ಅತ್ಯಂತ ವಿರಳವಾಗಿ ಮತ್ತು ವಿದೇಶಿ ಸಮುದಾಯಗಳಲ್ಲಿ ಮಾತ್ರ ಕಂಡಿದ್ದೇನೆ) - ಇದು ಶೀತ ಹರಿವಿನಿಂದ ಬಿಸಿಯಾಗಿ ರೂಪಾಂತರಗೊಳ್ಳುವ ಹರಿವು. ಪ್ರಶ್ನೆ ಉದ್ಭವಿಸುತ್ತದೆ - ಎಲ್ಲಿ ಬಳಸಬೇಕು)) ನಾನು ಅಭ್ಯಾಸದಿಂದ ಒಂದು ಉದಾಹರಣೆ ನೀಡುತ್ತೇನೆ.
ನಾನು ಕೋನೀಯ ಜೊತೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇನೆ. ಅವರು rxjs ಅನ್ನು ಸಕ್ರಿಯವಾಗಿ ಬಳಸುತ್ತಾರೆ. ಸರ್ವರ್‌ಗೆ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲು, ನಾನು ಕೋಲ್ಡ್ ಥ್ರೆಡ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತೇನೆ ಮತ್ತು asyncPipe ಅನ್ನು ಬಳಸಿಕೊಂಡು ಟೆಂಪ್ಲೇಟ್‌ನಲ್ಲಿ ಈ ಥ್ರೆಡ್ ಅನ್ನು ಬಳಸುತ್ತೇನೆ. ನಾನು ಈ ಪೈಪ್ ಅನ್ನು ಹಲವಾರು ಬಾರಿ ಬಳಸಿದರೆ, ನಂತರ, ಕೋಲ್ಡ್ ಸ್ಟ್ರೀಮ್ನ ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ಹಿಂತಿರುಗಿ, ಪ್ರತಿ ಪೈಪ್ ಸರ್ವರ್ನಿಂದ ಡೇಟಾವನ್ನು ವಿನಂತಿಸುತ್ತದೆ, ಇದು ಕನಿಷ್ಠ ಹೇಳಲು ವಿಚಿತ್ರವಾಗಿದೆ. ಮತ್ತು ನಾನು ಕೋಲ್ಡ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಬೆಚ್ಚಗಿನ ಒಂದು ಆಗಿ ಪರಿವರ್ತಿಸಿದರೆ, ನಂತರ ವಿನಂತಿಯು ಒಮ್ಮೆ ಸಂಭವಿಸುತ್ತದೆ.
ಸಾಮಾನ್ಯವಾಗಿ, ಹರಿವಿನ ಪ್ರಕಾರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಆರಂಭಿಕರಿಗಾಗಿ ಸಾಕಷ್ಟು ಕಷ್ಟ, ಆದರೆ ಮುಖ್ಯವಾಗಿದೆ.
ಆಪರೇಟರ್ಸ್
return this.http.get(`${environment.apiUrl}/${this.apiUrl}/trade_companies`)
.pipe(
tap(({ data }: TradeCompanyList) => this.companies$$.next(cloneDeep(data))),
map(({ data }: TradeCompanyList) => data)
);ಸ್ಟ್ರೀಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ನಮ್ಮ ಸಾಮರ್ಥ್ಯವನ್ನು ವಿಸ್ತರಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಆಪರೇಟರ್‌ಗಳು ನಮಗೆ ಒದಗಿಸುತ್ತಾರೆ. ಅವರು ಗಮನಿಸಬಹುದಾದ ಘಟನೆಗಳನ್ನು ನಿಯಂತ್ರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತಾರೆ. ನಾವು ಒಂದೆರಡು ಹೆಚ್ಚು ಜನಪ್ರಿಯವಾದವುಗಳನ್ನು ನೋಡುತ್ತೇವೆ ಮತ್ತು ಆಪರೇಟರ್‌ಗಳ ಕುರಿತು ಹೆಚ್ಚಿನ ವಿವರಗಳನ್ನು ಉಪಯುಕ್ತ ಮಾಹಿತಿಯಲ್ಲಿರುವ ಲಿಂಕ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಾಣಬಹುದು.
ನಿರ್ವಾಹಕರು - ಆಫ್
ನ ಸಹಾಯಕ ಆಪರೇಟರ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ಇದು ಸರಳ ಮೌಲ್ಯದ ಆಧಾರದ ಮೇಲೆ ಗಮನಿಸಬಹುದಾದದನ್ನು ರಚಿಸುತ್ತದೆ.
ನಿರ್ವಾಹಕರು - ಫಿಲ್ಟರ್
ಫಿಲ್ಟರ್ ಆಪರೇಟರ್, ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಸ್ಟ್ರೀಮ್ ಸಿಗ್ನಲ್ ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ. ಆಪರೇಟರ್ ನಿಜ ಎಂದು ಹಿಂತಿರುಗಿಸಿದರೆ, ಅದು ಮತ್ತಷ್ಟು ಸ್ಕಿಪ್ ಆಗುತ್ತದೆ.
ನಿರ್ವಾಹಕರು - ತೆಗೆದುಕೊಳ್ಳಿ
ತೆಗೆದುಕೊಳ್ಳಿ - ಹೊರಸೂಸುವವರ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದರ ನಂತರ ಥ್ರೆಡ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.
ನಿರ್ವಾಹಕರು - debounceTime
debounceTime - ಔಟ್‌ಪುಟ್‌ಗಳ ನಡುವಿನ ನಿರ್ದಿಷ್ಟ ಸಮಯದ ಮಧ್ಯಂತರದೊಳಗೆ ಬೀಳುವ ಹೊರಸೂಸಲ್ಪಟ್ಟ ಮೌಲ್ಯಗಳನ್ನು ತ್ಯಜಿಸುತ್ತದೆ - ಸಮಯದ ಮಧ್ಯಂತರವು ಕಳೆದ ನಂತರ, ಕೊನೆಯ ಮೌಲ್ಯವನ್ನು ಹೊರಸೂಸುತ್ತದೆ.
const { Observable } = Rx;
const { debounceTime, take } = RxOperators;
Observable.create((observer) => {
let i = 1;
observer.next(i++);
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next(i++)
}, 1000);
// Испускаем значение раз в 1500мс
setInterval(() => {
observer.next(i++)
}, 1500);
}).pipe(
debounceTime(700), // Ожидаем 700мс значения прежде чем обработать
take(3)
);
ನಿರ್ವಾಹಕರು - takeWhile
TakeWhile ತಪ್ಪನ್ನು ಹಿಂದಿರುಗಿಸುವವರೆಗೆ ಮೌಲ್ಯಗಳನ್ನು ಹೊರಸೂಸುತ್ತದೆ, ನಂತರ ಅದು ಥ್ರೆಡ್ನಿಂದ ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ಆಗುತ್ತದೆ.
const { Observable } = Rx;
const { debounceTime, takeWhile } = RxOperators;
Observable.create((observer) => {
let i = 1;
observer.next(i++);
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next(i++)
}, 1000);
}).pipe(
takeWhile( producer => producer < 5 )
);
ನಿರ್ವಾಹಕರು - ಇತ್ತೀಚಿನ ಸಂಯೋಜನೆ
combineLatest ಆಪರೇಟರ್ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ promise.all ಅನ್ನು ಹೋಲುತ್ತದೆ. ಇದು ಅನೇಕ ಎಳೆಗಳನ್ನು ಒಂದಾಗಿ ಸಂಯೋಜಿಸುತ್ತದೆ. ಪ್ರತಿ ಥ್ರೆಡ್ ಕನಿಷ್ಠ ಒಂದು ಹೊರಸೂಸುವಿಕೆಯನ್ನು ಮಾಡಿದ ನಂತರ, ನಾವು ಪ್ರತಿಯೊಂದರಿಂದ ಇತ್ತೀಚಿನ ಮೌಲ್ಯಗಳನ್ನು ರಚನೆಯ ರೂಪದಲ್ಲಿ ಪಡೆಯುತ್ತೇವೆ. ಇದಲ್ಲದೆ, ವಿಲೀನಗೊಂಡ ಸ್ಟ್ರೀಮ್‌ಗಳಿಂದ ಯಾವುದೇ ಹೊರಸೂಸುವಿಕೆಯ ನಂತರ, ಅದು ಹೊಸ ಮೌಲ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ.
const { combineLatest, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
});
const observer_2 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 750мс
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
});
combineLatest(observer_1, observer_2).pipe(take(5));
ನಿರ್ವಾಹಕರು - ಜಿಪ್
ಜಿಪ್ - ಪ್ರತಿ ಥ್ರೆಡ್ನಿಂದ ಮೌಲ್ಯಕ್ಕಾಗಿ ಕಾಯುತ್ತದೆ ಮತ್ತು ಈ ಮೌಲ್ಯಗಳ ಆಧಾರದ ಮೇಲೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರೂಪಿಸುತ್ತದೆ. ಮೌಲ್ಯವು ಯಾವುದೇ ಥ್ರೆಡ್ನಿಂದ ಬರದಿದ್ದರೆ, ನಂತರ ಗುಂಪು ರಚನೆಯಾಗುವುದಿಲ್ಲ.
const { zip, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
});
const observer_2 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 750
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
});
const observer_3 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 500
setInterval(() => {
observer.next('c: ' + i++);
}, 500);
});
zip(observer_1, observer_2, observer_3).pipe(take(5));
ನಿರ್ವಾಹಕರು - forkJoin
forkJoin ಸಹ ಥ್ರೆಡ್‌ಗಳನ್ನು ಸೇರುತ್ತದೆ, ಆದರೆ ಎಲ್ಲಾ ಥ್ರೆಡ್‌ಗಳು ಪೂರ್ಣಗೊಂಡಾಗ ಮಾತ್ರ ಅದು ಮೌಲ್ಯವನ್ನು ಹೊರಸೂಸುತ್ತದೆ.
const { forkJoin, Observable } = Rx;
const { take } = RxOperators;
const observer_1 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next('a: ' + i++);
}, 1000);
}).pipe(take(3));
const observer_2 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 750
setInterval(() => {
observer.next('b: ' + i++);
}, 750);
}).pipe(take(5));
const observer_3 = Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 500
setInterval(() => {
observer.next('c: ' + i++);
}, 500);
}).pipe(take(4));
forkJoin(observer_1, observer_2, observer_3);
ನಿರ್ವಾಹಕರು - ನಕ್ಷೆ
ನಕ್ಷೆ ರೂಪಾಂತರ ಆಪರೇಟರ್ ಹೊರಸೂಸುವ ಮೌಲ್ಯವನ್ನು ಹೊಸದಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.
const { Observable } = Rx;
const { take, map } = RxOperators;
Observable.create((observer) => {
let i = 1;
// Испускаем значение раз в 1000мс
setInterval(() => {
observer.next(i++);
}, 1000);
}).pipe(
map(x => x * 10),
take(3)
);
ನಿರ್ವಾಹಕರು - ಹಂಚಿಕೊಳ್ಳಿ, ಟ್ಯಾಪ್ ಮಾಡಿ
ಟ್ಯಾಪ್ ಆಪರೇಟರ್ ನಿಮಗೆ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ, ಅಂದರೆ, ಅನುಕ್ರಮದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರದ ಯಾವುದೇ ಕ್ರಮಗಳು.
ಶೇರ್ ಯುಟಿಲಿಟಿ ಆಪರೇಟರ್ ಕೋಲ್ಡ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಬಿಸಿಯಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು.
ನಾವು ಆಪರೇಟರ್‌ಗಳೊಂದಿಗೆ ಮುಗಿಸಿದ್ದೇವೆ. ವಿಷಯಕ್ಕೆ ಹೋಗೋಣ.
ಜೋರಾಗಿ ಯೋಚಿಸುತ್ತಿದೆ
ತದನಂತರ ನಾನು ಸ್ವಲ್ಪ ಚಹಾ ಕುಡಿಯಲು ಹೋದೆ. ಈ ಉದಾಹರಣೆಗಳಿಂದ ನಾನು ಬೇಸತ್ತಿದ್ದೇನೆ 😀
ವಿಷಯ ಕುಟುಂಬ
ವಿಷಯದ ಕುಟುಂಬವು ಬಿಸಿ ಹರಿವಿನ ಒಂದು ಪ್ರಮುಖ ಉದಾಹರಣೆಯಾಗಿದೆ. ಈ ವರ್ಗಗಳು ಒಂದು ರೀತಿಯ ಹೈಬ್ರಿಡ್ ಆಗಿದ್ದು ಅದು ಏಕಕಾಲದಲ್ಲಿ ಗಮನಿಸಬಹುದಾದ ಮತ್ತು ವೀಕ್ಷಕನಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ವಿಷಯವು ಹಾಟ್ ಥ್ರೆಡ್ ಆಗಿರುವುದರಿಂದ, ಅದರಿಂದ ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ಮಾಡುವುದು ಅವಶ್ಯಕ. ನಾವು ಮುಖ್ಯ ವಿಧಾನಗಳ ಬಗ್ಗೆ ಮಾತನಾಡಿದರೆ, ಅವುಗಳೆಂದರೆ:
- ಮುಂದೆ - ಸ್ಟ್ರೀಮ್‌ಗೆ ಹೊಸ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸುವುದು
- ದೋಷ - ದೋಷ ಮತ್ತು ಥ್ರೆಡ್ ಮುಕ್ತಾಯ
- ಸಂಪೂರ್ಣ - ಥ್ರೆಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ
- ಚಂದಾದಾರರಾಗಿ - ಸ್ಟ್ರೀಮ್‌ಗೆ ಚಂದಾದಾರರಾಗಿ
- ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ - ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಅನ್ಸಬ್ಸ್ಕ್ರೈಬ್ ಮಾಡಿ
- ಗಮನಿಸಬಹುದಾದಂತೆ - ವೀಕ್ಷಕನಾಗಿ ರೂಪಾಂತರ
- ಪ್ರಾಮಿಸ್ - ಭರವಸೆಯಾಗಿ ರೂಪಾಂತರಗೊಳ್ಳುತ್ತದೆ
4 5 ವಿಧದ ವಿಷಯಗಳಿವೆ.
ಜೋರಾಗಿ ಯೋಚಿಸುತ್ತಿದೆ
ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ 4 ಜನರು ಮಾತನಾಡುತ್ತಿದ್ದರು, ಆದರೆ ಅವರು ಮತ್ತೊಬ್ಬರನ್ನು ಸೇರಿಸಿದ್ದಾರೆ ಎಂದು ತಿಳಿದುಬಂದಿದೆ. ಅವರು ಹೇಳಿದಂತೆ, ಬದುಕು ಮತ್ತು ಕಲಿಯಿರಿ.
ಸರಳ ವಿಷಯ new Subject()- ವಿಷಯಗಳ ಸರಳ ಪ್ರಕಾರ. ನಿಯತಾಂಕಗಳಿಲ್ಲದೆ ರಚಿಸಲಾಗಿದೆ. ಚಂದಾದಾರಿಕೆಯ ನಂತರ ಮಾತ್ರ ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯಗಳನ್ನು ರವಾನಿಸುತ್ತದೆ.
ವರ್ತನೆಯ ವಿಷಯ new BehaviorSubject( defaultData<T> ) - ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, ವಿಷಯದ ಸಾಮಾನ್ಯ ಪ್ರಕಾರ. ಇನ್ಪುಟ್ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಚಂದಾದಾರರಾಗುವಾಗ ರವಾನೆಯಾಗುವ ಕೊನೆಯ ಸಂಚಿಕೆಯ ಡೇಟಾವನ್ನು ಯಾವಾಗಲೂ ಉಳಿಸುತ್ತದೆ. ಈ ವರ್ಗವು ಉಪಯುಕ್ತ ಮೌಲ್ಯ ವಿಧಾನವನ್ನು ಸಹ ಹೊಂದಿದೆ, ಇದು ಸ್ಟ್ರೀಮ್ನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ರಿಪ್ಲೇ ವಿಷಯ new ReplaySubject(bufferSize?: number, windowTime?: number) - ಇನ್ಪುಟ್ ಐಚ್ಛಿಕವಾಗಿ ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಅದು ಸ್ವತಃ ಸಂಗ್ರಹಿಸುವ ಮೌಲ್ಯಗಳ ಬಫರ್‌ನ ಗಾತ್ರ, ಮತ್ತು ಎರಡನೆಯದಾಗಿ ನಮಗೆ ಬದಲಾವಣೆಗಳು ಬೇಕಾಗುತ್ತವೆ.
AsyncSubject new AsyncSubject() - ಚಂದಾದಾರರಾಗುವಾಗ ಏನೂ ಆಗುವುದಿಲ್ಲ ಮತ್ತು ಮೌಲ್ಯವು ಪೂರ್ಣಗೊಂಡಾಗ ಮಾತ್ರ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಸ್ಟ್ರೀಮ್ನ ಕೊನೆಯ ಮೌಲ್ಯವನ್ನು ಮಾತ್ರ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
WebSocketSubject new WebSocketSubject(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>) - ದಸ್ತಾವೇಜನ್ನು ಅವನ ಬಗ್ಗೆ ಮೌನವಾಗಿದೆ ಮತ್ತು ನಾನು ಅವನನ್ನು ಮೊದಲ ಬಾರಿಗೆ ನೋಡುತ್ತಿದ್ದೇನೆ. ಅವನು ಏನು ಮಾಡುತ್ತಾನೆಂದು ಯಾರಿಗಾದರೂ ತಿಳಿದಿದ್ದರೆ, ದಯವಿಟ್ಟು ಬರೆಯಿರಿ ಮತ್ತು ನಾವು ಅದನ್ನು ಸೇರಿಸುತ್ತೇವೆ.
ಫ್ಯೂ. ಸರಿ, ನಾನು ಇಂದು ನಿಮಗೆ ಹೇಳಲು ಬಯಸಿದ ಎಲ್ಲವನ್ನೂ ನಾವು ಒಳಗೊಂಡಿದೆ. ಈ ಮಾಹಿತಿಯು ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಉಪಯುಕ್ತ ಮಾಹಿತಿ ಟ್ಯಾಬ್‌ನಲ್ಲಿ ನೀವು ಉಲ್ಲೇಖಗಳ ಪಟ್ಟಿಯನ್ನು ನೀವೇ ಓದಬಹುದು.
ಉಪಯುಕ್ತ ಮಾಹಿತಿ
ಮೂಲ: www.habr.com