ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್: ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಪೈಪ್‌ಲೈನ್ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ

ಇಂದಿನ ಡೇಟಾ-ತೀವ್ರ ಜಗತ್ತಿನಲ್ಲಿ, ಮಾಹಿತಿಯನ್ನು ದಕ್ಷತೆಯಿಂದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಆಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಅತಿಮುಖ್ಯವಾಗಿದೆ. ನೀವು ಬಹುರಾಷ್ಟ್ರೀಯ ನಿಗಮಕ್ಕಾಗಿ ರಿಯಲ್-ಟೈಮ್ ಅನಾಲಿಟಿಕ್ಸ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ಜಾಗತಿಕ ಸಾಮಾಜಿಕ ವೇದಿಕೆಯಲ್ಲಿ ಬಳಕೆದಾರರ ಸಂವಹನಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರಲಿ, ಅಥವಾ ವಿಶ್ವಾದ್ಯಂತ ಸಾಧನಗಳಿಂದ IoT ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರಲಿ, ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಸಾಮರ್ಥ್ಯವು ಒಂದು ನಿರ್ಣಾಯಕ ಕೌಶಲ್ಯವಾಗಿದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಫ್ರಂಟ್-ಎಂಡ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನಲ್ಲಿ ದೀರ್ಘಕಾಲದಿಂದ ಪ್ರಾಬಲ್ಯ ಹೊಂದಿದ್ದು, ವಿಶೇಷವಾಗಿ Node.js ಆಗಮನದೊಂದಿಗೆ ಸರ್ವರ್-ಸೈಡ್ ಮತ್ತು ಡೇಟಾ ಪ್ರೊಸೆಸಿಂಗ್ ಕಾರ್ಯಗಳಿಗಾಗಿ ಹೆಚ್ಚು ಶಕ್ತಿಶಾಲಿ ಸಾಧನವಾಗಿದೆ. ಈ ಪೋಸ್ಟ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನ ಮೂಲ ಪರಿಕಲ್ಪನೆಗಳನ್ನು, ವಿಶೇಷವಾಗಿ ಪೈಪ್‌ಲೈನ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ, ಮತ್ತು ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ದೃಢವಾದ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯುಳ್ಳ ಡೇಟಾ ಫ್ಲೋಗಳನ್ನು ರಚಿಸಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೇಗೆ ಅಧಿಕಾರ ನೀಡುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.

ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನ ಅಗತ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಸಾಂಪ್ರದಾಯಿಕ ಡೇಟಾ ಪ್ರೊಸೆಸಿಂಗ್ ಸಾಮಾನ್ಯವಾಗಿ ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡಿ ನಂತರ ಅವುಗಳನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಸಣ್ಣ, ಸ್ಥಿರ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಇದು ಪರಿಣಾಮಕಾರಿಯಾಗಿದ್ದರೂ, ಈ ಕೆಳಗಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಈ ವಿಧಾನವು ಬೇಗನೆ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ:

• ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾ: ಲಭ್ಯವಿರುವ RAM ಅನ್ನು ಮೀರಿದ ಡೇಟಾಸೆಟ್‌ಗಳು ಕ್ರ್ಯಾಶ್‌ಗಳಿಗೆ ಅಥವಾ ತೀವ್ರ ಕಾರ್ಯಕ್ಷಮತೆ ಕುಸಿತಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು.
• ನಿರಂತರ ಡೇಟಾ ಫ್ಲೋಗಳು: ಹಣಕಾಸು ವ್ಯಾಪಾರ ವೇದಿಕೆಗಳಿಂದ ಹಿಡಿದು ಲೈವ್ ಸೆನ್ಸರ್ ಮಾನಿಟರಿಂಗ್‌ವರೆಗಿನ ಅನೇಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ನಿರಂತರವಾಗಿ ಡೇಟಾವನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆ, ಇದು ಬ್ಯಾಚ್ ಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಅದಕ್ಷ ಮತ್ತು ಹಳೆಯದಾಗಿಸುತ್ತದೆ.
• ರಿಯಲ್-ಟೈಮ್ ಅವಶ್ಯಕತೆಗಳು: ವ್ಯವಹಾರಗಳು ಡೇಟಾ ಬಂದ ತಕ್ಷಣ ಪ್ರತಿಕ್ರಿಯಿಸಬೇಕಾಗುತ್ತದೆ, ಗಂಟೆಗಳು ಅಥವಾ ದಿನಗಳ ನಂತರ ಅಲ್ಲ.

ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಈ ಸವಾಲುಗಳನ್ನು ಡೇಟಾವನ್ನು ಘಟನೆಗಳ ಅಥವಾ ತುಣುಕುಗಳ ಅನುಕ್ರಮವಾಗಿ ಪರಿಗಣಿಸುವ ಮೂಲಕ ನಿಭಾಯಿಸುತ್ತದೆ, ಇವುಗಳನ್ನು ಹಂತಹಂತವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು. ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್‌ಗಾಗಿ ಕಾಯುವ ಬದಲು, ಲಭ್ಯವಾದಂತೆ ನಾವು ತುಣುಕುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತೇವೆ. ಈ ಆನ್-ಡಿಮಾಂಡ್ ಪ್ರೊಸೆಸಿಂಗ್ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನ ಹೆಗ್ಗುರುತಾಗಿದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳು ಎಂದರೇನು?

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಸ್ಟ್ರೀಮ್ ಎನ್ನುವುದು ಕಾಲಾನಂತರದಲ್ಲಿ ಡೇಟಾದ ಅನುಕ್ರಮವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಅಮೂರ್ತತೆಯಾಗಿದೆ. ಇದನ್ನು ನೀರಿನ ಪೈಪ್‌ನಂತೆ ಯೋಚಿಸಿ: ಡೇಟಾ ಅದರ ಮೂಲಕ ಹರಿಯುತ್ತದೆ, ಮತ್ತು ನೀವು ಪೈಪ್‌ನ ವಿವಿಧ ಹಂತಗಳಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಬಹುದು. Node.js ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರೀಮ್ APIಗಳನ್ನು ಹೊಂದಿದೆ, ಅದು ಅದರ I/O ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಮೂಲಭೂತವಾಗಿದೆ, ಇದು ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಓದುವುದು, ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಸಾಕೆಟ್‌ಗಳಿಗೆ ಡೇಟಾ ಬರೆಯುವಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಅವುಗಳನ್ನು ದಕ್ಷವಾಗಿಸುತ್ತದೆ.

Node.js ನಲ್ಲಿ ನಾಲ್ಕು ಪ್ರಾಥಮಿಕ ರೀತಿಯ ಸ್ಟ್ರೀಮ್‌ಗಳಿವೆ:

• Readable Streams (ಓದಬಹುದಾದ ಸ್ಟ್ರೀಮ್‌ಗಳು): ಮೂಲದಿಂದ ಡೇಟಾವನ್ನು ಓದಲು ಬಳಸಲಾಗುತ್ತದೆ (ಉದಾ., ಒಂದು ಫೈಲ್, ಒಂದು ನೆಟ್‌ವರ್ಕ್ ಸಾಕೆಟ್).
• Writable Streams (ಬರೆಯಬಹುದಾದ ಸ್ಟ್ರೀಮ್‌ಗಳು): ಗಮ್ಯಸ್ಥಾನಕ್ಕೆ ಡೇಟಾವನ್ನು ಬರೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ (ಉದಾ., ಒಂದು ಫೈಲ್, ಒಂದು ನೆಟ್‌ವರ್ಕ್ ಸಾಕೆಟ್).
• Duplex Streams (ಡ್ಯುಪ್ಲೆಕ್ಸ್ ಸ್ಟ್ರೀಮ್‌ಗಳು): ಡೇಟಾವನ್ನು ಓದಬಹುದು ಮತ್ತು ಬರೆಯಬಹುದು (ಉದಾ., ಒಂದು ನೆಟ್‌ವರ್ಕ್ ಸಾಕೆಟ್).
• Transform Streams (ಪರಿವರ್ತನಾ ಸ್ಟ್ರೀಮ್‌ಗಳು): ಇದು ಒಂದು ವಿಶೇಷ ರೀತಿಯ ಡ್ಯುಪ್ಲೆಕ್ಸ್ ಸ್ಟ್ರೀಮ್ ಆಗಿದ್ದು, ಡೇಟಾ ಹಾದುಹೋಗುವಾಗ ಅದನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ ಅಥವಾ ಪರಿವರ್ತಿಸುತ್ತದೆ (ಉದಾ., ಫೈಲ್ ಅನ್ನು ಸಂಕುಚಿತಗೊಳಿಸುವುದು, ಡೇಟಾವನ್ನು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡುವುದು).

ಸ್ಟ್ರೀಮ್‌ಗಳ ನಿಜವಾದ ಶಕ್ತಿಯು ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡಿಸುವ ಸಾಮರ್ಥ್ಯದಲ್ಲಿದೆ, ಇದು ಕಾರ್ಯಾಚರಣೆಗಳ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ.

ಪೈಪ್‌ಲೈನ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಪರಿಚಯ

ಪೈಪ್‌ಲೈನ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಪರಿಣಾಮಕಾರಿ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನ ಬೆನ್ನೆಲುಬಾಗಿವೆ. ಅವು ನಿಮಗೆ ಅನುಕ್ರಮವಾಗಿ ಅನೇಕ ಸ್ಟ್ರೀಮ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಜೋಡಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಅಲ್ಲಿ ಒಂದು ಸ್ಟ್ರೀಮ್‌ನ ಔಟ್‌ಪುಟ್ ಮುಂದಿನದಕ್ಕೆ ಇನ್‌ಪುಟ್ ಆಗುತ್ತದೆ. ಇದು ಸಂಕೀರ್ಣ ಡೇಟಾ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಒಂದು ಘೋಷಣಾತ್ಮಕ ಮತ್ತು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮಾರ್ಗವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.

ನೀವು ದೊಡ್ಡ CSV ಫೈಲ್ ಅನ್ನು ಓದಬೇಕು, ನಿರ್ದಿಷ್ಟ ಸಾಲುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬೇಕು, ಉಳಿದ ಡೇಟಾವನ್ನು ಪರಿವರ್ತಿಸಬೇಕು (ಉದಾ., ಯೂನಿಟ್‌ಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದು ಅಥವಾ ದಿನಾಂಕಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು), ಮತ್ತು ನಂತರ ಸಂಸ್ಕರಿಸಿದ ಡೇಟಾವನ್ನು ಮತ್ತೊಂದು ಫೈಲ್‌ಗೆ ಬರೆಯಬೇಕು ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಪೈಪ್‌ಲೈನ್‌ಗಳಿಲ್ಲದೆ, ನೀವು ಬಫರ್‌ಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸಬಹುದು, ಡೇಟಾ ತುಣುಕುಗಳನ್ನು ನಿಭಾಯಿಸಬಹುದು ಮತ್ತು ಸಂಕೀರ್ಣ ಕಾಲ್‌ಬ್ಯಾಕ್ ಅಥವಾ ಪ್ರಾಮಿಸ್ ಚೈನ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು. ಪೈಪ್‌ಲೈನ್‌ಗಳೊಂದಿಗೆ, ನೀವು ಇದನ್ನು ಸ್ಪಷ್ಟ ಅನುಕ್ರಮವಾಗಿ ವ್ಯಕ್ತಪಡಿಸಬಹುದು:

ReadableStream (File) -> TransformStream (Filter) -> TransformStream (Transform) -> WritableStream (File)

ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಏಕೆ ನಿರ್ಣಾಯಕವಾಗಿವೆ

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗೆ ಸೇವೆ ಸಲ್ಲಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಡೇಟಾ ಸಾಮಾನ್ಯವಾಗಿ ವಿವಿಧ ಸ್ವರೂಪಗಳಲ್ಲಿ ಬರುತ್ತದೆ, ಪ್ರಾದೇಶಿಕ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಭಿನ್ನ ಪ್ರಕ್ರಿಯೆಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ, ಮತ್ತು ಲೇಟೆನ್ಸಿಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಗರಿಷ್ಠ ದಕ್ಷತೆಯೊಂದಿಗೆ ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ. ಪೈಪ್‌ಲೈನ್‌ಗಳು ಈ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ:

