ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಮಾದರಿಗಳು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಏಕ-ಥ್ರೆಡ್ ಭಾಷೆಯಾಗಿದೆ, ಅಂದರೆ ಇದು ಒಂದು ಸಾಲಿನ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಇದು ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಡೆವಲಪರ್ಗಳಿಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಈ ವಿಷಯದ ಬಗ್ಗೆ ಪ್ರಶ್ನೆಗಳು ತಾಂತ್ರಿಕ ಸಂದರ್ಶನಗಳಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ, ಈ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಗ್ರಹಿಸಲು ಮುಖ್ಯವಾಗಿದೆ.
ಅಭಿವರ್ಧಕರು ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವಾಗ ಅಥವಾ , ಮರಣದಂಡನೆಯ ಹರಿವು ಮೊದಲಿಗೆ ಸ್ವಲ್ಪ ಅನಿರೀಕ್ಷಿತವಾಗಿ ಕಾಣಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಸ್ಪಷ್ಟವಾದ ರಚನೆಯನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಕೋಡ್ನ ವಿವಿಧ ಭಾಗಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ನಿಖರವಾದ ಕ್ರಮವನ್ನು ನೀವು ನಿರ್ಧರಿಸಬಹುದು. ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ ಮತ್ತು ಈವೆಂಟ್ ಸಾಲುಗಳು.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಒಡೆಯುತ್ತೇವೆ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು . ಈ ವಿವರಣೆಯ ಅಂತ್ಯದ ವೇಳೆಗೆ, JavaScript ನ ಈವೆಂಟ್ ಲೂಪ್ ಹೇಗೆ ಆದ್ಯತೆ ನೀಡುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನೀವು ಸ್ಪಷ್ಟವಾದ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿರುತ್ತೀರಿ.
ಸಂದರ್ಶನದ ಪ್ರಶ್ನೆಗಳನ್ನು ನಿಭಾಯಿಸುವಾಗ ಅಥವಾ ಅಸಮಕಾಲಿಕ ಕೋಡ್ ಡೀಬಗ್ ಮಾಡುವಾಗ ಉಪಯುಕ್ತ ಕೌಶಲ್ಯವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಮರಣದಂಡನೆಯ ಕ್ರಮವನ್ನು ನಿರ್ಧರಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಈ ಲೇಖನವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರದರ್ಶಿಸಲು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಯಲ್ಲಿ ಧುಮುಕೋಣ.
| ಆಜ್ಞೆ | ಬಳಕೆಯ ಉದಾಹರಣೆ |
|---|---|
| setTimeout() | ಈ ಕಾರ್ಯವು ನಿರ್ದಿಷ್ಟ ವಿಳಂಬದ ನಂತರ ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಅನ್ನು ನಿಗದಿಪಡಿಸುತ್ತದೆ. ಕ್ರಿಯೆಗಳನ್ನು ವಿಳಂಬಗೊಳಿಸುವುದು ಅಥವಾ ಈವೆಂಟ್ ಲೂಪ್ಗೆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮುಂದೂಡುವುದು ಮುಂತಾದ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳನ್ನು ಅನುಕರಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಯಲ್ಲಿ, "B" ಮತ್ತು "E" ಲಾಗಿಂಗ್ ಅನ್ನು ವಿಳಂಬಗೊಳಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. |
| Promise.resolve() | ತಕ್ಷಣವೇ ಪರಿಹರಿಸುವ ಭರವಸೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ನೀವು ಅಸಮಕಾಲಿಕ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ ಆದರೆ ಬಾಹ್ಯ ಸ್ಥಿತಿಗಾಗಿ ಕಾಯಬೇಕಾಗಿಲ್ಲ. ಉದಾಹರಣೆಯಲ್ಲಿ, "B" ನಂತರ "D" ಅನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ಲಾಗ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. |
| then() | ಈ ವಿಧಾನವು ಭರವಸೆಗೆ ಕಾಲ್ಬ್ಯಾಕ್ ಅನ್ನು ಲಗತ್ತಿಸುತ್ತದೆ, ಅದು ಭರವಸೆಯನ್ನು ಪರಿಹರಿಸಿದಾಗ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಅಸಮಕಾಲಿಕ ಕಾರ್ಯವು ಪೂರ್ಣಗೊಂಡ ನಂತರ ನಿರ್ದಿಷ್ಟ ಕೋಡ್ ರನ್ ಆಗುತ್ತದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇಲ್ಲಿ, ಪರಿಹರಿಸಿದ ಭರವಸೆಯ ನಂತರ "D" ಲಾಗ್ ಆಗಿರುವುದನ್ನು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. |
| Event Loop | ಈವೆಂಟ್ ಲೂಪ್ ಎನ್ನುವುದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ನೇರವಾಗಿ ಆದೇಶವಲ್ಲದಿದ್ದರೂ, ಕೋಡ್ನಲ್ಲಿನ ಕಾರ್ಯಾಚರಣೆಗಳ ಕ್ರಮವನ್ನು ವಿವರಿಸಲು ಅದರ ಕಾರ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಪ್ರಸ್ತುತ ಸ್ಟಾಕ್ ಅನ್ನು ತೆರವುಗೊಳಿಸಿದ ನಂತರ ಇದು ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂನಿಂದ ಕಾರ್ಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. |
| Microtask Queue | ಪರಿಹರಿಸಿದ ಭರವಸೆಗಳಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಇದು ಆದ್ಯತೆಯ ಸರತಿಯಾಗಿದೆ. ಈವೆಂಟ್ ಲೂಪ್ನ ಟಾಸ್ಕ್ ಕ್ಯೂನಿಂದ (ಸೆಟ್ಟೈಮ್ಔಟ್ ಕಾಲ್ಬ್ಯಾಕ್ಗಳಂತಹ) ಕಾರ್ಯಗಳ ಮೊದಲು ಮೈಕ್ರೋಟಾಸ್ಕ್ಗಳನ್ನು (ಪರಿಹರಿಸಲಾದ ಭರವಸೆಗಳಂತೆ) ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಇದಕ್ಕಾಗಿಯೇ "ಇ" ಗಿಂತ ಮೊದಲು "ಡಿ" ಲಾಗ್ ಆಗುತ್ತದೆ. |
| Console.log() | ಡೀಬಗ್ ಮಾಡುವ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಕನ್ಸೋಲ್ಗೆ ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಕ್ರಮವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಇದು ಸಹಾಯಕವಾಗಿದೆ. |
| Callback Queue | ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂ ಪ್ರಸ್ತುತ ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಮುಗಿದ ನಂತರ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಿದ್ಧವಾಗಿರುವ ಕಾರ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ setTimeout ಗೆ ರವಾನಿಸಲಾದ ಕಾರ್ಯಗಳು. ಈವೆಂಟ್ ಲೂಪ್ ಈ ಕಾರ್ಯಗಳನ್ನು ಕರೆ ಸ್ಟಾಕ್ಗೆ ಚಲಿಸುತ್ತದೆ. |
| Zero Delay | ಒಂದು setTimeout() ವಿಳಂಬವನ್ನು 0 ಗೆ ಹೊಂದಿಸಿದಾಗ, ಎಲ್ಲಾ ಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಗಳು ಮತ್ತು ಮೈಕ್ರೋಟಾಸ್ಕ್ಗಳು ಪೂರ್ಣಗೊಂಡ ನಂತರ ಕಾಲ್ಬ್ಯಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಯಲ್ಲಿ, "E" ನೊಂದಿಗೆ ಕಾಲ್ಬ್ಯಾಕ್ ಅದರ ವಿಳಂಬ 0 ಆಗಿದ್ದರೂ ಸಹ "D" ನಂತರ ಚಲಿಸುತ್ತದೆ. |
| Asynchronous Execution | ಇದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಯಾಗಿದ್ದು, ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳು ಮುಖ್ಯ ಕೋಡ್ ಹರಿವಿನಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಮುಖ್ಯ ಥ್ರೆಡ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸದೆಯೇ ನೆಟ್ವರ್ಕ್ ವಿನಂತಿಗಳು ಅಥವಾ ಟೈಮರ್ಗಳಂತಹ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು JavaScript ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ. |
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಫ್ಲೋ ಎಕ್ಸ್ಪ್ಲೋರಿಂಗ್: ಸಿಂಕ್ರೊನಸ್ vs ಅಸಮಕಾಲಿಕ ಕೋಡ್
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ, ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕೋಡ್ನ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕ್ರಮವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ, ವಿಶೇಷವಾಗಿ ವ್ಯವಹರಿಸುವಾಗ ಮತ್ತು . ಈವೆಂಟ್ ಲೂಪ್ ಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಗಳನ್ನು ಮೊದಲು ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಸರತಿಯಲ್ಲಿರುವ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಹೇಗೆ ಚಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗ್ರಹಿಸಲು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. ಒದಗಿಸಿದ ಉದಾಹರಣೆ ಕೋಡ್ನಲ್ಲಿ, ಮೊದಲ ಎರಡು ಲಾಗ್ಗಳು ("A" ಮತ್ತು "F") ಸಿಂಕ್ರೊನಸ್ ಆಗಿರುತ್ತವೆ, ಅಂದರೆ ಕೋಡ್ನಲ್ಲಿ ಗೋಚರಿಸುವ ನಿಖರವಾದ ಕ್ರಮದಲ್ಲಿ ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಕ್ಷಣದಲ್ಲಿ, ಸ್ಕ್ರಿಪ್ಟ್ ತಕ್ಷಣವೇ ನಂತರದ ಪ್ರಕ್ರಿಯೆಗಾಗಿ setTimeout ನಂತಹ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳನ್ನು ನಿಗದಿಪಡಿಸುತ್ತದೆ.
ಸೆಟ್ಟೈಮ್ಔಟ್ ಕಾರ್ಯವು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮುಂದೂಡಲು ಒಂದು ಸಾಮಾನ್ಯ ಮಾರ್ಗವಾಗಿದೆ, ಇದು ಮರಣದಂಡನೆಯ ಹರಿವಿನಲ್ಲಿ ವಿಳಂಬದ ಅರ್ಥವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡೂ ಈವೆಂಟ್ ಕ್ಯೂಗೆ "B" ಮತ್ತು "E" ಕನ್ಸೋಲ್ ಲಾಗ್ಗಳನ್ನು ಸೇರಿಸಲು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. "E" 0 ಮಿಲಿಸೆಕೆಂಡ್ಗಳ ವಿಳಂಬವನ್ನು ಹೊಂದಿದ್ದರೂ, ಪ್ರಸ್ತುತ ಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಮೈಕ್ರೊಟಾಸ್ಕ್ಗಳು ಪೂರ್ಣಗೊಂಡ ನಂತರವೂ ಅದು ಸರದಿಯಲ್ಲಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗಳಿಗಾಗಿ ಮರಣದಂಡನೆ ಕ್ರಮವನ್ನು ನಿರ್ಧರಿಸುವಲ್ಲಿ ಈ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಮೊದಲ ಒಳಗೆ ಕಾಲ್ಬ್ಯಾಕ್, ಲಾಗ್ "B" ಅನ್ನು ಮೊದಲು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ಇನ್ನೂ ಸಿಂಕ್ರೊನಸ್ ಟಾಸ್ಕ್ ಕ್ಯೂನ ಭಾಗವಾಗಿದೆ, ಇದು ಆದ್ಯತೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನಂತರ, ಆ ಕಾಲ್ಬ್ಯಾಕ್ನಲ್ಲಿ, ಪರಿಹರಿಸಿದ ಭರವಸೆಯೊಂದಿಗೆ ರಚಿಸಲಾಗುತ್ತದೆ . ಇದು ಮೈಕ್ರೊಟಾಸ್ಕ್ ಅನ್ನು ಪ್ರಚೋದಿಸುತ್ತದೆ ಅದು ಲಾಗ್ "D" "B" ನಂತರ ಸಂಭವಿಸುತ್ತದೆ ಆದರೆ ಮುಖ್ಯ ಈವೆಂಟ್ ಸರದಿಯಲ್ಲಿ ಯಾವುದೇ ಇತರ ಕಾರ್ಯಗಳ ಮೊದಲು ಸಂಭವಿಸುತ್ತದೆ. ಮೈಕ್ರೋಟಾಸ್ಕ್ ಕ್ಯೂನಲ್ಲಿ ಇರಿಸಲಾದ ಪ್ರಾಮಿಸ್ಗಳ ಈ ನಡವಳಿಕೆಯು ಎರಡನೇ ಸೆಟ್ಟೈಮ್ಔಟ್ ಕಾಲ್ಬ್ಯಾಕ್ ಲಾಗ್ಗಳು "E" ಮೊದಲು ಲಾಗ್ ಆಗಲು "D" ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ಮೈಕ್ರೊಟಾಸ್ಕ್ಗಳು ಪ್ರಮಾಣಿತ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳಿಗಿಂತ ಆದ್ಯತೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ.
ಅಂತಿಮ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಆರ್ಡರ್ ಅನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳಲು: "A" ಮತ್ತು "F" ಅನ್ನು ಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಲಾಗ್ ಮಾಡಲಾಗಿದೆ, ನಂತರ "B" ಅನ್ನು ಮೊದಲ ಸೆಟ್ಟೈಮ್ಔಟ್ನಿಂದ ಸರದಿಯಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ. ಪರಿಹರಿಸಿದ ಭರವಸೆಯು "D" ಅನ್ನು ಮೈಕ್ರೋಟಾಸ್ಕ್ ಆಗಿ ಲಾಗ್ ಮಾಡಲು ಕಾರಣವಾಗುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, "E" ಅನ್ನು ಕೊನೆಯದಾಗಿ ಲಾಗ್ ಮಾಡಲಾಗಿದೆ ಏಕೆಂದರೆ ಅದು ಎರಡನೆಯ ಭಾಗವಾಗಿದೆ ಕಾಲ್ಬ್ಯಾಕ್. ಸಂದರ್ಶನದ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸುವಾಗ ಅಥವಾ ನೈಜ-ಜೀವನ ಯೋಜನೆಗಳಲ್ಲಿ ಅಸಮಕಾಲಿಕ ಕೋಡ್ ಡೀಬಗ್ ಮಾಡುವಾಗ ಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಗಳು, ಈವೆಂಟ್ ಲೂಪ್ ಮತ್ತು ಮೈಕ್ರೊಟಾಸ್ಕ್ಗಳನ್ನು ಸಂಯೋಜಿಸುವ JavaScript ನ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಹರಿವಿನ ಈ ತಿಳುವಳಿಕೆಯು ಅಮೂಲ್ಯವಾಗಿದೆ.
ವಿಭಿನ್ನ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನ ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳ ಮಿಶ್ರಣವನ್ನು ಬಳಸಿಕೊಂಡು JavaScript ನ ಈವೆಂಟ್ ಲೂಪ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.
console.log("A");setTimeout(() => {console.log("B");Promise.resolve("C").then(() => console.log("D"));}, 1000);setTimeout(() => console.log("E"), 0);console.log("F");
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು: ಈವೆಂಟ್ ಲೂಪ್ ಮೇಲೆ ಗಮನ
ಈ ಉದಾಹರಣೆಯು ಹಿಂದಿನದನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ, ಈವೆಂಟ್ ಲೂಪ್ ವಿಭಿನ್ನ ಸಮಯದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಸರತಿಯಲ್ಲಿರುವ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.
console.log("Start");setTimeout(() => {console.log("Middle");}, 500);Promise.resolve().then(() => {console.log("Promise 1");});console.log("End");
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನ ಈವೆಂಟ್ ಲೂಪ್ ಮತ್ತು ಟಾಸ್ಕ್ ಆದ್ಯತೆಯಲ್ಲಿ ಡೀಪ್ ಡೈವ್ ಮಾಡಿ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನ ಅಸಮಕಾಲಿಕ ನಡವಳಿಕೆಯ ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ದಿ , ಇದು ಕಾಲ್ಬ್ಯಾಕ್ಗಳು, ಭರವಸೆಗಳು ಮತ್ತು ಇತರ ಅಸಮಕಾಲಿಕ ಕೋಡ್ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ಹೊಂದಿದೆ. ಈ ಈವೆಂಟ್ ಲೂಪ್ ಕರೆ ಸ್ಟಾಕ್ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ನಿರಂತರವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅದು ಇದ್ದರೆ, ಇದು ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂ ಮತ್ತು ಮೈಕ್ರೋಟಾಸ್ಕ್ ಕ್ಯೂನಿಂದ ಕಾರ್ಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ಈ ಸರತಿ ಸಾಲುಗಳಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕೋಡ್ ನಿರೀಕ್ಷೆಯಂತೆ ವರ್ತಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ನಿರ್ವಹಿಸುವಾಗ ಮತ್ತು ಏಕಕಾಲದಲ್ಲಿ ಭರವಸೆ.
ಮೈಕ್ರೊಟಾಸ್ಕ್ ಕ್ಯೂ ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂಗಿಂತ ಆದ್ಯತೆಯನ್ನು ಪಡೆಯುತ್ತದೆ. ಮುಂತಾದ ಕಾರ್ಯಗಳು ಮೈಕ್ರೊಟಾಸ್ಕ್ ಕ್ಯೂನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ ಕಾಲ್ಬ್ಯಾಕ್ ಸರದಿಯಿಂದ ಯಾವುದೇ ವಿಳಂಬವಾದ ಕಾರ್ಯಗಳ ಮೊದಲು ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಸೆಟ್ಟೈಮ್ಔಟ್ ಶೂನ್ಯ ವಿಳಂಬವನ್ನು ಹೊಂದಿದ್ದರೂ ಸಹ. ಇದಕ್ಕಾಗಿಯೇ ಕೋಡ್ ಉದಾಹರಣೆಯಲ್ಲಿ, ಭರವಸೆಯಿಂದ ಲಾಗ್ "D" ಅನ್ನು ಎರಡನೇ ಸೆಟ್ಟೈಮ್ಔಟ್ನಿಂದ ಲಾಗ್ "E" ಮೊದಲು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ತಪ್ಪಿಸಲು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಿಶ್ರಣ ಮಾಡುವ ಕೋಡ್ ಬರೆಯುವಾಗ ಡೆವಲಪರ್ಗಳು ಇದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.
ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ, API ಕರೆಗಳು ಅಥವಾ ಟೈಮರ್ಗಳಂತಹ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳು ಸಿಂಕ್ರೊನಸ್ ಕೋಡ್ನೊಂದಿಗೆ ಆಗಾಗ್ಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ. ಈವೆಂಟ್ ಲೂಪ್, ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂ ಮತ್ತು ಮೈಕ್ರೋಟಾಸ್ಕ್ ಕ್ಯೂ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವ ಮೂಲಕ, ಡೆವಲಪರ್ಗಳು ತಮ್ಮ ಕೋಡ್ನ ಫಲಿತಾಂಶವನ್ನು ಉತ್ತಮವಾಗಿ ಊಹಿಸಬಹುದು. ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವಾಗ ಅಥವಾ ಸಂಕೀರ್ಣ ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ ಮತ್ತು ಸಿಂಕ್ರೊನಸ್ ಕೋಡ್ ಆಗಾಗ್ಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ.
- JavaScript ನಲ್ಲಿ ಈವೆಂಟ್ ಲೂಪ್ ಎಂದರೇನು?
- ಈವೆಂಟ್ ಲೂಪ್ ಎನ್ನುವುದು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಆದ್ಯತೆ ನೀಡಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುವ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ಅಥವಾ .
- ಹೇಗೆ ಮಾಡುತ್ತದೆ ಕೆಲಸ?
- ನಿಗದಿತ ವಿಳಂಬದ ನಂತರ ಕಾಲ್ಬ್ಯಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಗದಿಪಡಿಸುತ್ತದೆ, ಆದರೆ ಅದನ್ನು ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ಸಿಂಕ್ರೊನಸ್ ಕೋಡ್ ಮತ್ತು ಮೈಕ್ರೋಟಾಸ್ಕ್ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ ನಂತರ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.
- ಏಕೆ ಮಾಡುತ್ತದೆ ಎ ಎ ಮೊದಲು ಪರಿಹರಿಸಿ 0 ವಿಳಂಬದೊಂದಿಗೆ?
- ಮೈಕ್ರೊಟಾಸ್ಕ್ ಕ್ಯೂನಲ್ಲಿ ಭರವಸೆಗಳನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ, ಇದು ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂಗಿಂತ ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯನ್ನು ಹೊಂದಿದೆ, ಅಲ್ಲಿ ಕಾಲ್ಬ್ಯಾಕ್ಗಳನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ.
- ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂ ಮತ್ತು ಮೈಕ್ರೋಟಾಸ್ಕ್ ಕ್ಯೂ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು?
- ಕಾಲ್ಬ್ಯಾಕ್ ಕ್ಯೂ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಇತರ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳು, ಮೈಕ್ರೊಟಾಸ್ಕ್ ಕ್ಯೂ ನಂತಹ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಕಾಲ್ಬ್ಯಾಕ್ಗಳ ಮೊದಲು ರೆಸಲ್ಯೂಶನ್ಗಳು ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ.
- ಮರಣದಂಡನೆಯ ಕ್ರಮ ಯಾವುದು ಒದಗಿಸಿದ ಉದಾಹರಣೆಯಲ್ಲಿ ಹೇಳಿಕೆಗಳು?
- ಈವೆಂಟ್ ಲೂಪ್ ಮೂಲಕ ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವ ವಿಧಾನದಿಂದಾಗಿ "A", "F", "B", "D", "E" ಕ್ರಮವಾಗಿದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನ ಈವೆಂಟ್ ಲೂಪ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಹೇಗೆ ಮಾಸ್ಟರಿಂಗ್ ಮಾಡಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ ಮುಂತಾದ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಡೆವಲಪರ್ಗಳು ತಮ್ಮ ಕೋಡ್ ನಿರೀಕ್ಷೆಯಂತೆ ವರ್ತಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮತ್ತು ಬಹು ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಸಾಮಾನ್ಯ ಅಪಾಯಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, "A", "F", "B", "D", ಮತ್ತು "E" ನ ಅಂತಿಮ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಆರ್ಡರ್ ಸೆಟ್ಟೈಮ್ಔಟ್ನಿಂದ ಕಾಲ್ಬ್ಯಾಕ್ಗಳಿಗಿಂತ ಮೈಕ್ರೊಟಾಸ್ಕ್ಗಳು (ಪ್ರಾಮಿಸಸ್) ಹೇಗೆ ಆದ್ಯತೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಸಂದರ್ಶನದ ಪ್ರಶ್ನೆಗಳಿಗೆ ಮತ್ತು ನಿಜ ಜೀವನದ ಕೋಡಿಂಗ್ ಸವಾಲುಗಳಿಗೆ ಈ ಜ್ಞಾನವು ಅಮೂಲ್ಯವಾಗಿದೆ.
- JavaScript ನಲ್ಲಿ ಈವೆಂಟ್ ಲೂಪ್ ಮತ್ತು ಕಾರ್ಯ ಆದ್ಯತೆಯ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ವಿವರಿಸುತ್ತದೆ. MDN ವೆಬ್ ಡಾಕ್ಸ್ - ಈವೆಂಟ್ ಲೂಪ್
- ನ ನಡವಳಿಕೆಯನ್ನು ಚರ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ನಲ್ಲಿ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಹಿತಿ - ಮೈಕ್ರೋಟಾಸ್ಕ್ ಕ್ಯೂ
- JavaScript ಉದಾಹರಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳಿಗಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕ್ರಮವನ್ನು ವಿವರಿಸುತ್ತದೆ. freeCodeCamp - ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭರವಸೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು