MERN Stack ಕಲಿಯುವಿಕೆಯ 39ನೇ ದಿನ
ನಾನು ನನ್ನ MERN stack ಪ್ರಯಾಣದ 39ನೇ ದಿನದಲ್ಲಿದ್ದೇನೆ.
ನಿನ್ನೆ ನಾನು GET ಮತ್ತು POST ನಂತಹ HTTP verbs ಬಗ್ಗೆ ಅಧ್ಯಯನ ಮಾಡಿದೆ. ಇಂದು ನಾನು backend operations ಮೇಲೆ ಗಮನ ಹರಿಸಿದೆ. ಸರ್ವರ್ಗಳು data streams ಮತ್ತು body parsing ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನಾನು ಅಧ್ಯಯನ ಮಾಡಿದೆ.
ಬಳಕೆದಾರರು ಫಾರ್ಮ್ ಅಥವಾ ಫೈಲ್ ಅನ್ನು ಕಳುಹಿಸಿದಾಗ, ಸರ್ವರ್ ಅದನ್ನು ಒಂದೇ ಬಾರಿಗೆ ಪಡೆಯುವುದಿಲ್ಲ. ಡೇಟಾ ಸಣ್ಣ ತುಣುಕುಗಳಲ್ಲಿ ಬರುತ್ತದೆ. ಈ ತುಣುಕುಗಳನ್ನು chunks ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
Node.js ಮೆಮೊರಿಯನ್ನು ಉಳಿಸಲು streams ಅನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ದೊಡ್ಡ ಫೈಲ್ ಅನ್ನು ತಕ್ಷಣವೇ ನಿಮ್ಮ ಸರ್ವರ್ ಮೆಮೊರಿಯಲ್ಲಿ ಲೋಡ್ ಮಾಡುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ಡೇಟಾವನ್ನು ಸಣ್ಣ ಭಾಗಗಳಲ್ಲಿ ನಿರ್ವಹಿಸುತ್ತದೆ.
ಈ ಪ್ರಕ್ರಿಯೆಯು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:
- ಬರುವ POST ಡೇಟಾ 'Readable Stream' ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
- ಸರ್ವರ್ ಬೈನರಿ ಡೇಟಾದ ಸಣ್ಣ chunks ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.
- ನೀವು ಡೇಟಾವನ್ನು ಬಳಸುವ ಮೊದಲು ಈ chunks ಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು.
Node.js ನಲ್ಲಿ, ನಿಮಗೆ ತಕ್ಷಣವೇ request body ಸಿಗುವುದಿಲ್ಲ. ನೀವು ನಿರ್ದಿಷ್ಟ network events ಗಳನ್ನು ಗಮನಿಸಬೇಕು:
req.on("data"): ಹೊಸ chunk ಬಂದ度に ಈ event ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ. ನೀವು ಈ chunks ಗಳನ್ನು ಒಂದು array ನಲ್ಲಿ ಉಳಿಸಿಕೊಳ್ಳುತ್ತೀರಿ.req.on("end"): stream ಮುಗಿದಾಗ ಈ event ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ. ಎಲ್ಲಾ ಡೇಟಾ ಬಂದಿದೆ ಎಂದು ಇದು ನಿಮಗೆ ತಿಳಿಸುತ್ತದೆ.
ತುಣುಕುಗಳನ್ನು ಜೋಡಿಸಲು ನೀವು Buffer.concat ಅನ್ನು ಬಳಸುತ್ತೀರಿ. ನಂತರ ನೀವು ಅವುಗಳನ್ನು string ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತೀರಿ.
ಈ ವಿಧಾನವು ನಿಮ್ಮ ಸರ್ವರ್ ಅನ್ನು ವೇಗವಾಗಿ ಮತ್ತು ದಕ್ಷವಾಗಿರಿಸುತ್ತದೆ. ಇದು ದೊಡ್ಡ ಫೈಲ್ಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಮೆಮೊರಿ ಕ್ರ್ಯಾಶ್ ಆಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ.
ಮೂಲ: https://dev.to/ali_hamza_589ec7b3eb6688d/day-39-of-learning-mern-stack-hkp