• ದಕ್ಷತೆ: ಡೇಟಾವನ್ನು ತುಣುಕುಗಳಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ವೇಗವಾದ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ವಿಭಿನ್ನ ಭೌಗೋಳಿಕ ಸ್ಥಳಗಳಿಂದ ಮತ್ತು ವಿವಿಧ ನೆಟ್‌ವರ್ಕ್ ಪರಿಸ್ಥಿತಿಗಳೊಂದಿಗೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವ ಬಳಕೆದಾರರಿಗೆ ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
• ಮಾಡ್ಯುಲಾರಿಟಿ: ಪೈಪ್‌ಲೈನ್‌ನ ಪ್ರತಿಯೊಂದು ಹಂತವು ಪ್ರತ್ಯೇಕ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಸ್ಟ್ರೀಮ್ ಆಗಿರಬಹುದು. ಇದು ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ, ಭೌಗೋಳಿಕವಾಗಿ ಹಂಚಿಕೆಯಾದ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳಲ್ಲಿ.
• ಸಂಯೋಜನೆ (Composability): ಪೈಪ್‌ಲೈನ್‌ಗಳು ಸರಳವಾದ ಸ್ಟ್ರೀಮ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಸಂಕೀರ್ಣ ಪ್ರೊಸೆಸಿಂಗ್ ತರ್ಕವನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ. ಇದು ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ತತ್ವಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ, ಸ್ವಚ್ಛ ಮತ್ತು ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ.
• ಸ್ಕೇಲೆಬಿಲಿಟಿ: ಡೇಟಾವನ್ನು ಹಂತಹಂತವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೂಲಕ, ಪೈಪ್‌ಲೈನ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಸ್ವಾಭಾವಿಕವಾಗಿ ಸ್ಕೇಲಿಂಗ್‌ಗೆ ಅನುಕೂಲಕರವಾಗಿವೆ. ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರೊಸೆಸಿಂಗ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹೆಚ್ಚಿಸುವ ಮೂಲಕ ಅಥವಾ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಅನೇಕ ನಿದರ್ಶನಗಳಲ್ಲಿ ವಿತರಿಸುವ ಮೂಲಕ ಹೆಚ್ಚಿದ ಡೇಟಾ ಪ್ರಮಾಣವನ್ನು ನಿಭಾಯಿಸಬಹುದು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರೀಮ್ ಪೈಪ್‌ಲೈನ್‌ಗಳಲ್ಲಿನ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು

ಪೈಪ್‌ಲೈನ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಿಕೊಳ್ಳಲು, ಕೆಲವು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ:

1. ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪೈಪಿಂಗ್ ಮಾಡುವುದು (`.pipe()`)

ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅತ್ಯಂತ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಯೆಂದರೆ `.pipe()` ವಿಧಾನ. ಇದು ReadableStream ಅನ್ನು WritableStream ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ. ಓದಬಹುದಾದ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಓದಿದ ಡೇಟಾವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬರೆಯಬಹುದಾದ ಸ್ಟ್ರೀಮ್‌ಗೆ ಬರೆಯಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: ಫೈಲ್ ಅನ್ನು ನಕಲಿಸುವುದು

ಇದು ಪೈಪಿಂಗ್‌ನ ಸರಳ ರೂಪವಾಗಿದೆ, ಇದು ಮೂಲಭೂತ ಸಂಪರ್ಕವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

            const fs = require('fs');

const readableStream = fs.createReadStream('input.txt');
const writableStream = fs.createWriteStream('output.txt');

readableStream.pipe(writableStream);

readableStream.on('end', () => {
  console.log('File copied successfully!');
});

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಡೇಟಾ `input.txt` ನಿಂದ `readableStream` ಮೂಲಕ ಹರಿಯುತ್ತದೆ, `writableStream` ಗೆ ಪೈಪ್ ಆಗುತ್ತದೆ, ಮತ್ತು ಅಂತಿಮವಾಗಿ `output.txt` ಗೆ ಬರೆಯಲ್ಪಡುತ್ತದೆ. `'end'` ಈವೆಂಟ್ ಇಡೀ ಫೈಲ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.

2. ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್‌ಗಳು (ಪರಿವರ್ತನಾ ಸ್ಟ್ರೀಮ್‌ಗಳು)

ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್‌ಗಳು ಪೈಪ್‌ಲೈನ್‌ಗಳೊಳಗಿನ ಡೇಟಾ ನಿರ್ವಹಣೆಯ ಕಾರ್ಯನಿರ್ವಾಹಕಗಳಾಗಿವೆ. ಅವು `Readable` ಮತ್ತು `Writable` ಎರಡೂ ಸ್ಟ್ರೀಮ್ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತವೆ, ಅವುಗಳನ್ನು ಪೈಪ್‌ಲೈನ್‌ನ ಮಧ್ಯದಲ್ಲಿ ಇರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ. ಡೇಟಾ ಹರಿದು ಬಂದಂತೆ, ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್ ಅದನ್ನು ಪೈಪ್‌ಲೈನ್‌ನ ಮುಂದಿನ ಸ್ಟ್ರೀಮ್‌ಗೆ ರವಾನಿಸುವ ಮೊದಲು ಅದನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು.

Node.js ಕಸ್ಟಮ್ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ರಚಿಸಲು `stream.Transform` ಕ್ಲಾಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಪಠ್ಯವನ್ನು ದೊಡ್ಡಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು

ಬರುತ್ತಿರುವ ಪಠ್ಯ ಡೇಟಾವನ್ನು ದೊಡ್ಡಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಒಂದು ಕಸ್ಟಮ್ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ರಚಿಸೋಣ.

            const { Transform } = require('stream');
const fs = require('fs');

class UppercaseTransform extends Transform {
  _transform(chunk, encoding, callback) {
    const uppercasedChunk = chunk.toString().toUpperCase();
    this.push(uppercasedChunk);
    callback();
  }
}

const readableStream = fs.createReadStream('input.txt');
const uppercaseStream = new UppercaseTransform();
const writableStream = fs.createWriteStream('output_uppercase.txt');

readableStream.pipe(uppercaseStream).pipe(writableStream);

uppercaseStream.on('finish', () => {
  console.log('Uppercase transformation complete!');
});

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, `UppercaseTransform` ಸ್ಟ್ರೀಮ್ ಡೇಟಾ ತುಣುಕುಗಳನ್ನು ಓದುತ್ತದೆ, ಅವುಗಳನ್ನು `toUpperCase()` ಬಳಸಿ ದೊಡ್ಡಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಮತ್ತು ನಂತರ ಪರಿವರ್ತಿತ ತುಣುಕನ್ನು ಪೈಪ್‌ಲೈನ್‌ನ ಮುಂದಿನ ಸ್ಟ್ರೀಮ್‌ಗೆ ತಳ್ಳುತ್ತದೆ. `_transform` ವಿಧಾನವು ಈ ಕಸ್ಟಮ್ ಸ್ಟ್ರೀಮ್‌ನ ತಿರುಳಾಗಿದೆ.

3. ಈವೆಂಟ್‌ಗಳು ಮತ್ತು ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ದೃಢವಾದ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ಗೆ ಈವೆಂಟ್‌ಗಳು ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆಯ ಬಗ್ಗೆ ಎಚ್ಚರಿಕೆಯ ಗಮನ ಬೇಕು. ಸ್ಟ್ರೀಮ್‌ಗಳು ವಿವಿಧ ಈವೆಂಟ್‌ಗಳನ್ನು ಹೊರಸೂಸುತ್ತವೆ, ಅವುಗಳೆಂದರೆ:

• 'data': ಡೇಟಾದ ಒಂದು ತುಣುಕು ಲಭ್ಯವಿದ್ದಾಗ ಹೊರಸೂಸಲ್ಪಡುತ್ತದೆ.
• 'end': ಸೇವಿಸಲು ಇನ್ನು ಮುಂದೆ ಡೇಟಾ ಇಲ್ಲದಿದ್ದಾಗ ಹೊರಸೂಸಲ್ಪಡುತ್ತದೆ.
• 'error': ದೋಷ ಸಂಭವಿಸಿದಾಗ ಹೊರಸೂಸಲ್ಪಡುತ್ತದೆ. ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ; ದೋಷವನ್ನು ನಿರ್ವಹಿಸದಿದ್ದರೆ, ಪ್ರಕ್ರಿಯೆಯು ಕ್ರ್ಯಾಶ್ ಆಗಬಹುದು.
• 'finish': ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಆಧಾರವಾಗಿರುವ ಗಮ್ಯಸ್ಥಾನಕ್ಕೆ ಫ್ಲಶ್ ಮಾಡಿದಾಗ ಬರೆಯಬಹುದಾದ ಬದಿಯಲ್ಲಿ ಹೊರಸೂಸಲ್ಪಡುತ್ತದೆ.
• 'close': ಆಧಾರವಾಗಿರುವ ಸಂಪನ್ಮೂಲ (ಉದಾ., ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್) ಮುಚ್ಚಿದಾಗ ಹೊರಸೂಸಲ್ಪಡುತ್ತದೆ.

ಅನೇಕ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪೈಪ್ ಮಾಡುವಾಗ, ಪೈಪ್‌ಲೈನ್‌ನ ಯಾವುದೇ ಹಂತದಲ್ಲಿ ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಹಿಡಿಯಲು ಪ್ರತಿಯೊಂದು ಸ್ಟ್ರೀಮ್‌ಗೆ ದೋಷ ನಿರ್ವಾಹಕಗಳನ್ನು ಲಗತ್ತಿಸುವುದು ಅತ್ಯಗತ್ಯ.

ಉದಾಹರಣೆ: ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ

            const fs = require('fs');

const readableStream = fs.createReadStream('non_existent_file.txt');
const writableStream = fs.createWriteStream('output.txt');

readableStream.on('error', (err) => {
  console.error('Error reading the input file:', err.message);
});

writableStream.on('error', (err) => {
  console.error('Error writing to the output file:', err.message);
});

readableStream.pipe(writableStream);

writableStream.on('finish', () => {
  console.log('Operation finished (or attempted).');
});

            

              
                Copy
              
            
          

ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, `non_existent_file.txt` ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, `readableStream` ಒಂದು `'error'` ಈವೆಂಟ್ ಅನ್ನು ಹೊರಸೂಸುತ್ತದೆ, ಮತ್ತು ನಮ್ಮ ನಿರ್ವಾಹಕ ಅದನ್ನು ಹಿಡಿಯುತ್ತದೆ, ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್ ಆಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ.

4. ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ (Backpressure)

ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನಲ್ಲಿ ಒಂದು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಯಾಗಿದ್ದು, ವೇಗದ ಉತ್ಪಾದಕವು ನಿಧಾನಗತಿಯ ಗ್ರಾಹಕವನ್ನು ಮುಳುಗಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಓದಬಹುದಾದ ಸ್ಟ್ರೀಮ್, ಬರೆಯಬಹುದಾದ ಸ್ಟ್ರೀಮ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದಕ್ಕಿಂತ ವೇಗವಾಗಿ ಡೇಟಾವನ್ನು ಉತ್ಪಾದಿಸುತ್ತಿರುವಾಗ, ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಯಾಂತ್ರಿಕತೆಗಳು ಉತ್ಪಾದಕನಿಗೆ ನಿಧಾನಗೊಳಿಸಲು ಸಂಕೇತ ನೀಡುತ್ತವೆ. Node.js ಸ್ಟ್ರೀಮ್‌ಗಳು `.pipe()` ವಿಧಾನವನ್ನು ಬಳಸುವಾಗ ಇದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ. ಬರೆಯಬಹುದಾದ ಸ್ಟ್ರೀಮ್ ಹೆಚ್ಚು ಡೇಟಾಗೆ ಸಿದ್ಧವಾಗುವವರೆಗೆ ಓದಬಹುದಾದ ಸ್ಟ್ರೀಮ್ ಡೇಟಾ ಹೊರಸೂಸುವುದನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ. ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ ವೈವಿಧ್ಯಮಯ ನೆಟ್‌ವರ್ಕ್ ವೇಗಗಳು ಅಥವಾ ಸರ್ವರ್ ಲೋಡ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ಸ್ಥಿರತೆಗೆ ಅತ್ಯಗತ್ಯ.

ಸುಧಾರಿತ ಪೈಪ್‌ಲೈನ್ ಪ್ಯಾಟರ್ನ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳು

Node.js ಸ್ಟ್ರೀಮ್‌ಗಳು ಅಡಿಪಾಯವನ್ನು ಒದಗಿಸಿದರೆ, ಹಲವಾರು ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಪ್ಯಾಟರ್ನ್‌ಗಳು ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ, ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗಾಗಿ.

1. RxJS (Reactive Extensions for JavaScript)

RxJS, ಅಬ್ಸರ್ವಬಲ್ಸ್ (Observables) ಬಳಸಿ ರಿಯಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗಾಗಿ ಒಂದು ಜನಪ್ರಿಯ ಲೈಬ್ರರಿಯಾಗಿದೆ. ಇವು ಸ್ಟ್ರೀಮ್‌ಗಳಂತೆಯೇ ಇರುತ್ತವೆ ಆದರೆ ಅಸಿಂಕ್ರೋನಸ್ ಡೇಟಾ ಅನುಕ್ರಮಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚು ಶಕ್ತಿಶಾಲಿ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ. ಅಸಿಂಕ್ರೋನಸ್ ಮತ್ತು ಈವೆಂಟ್-ಆಧಾರಿತ ಕೋಡ್ ಅನ್ನು ಸಂಯೋಜಿಸುವಲ್ಲಿ RxJS ಉತ್ತಮವಾಗಿದೆ.

ಪ್ರಮುಖ RxJS ಪರಿಕಲ್ಪನೆಗಳು:

• ಅಬ್ಸರ್ವಬಲ್ಸ್ (Observables): ಕಾಲಾನಂತರದಲ್ಲಿ ಮೌಲ್ಯಗಳ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• ಆಪರೇಟರ್‌ಗಳು (Operators): ಅಬ್ಸರ್ವಬಲ್ಸ್‌ಗಳನ್ನು ಪರಿವರ್ತಿಸುವ, ಸಂಯೋಜಿಸುವ ಅಥವಾ ನಿರ್ವಹಿಸುವ ಫಂಕ್ಷನ್‌ಗಳು (ಉದಾ., `map`, `filter`, `merge`, `switchMap`). ಇವು Node.js ನಲ್ಲಿನ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್‌ಗಳಿಗೆ ಸಮಾನವಾಗಿವೆ ಆದರೆ ಆಗಾಗ್ಗೆ ಹೆಚ್ಚು ಘೋಷಣಾತ್ಮಕ ಮತ್ತು ಸಂಯೋಜಿತವಾಗಿರುತ್ತವೆ.

ಉದಾಹರಣೆ: RxJS ನೊಂದಿಗೆ ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಮ್ಯಾಪಿಂಗ್

ವಿವಿಧ ಜಾಗತಿಕ ಪ್ರದೇಶಗಳಿಂದ ಬಳಕೆದಾರರ ಈವೆಂಟ್‌ಗಳ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು, ಯುರೋಪ್‌ನಿಂದ ಹುಟ್ಟುವ ಈವೆಂಟ್‌ಗಳಿಗಾಗಿ ಫಿಲ್ಟರ್ ಮಾಡುವುದು, ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಒಂದು ಪ್ರಮಾಣಿತ ಸ್ವರೂಪಕ್ಕೆ ಮ್ಯಾಪ್ ಮಾಡುವುದು ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ.

            import { from } from 'rxjs';
import { filter, map } from 'rxjs/operators';

const userEvents = [
  { userId: 1, region: 'USA', action: 'click' },
  { userId: 2, region: 'Europe', action: 'scroll' },
  { userId: 3, region: 'Asia', action: 'submit' },
  { userId: 4, region: 'Europe', action: 'hover' },
  { userId: 5, region: 'USA', action: 'click' },
];

const europeanScrolls$ = from(userEvents).pipe(
  filter(event => event.region === 'Europe' && event.action === 'scroll'),
  map(event => ({ userId: event.userId, source: 'european_scroll' }))
);

europeanScrolls$.subscribe(
  event => console.log('Processed European Scroll:', event),
  error => console.error('An error occurred:', error),
  () => console.log('Finished processing European scrolls.')
);

            

              
                Copy
              
            
          

RxJS ಆಪರೇಟರ್‌ಗಳು ಹೆಚ್ಚು ಓದಬಲ್ಲ, ಫಂಕ್ಷನಲ್ ಶೈಲಿಯಲ್ಲಿ ಪರಿವರ್ತನೆಗಳನ್ನು ಚೈನ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತವೆ. `from()` ಒಂದು ಅರೇಯಿಂದ ಅಬ್ಸರ್ವಬಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, `filter()` ನಿರ್ದಿಷ್ಟ ಈವೆಂಟ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ಮತ್ತು `map()` ಡೇಟಾವನ್ನು ಪರಿವರ್ತಿಸುತ್ತದೆ. ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾದ ಸಂಕೀರ್ಣ ಅಸಿಂಕ್ರೋನಸ್ ವರ್ಕ್‌ಫ್ಲೋಗಳಿಗೆ ಈ ಪ್ಯಾಟರ್ನ್ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ.

2. `pipeline` ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಸ್ಟ್ರೀಮ್ ಚೈನಿಂಗ್ (Node.js v15+)

Node.js v15 ರಿಂದ ಲಭ್ಯವಿರುವ `stream.pipeline` ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಲು Node.js ಹೆಚ್ಚು ಆಧುನಿಕ ಮತ್ತು ದೃಢವಾದ ಮಾರ್ಗವನ್ನು ಪರಿಚಯಿಸಿದೆ. ಇದು ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಹಸ್ತಚಾಲಿತ `.pipe()` ಚೈನಿಂಗ್‌ಗೆ ಹೋಲಿಸಿದರೆ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಚೈನ್ ಮಾಡಲು ಹೆಚ್ಚು ರಚನಾತ್ಮಕ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ದೀರ್ಘ ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗಾಗಿ.

`stream.pipeline` ನ ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳು:

• ಸ್ವಯಂಚಾಲಿತ ದೋಷ ನಿರ್ವಹಣೆ: ಯಾವುದೇ ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದಾಗ ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಸ್ಟ್ರೀಮ್‌ಗಳು ಸರಿಯಾಗಿ ನಾಶವಾಗುವುದನ್ನು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಸಂಪನ್ಮೂಲ ಸೋರಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ.
• ಕೇಂದ್ರೀಕೃತ ಕಾಲ್‌ಬ್ಯಾಕ್: ಒಂದೇ ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಸಂಪೂರ್ಣ ಪೈಪ್‌ಲೈನ್‌ನ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಅಥವಾ ದೋಷವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: `stream.pipeline` ಬಳಸುವುದು

            const { pipeline } = require('stream');
const fs = require('fs');

const readableStream = fs.createReadStream('input.txt');
// Assume UppercaseTransform class is defined as above
const uppercaseStream = new UppercaseTransform();
const writableStream = fs.createWriteStream('output_pipeline.txt');

pipeline(
  readableStream,
  uppercaseStream,
  writableStream,
  (err) => {
    if (err) {
      console.error('Pipeline failed:', err);
    } else {
      console.log('Pipeline succeeded.');
    }
  }
);

            

              
                Copy
              
            
          

ಈ `pipeline` ಫಂಕ್ಷನ್ ಪೈಪಿಂಗ್ ಮತ್ತು ದೋಷ ಪ್ರಸಾರವನ್ನು ಸೊಗಸಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ, ಸಂಕೀರ್ಣ ಸ್ಟ್ರೀಮ್ ಸಂಯೋಜನೆಗಳನ್ನು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿಸುತ್ತದೆ.

3. ಈವೆಂಟ್ ಎಮಿಟರ್‌ಗಳು ಮತ್ತು ಕಸ್ಟಮ್ ಸ್ಟ್ರೀಮ್‌ಗಳು

ಹೆಚ್ಚು ವಿಶೇಷವಾದ ಪ್ರೊಸೆಸಿಂಗ್ ಅಗತ್ಯಗಳಿಗಾಗಿ, ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಕಸ್ಟಮ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ರಚಿಸಬೇಕಾಗಬಹುದು. ಎಲ್ಲಾ Node.js ಸ್ಟ್ರೀಮ್‌ಗಳು `EventEmitter` ನಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಬಂದಿವೆ, ಅವುಗಳಿಗೆ ಈವೆಂಟ್-ಚಾಲಿತ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ. `stream.Readable`, `stream.Writable`, ಅಥವಾ `stream.Transform` ಅನ್ನು ವಿಸ್ತರಿಸುವ ಮೂಲಕ, ಬಾಹ್ಯ APIಗಳು ಅಥವಾ ಕಸ್ಟಮ್ ಡೇಟಾ ಸೀರಿಯಲೈಸೇಶನ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವಂತಹ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿಶಿಷ್ಟ ಅವಶ್ಯಕತೆಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ನೀವು ಕಸ್ಟಮ್ ಡೇಟಾ ಪ್ರೊಸೆಸಿಂಗ್ ಘಟಕಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು.

ಜಾಗತಿಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಪೈಪ್‌ಲೈನ್‌ಗಳ ಪ್ರಾಯೋಗಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು

ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಪೈಪ್‌ಲೈನ್‌ಗಳ ಅಪ್ಲಿಕೇಶನ್ ವಿಶಾಲವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಜಾಗತಿಕ ಸೇವೆಗಳಿಗೆ:

1. ರಿಯಲ್-ಟೈಮ್ ಅನಾಲಿಟಿಕ್ಸ್ ಮತ್ತು ಮಾನಿಟರಿಂಗ್

ಜಾಗತಿಕ ಸೇವೆಗಳು ವಿಶ್ವಾದ್ಯಂತ ಸರ್ವರ್‌ಗಳು ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗಳಿಂದ ಅಪಾರ ಪ್ರಮಾಣದ ಲಾಗ್ ಡೇಟಾ, ಬಳಕೆದಾರರ ಸಂವಹನ ಈವೆಂಟ್‌ಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆ. ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಈ ಡೇಟಾವನ್ನು ರಿಯಲ್-ಟೈಮ್‌ನಲ್ಲಿ ಗ್ರಹಿಸಬಹುದು, ಅದನ್ನು ಒಟ್ಟುಗೂಡಿಸಬಹುದು, ಅನಗತ್ಯ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬಹುದು, ವೈಪರೀತ್ಯಗಳನ್ನು ಗುರುತಿಸಬಹುದು, ಮತ್ತು ಅದನ್ನು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳು ಅಥವಾ ಎಚ್ಚರಿಕೆ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ನೀಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ಒಂದು CDN ಪೂರೈಕೆದಾರರು ಖಂಡಗಳಾದ್ಯಂತ ಸಂಚಾರ ಮಾದರಿಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು, ಹೆಚ್ಚಿನ ದೋಷ ದರಗಳನ್ನು ಹೊಂದಿರುವ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು, ಮತ್ತು ಸಂಚಾರವನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮರುಮಾರ್ಗ ಮಾಡಲು ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

2. ಡೇಟಾ ಪರಿವರ್ತನೆ ಮತ್ತು ETL (Extract, Transform, Load)

ವೈವಿಧ್ಯಮಯ ಜಾಗತಿಕ ಮೂಲಗಳಿಂದ (ಉದಾ., ವಿಭಿನ್ನ ಪ್ರಾದೇಶಿಕ ಡೇಟಾಬೇಸ್‌ಗಳು, ವಿಭಿನ್ನ ಡೇಟಾ ಸ್ವರೂಪಗಳೊಂದಿಗೆ ಪಾಲುದಾರ APIಗಳು) ಡೇಟಾವನ್ನು ಸಂಯೋಜಿಸುವಾಗ, ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಅಮೂಲ್ಯವಾಗಿವೆ. ಅವು ಡೇಟಾವನ್ನು ಓದಬಹುದು, ಅದನ್ನು ಸ್ಥಿರ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದು, ಸಾಂದರ್ಭಿಕ ಮಾಹಿತಿಯೊಂದಿಗೆ (ಹಣಕಾಸು ಡೇಟಾಗೆ ಕರೆನ್ಸಿ ಪರಿವರ್ತನೆಯಂತಹ) ಅದನ್ನು ಸಮೃದ್ಧಗೊಳಿಸಬಹುದು, ಮತ್ತು ನಂತರ ಅದನ್ನು ಡೇಟಾ ವೇರ್‌ಹೌಸ್ ಅಥವಾ ವಿಶ್ಲೇಷಣಾತ್ಮಕ ವೇದಿಕೆಗೆ ಲೋಡ್ ಮಾಡಬಹುದು.

ಉದಾಹರಣೆ: ಇ-ಕಾಮರ್ಸ್ ಆರ್ಡರ್ ಪ್ರೊಸೆಸಿಂಗ್

ಅಂತರರಾಷ್ಟ್ರೀಯ ಇ-ಕಾಮರ್ಸ್ ವೇದಿಕೆಯು ಡಜನ್‌ಗಟ್ಟಲೆ ದೇಶಗಳಲ್ಲಿನ ಗ್ರಾಹಕರಿಂದ ಆರ್ಡರ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಬಹುದು. ಒಂದು ಪೈಪ್‌ಲೈನ್ ಹೀಗೆ ಮಾಡಬಹುದು:

• ಸಂದೇಶ ಕ್ಯೂನಿಂದ (ಉದಾ., Kafka, RabbitMQ) ಒಳಬರುವ ಆರ್ಡರ್ ಡೇಟಾವನ್ನು ಓದುವುದು.
• ಆರ್ಡರ್ ಪೇಲೋಡ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು (ಇದು JSON ಅಥವಾ XML ನಲ್ಲಿ ಇರಬಹುದು).
• ಜಾಗತಿಕ ಗ್ರಾಹಕ ಡೇಟಾಬೇಸ್ ವಿರುದ್ಧ ಗ್ರಾಹಕರ ವಿವರಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದು.
• ಕರೆನ್ಸಿಗಳು ಮತ್ತು ಉತ್ಪನ್ನದ ಬೆಲೆಗಳನ್ನು ಮೂಲ ಕರೆನ್ಸಿಗೆ ಪರಿವರ್ತಿಸುವುದು.
• ಗಮ್ಯಸ್ಥಾನ ದೇಶ ಮತ್ತು ಉತ್ಪನ್ನದ ಪ್ರಕಾರವನ್ನು ಆಧರಿಸಿ ಸೂಕ್ತವಾದ ಶಿಪ್ಪಿಂಗ್ ವಾಹಕವನ್ನು ನಿರ್ಧರಿಸುವುದು.
• ಸಂಸ್ಕರಿಸಿದ ಆರ್ಡರ್ ಅನ್ನು ಪೂರೈಸುವ ವ್ಯವಸ್ಥೆಗೆ ಬರೆಯುವುದು ಮತ್ತು ದಾಸ್ತಾನು ನವೀಕರಿಸುವುದು.

ಈ ಪ್ರತಿಯೊಂದು ಹಂತಗಳು ಪೈಪ್‌ಲೈನ್‌ನೊಳಗಿನ ವಿಭಿನ್ನ ಸ್ಟ್ರೀಮ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿರಬಹುದು, ದಿನಕ್ಕೆ ಲಕ್ಷಾಂತರ ಆರ್ಡರ್‌ಗಳಿದ್ದರೂ ಸಹ ದಕ್ಷ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ.

3. WebSocket ಮತ್ತು ರಿಯಲ್-ಟೈಮ್ ಸಂವಹನ

ರಿಯಲ್-ಟೈಮ್ ನವೀಕರಣಗಳನ್ನು ಅವಲಂಬಿಸಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ಲೈವ್ ಚಾಟ್, ಸಹಕಾರಿ ಎಡಿಟಿಂಗ್ ಉಪಕರಣಗಳು, ಅಥವಾ ಸ್ಟಾಕ್ ಟಿಕ್ಕರ್‌ಗಳಂತಹವು, ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ. WebSocket ಸಂಪರ್ಕಗಳು ಅಂತರ್ಗತವಾಗಿ ಸಂದೇಶಗಳ ಸ್ಟ್ರೀಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ. ಸಂದೇಶಗಳ ಹರಿವನ್ನು ನಿರ್ವಹಿಸಲು, ಬಳಕೆದಾರರ ಚಂದಾದಾರಿಕೆಗಳ ಆಧಾರದ ಮೇಲೆ ಅವುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು, ವಿಭಿನ್ನ ಕ್ಲೈಂಟ್ ಪ್ರಕಾರಗಳಿಗೆ ಅವುಗಳನ್ನು ಪರಿವರ್ತಿಸಲು, ಮತ್ತು ಪ್ರಸಾರವನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸಲು ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

4. ದೊಡ್ಡ ಫೈಲ್ ಪ್ರೊಸೆಸಿಂಗ್

ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಮತ್ತು ಅಪ್‌ಲೋಡ್ ಮಾಡುವುದು (ಉದಾ., ವೀಡಿಯೊ ಎನ್‌ಕೋಡಿಂಗ್, ವರದಿ ಉತ್ಪಾದನೆ) ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದೆ. Node.js ಸ್ಟ್ರೀಮ್‌ಗಳು ಮತ್ತು ಪೈಪ್‌ಲೈನ್‌ಗಳು ಇದಕ್ಕಾಗಿ ಪರಿಪೂರ್ಣವಾಗಿವೆ. ಟ್ರಾನ್ಸ್‌ಕೋಡಿಂಗ್‌ಗಾಗಿ ಮಲ್ಟಿ-ಗಿಗಾಬೈಟ್ ವೀಡಿಯೊ ಫೈಲ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವ ಬದಲು, ಫೈಲ್‌ನ ಭಾಗಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಓದಲು, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು, ಮತ್ತು ಬರೆಯಲು ನೀವು ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್‌ಗಳ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಬಳಸಬಹುದು, ಇದು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ತೀವ್ರವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ.

ಜಾಗತಿಕ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್‌ಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ವೈಫಲ್ಯಕ್ಕಾಗಿ ವಿನ್ಯಾಸ: ಸಮಗ್ರ ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಮರುಪ್ರಯತ್ನ ಯಾಂತ್ರಿಕತೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ. ವಿತರಿಸಿದ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆಗಳು ಅಥವಾ ಸರ್ವರ್ ಸ್ಥಗಿತಗಳು ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿದೆ.
• ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ: ವಿವಿಧ ಪ್ರದೇಶಗಳಲ್ಲಿ ಥ್ರೋಪುಟ್, ಲೇಟೆನ್ಸಿ, ಮತ್ತು ಸಂಪನ್ಮೂಲ ಬಳಕೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಲಾಗಿಂಗ್ ಮತ್ತು ಮಾನಿಟರಿಂಗ್ ಉಪಕರಣಗಳನ್ನು ಬಳಸಿ.
• ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ: ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗಾಗಿ ಯಾವಾಗಲೂ ಇನ್-ಮೆಮೊರಿ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಿಂತ ಸ್ಟ್ರೀಮ್-ಆಧಾರಿತ ಪ್ರೊಸೆಸಿಂಗ್‌ಗೆ ಆದ್ಯತೆ ನೀಡಿ.
• ಡೇಟಾ ಸ್ವರೂಪಗಳನ್ನು ನಿರ್ವಹಿಸಿ: ವಿವಿಧ ಪ್ರದೇಶಗಳಲ್ಲಿ ಪ್ರಚಲಿತದಲ್ಲಿರಬಹುದಾದ ವೈವಿಧ್ಯಮಯ ಡೇಟಾ ಎನ್‌ಕೋಡಿಂಗ್‌ಗಳು (ಉದಾ., UTF-8, ವಿಭಿನ್ನ ಅಕ್ಷರ ಸೆಟ್‌ಗಳು) ಮತ್ತು ಸ್ವರೂಪಗಳನ್ನು (JSON, XML, CSV, ಪ್ರೋಟೋಕಾಲ್ ಬಫರ್‌ಗಳು) ನಿರ್ವಹಿಸಲು ಸಿದ್ಧರಾಗಿರಿ.
• ಅಂತರರಾಷ್ಟ್ರೀಕರಣ ಮತ್ತು ಸ್ಥಳೀಕರಣ: ನಿಮ್ಮ ಪ್ರೊಸೆಸಿಂಗ್ ಬಳಕೆದಾರ-ಮುಖಿ ಡೇಟಾ ಪರಿವರ್ತನೆಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದರೆ (ಉದಾ., ದಿನಾಂಕಗಳು, ಸಂಖ್ಯೆಗಳು, ಕರೆನ್ಸಿಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು), ನಿಮ್ಮ ಸ್ಟ್ರೀಮ್‌ಗಳು ಸ್ಥಳೀಕರಣ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಸರಿಹೊಂದಿಸಬಹುದೆಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಭದ್ರತೆ: ಪೈಪ್‌ಲೈನ್‌ಗಳ ಮೂಲಕ ಹಾದುಹೋಗುವ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ ಮತ್ತು ಮೌಲ್ಯೀಕರಿಸಿ, ವಿಶೇಷವಾಗಿ ಡೇಟಾ ಬಾಹ್ಯ ಅಥವಾ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದ ಮೂಲಗಳಿಂದ ಬಂದಿದ್ದರೆ. ಸಾಗಣೆಯಲ್ಲಿರುವ ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಗಾಗಿ ಡೇಟಾ ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ.
• ಸರಿಯಾದ ಉಪಕರಣಗಳನ್ನು ಆರಿಸಿ: Node.js ಸ್ಟ್ರೀಮ್‌ಗಳು ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ರಿಯಾಕ್ಟಿವ್ ಪ್ಯಾಟರ್ನ್‌ಗಳಿಗಾಗಿ RxJS ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಅಥವಾ ನಿಮ್ಮ ಅಗತ್ಯಗಳು ತುಂಬಾ ಅತ್ಯಾಧುನಿಕವಾದರೆ ವಿಶೇಷ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳನ್ನು ಪರಿಗಣಿಸಿ.

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್, ವಿಶೇಷವಾಗಿ ಪೈಪ್‌ಲೈನ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಮೂಲಕ, ಆಧುನಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ದಕ್ಷ ಮಾದರಿಯನ್ನು ನೀಡುತ್ತದೆ. Node.js ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರೀಮ್ APIಗಳು, RxJS ನಂತಹ ಲೈಬ್ರರಿಗಳು, ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್‌ಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಸ್ಕೇಲೆಬಲ್, ಸ್ಥಿತಿಸ್ಥಾಪಕ, ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯುಳ್ಳ ಡೇಟಾ ಫ್ಲೋಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ವಿವಿಧ ನೆಟ್‌ವರ್ಕ್ ಪರಿಸ್ಥಿತಿಗಳು, ವೈವಿಧ್ಯಮಯ ಡೇಟಾ ಮೂಲಗಳು, ಮತ್ತು ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ರಿಯಲ್-ಟೈಮ್ ಮಾಹಿತಿಯೊಂದಿಗೆ ಸ್ಪರ್ಧಿಸಬೇಕಾದ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಪೈಪ್‌ಲೈನ್‌ಗಳಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ ಸಾಧಿಸುವುದು ಕೇವಲ ಒಂದು ಪ್ರಯೋಜನವಲ್ಲ - ಇದು ಒಂದು ಅವಶ್ಯಕತೆಯಾಗಿದೆ. ಪ್ರಪಂಚದ ಎಲ್ಲಿಂದಲಾದರೂ, ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಡೇಟಾವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಲ್ಲ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಈ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ.