JavaScript ನಲ್ಲಿ printIn ಮತ್ತು console.log ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು? (ಉತ್ತರಿಸಲಾಗಿದೆ) - ಎಲ್ಲಾ ವ್ಯತ್ಯಾಸಗಳು
ಪರಿವಿಡಿ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದ್ದು ಅದು ವೆಬ್ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ ಮಾತ್ರ ಲಭ್ಯವಿದೆ. JavaScript ಕನ್ಸೋಲ್ ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಆಜ್ಞಾ ಸಾಲಿನ ಇಂಟರ್ಫೇಸ್ ಆಗಿದ್ದು ಅದು ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಚಲಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನೀವು ಪ್ರಸ್ತುತ ವೀಕ್ಷಿಸುತ್ತಿರುವ ವೆಬ್‌ಪುಟದೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಆ ಕೋಡ್ ತುಣುಕನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿದಾಗ, ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳು ಸಂಭವಿಸಬಹುದು.
“PrintIn” ಪಠ್ಯವನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುವಂತೆ ಮಾಡುತ್ತದೆ, ಆದರೆ ನೀವು "console.log" ಅನ್ನು ಲಾಗ್ ಮಾಡಲು ಮತ್ತು ಅದನ್ನು ಬಗ್ ವರದಿಯಾಗಿ ಇಮೇಲ್ ಮಾಡುವಂತಹ ವಿವಿಧ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಬಳಸಬಹುದು.
ನೀವು ಪ್ರೋಗ್ರಾಮರ್ ಆಗಿದ್ದರೆ, ಬಳಸುವುದು ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಎಷ್ಟು ಮುಖ್ಯ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಂತಹ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಗಳು. ಆದಾಗ್ಯೂ, ಅದರ ಕಾರ್ಯಗಳ ಬಗ್ಗೆ ನೀವು ಗೊಂದಲಕ್ಕೊಳಗಾಗುವ ಸಂದರ್ಭಗಳಿವೆ.
printIn ಮತ್ತು console.log ಕಾರ್ಯದಂತೆಯೇ. ಈ ಎರಡು ಕಾರ್ಯಗಳ ವ್ಯತ್ಯಾಸ ಮತ್ತು ಅನ್ವಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು, ಅವುಗಳ ಅರ್ಥ ಮತ್ತು ಅವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನಾನು ವಿವರಿಸುತ್ತೇನೆ.
ಆರಂಭಿಸೋಣ!
JavaScript ಎಂದರೇನು?
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಂದರೇನು?
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಿಯಮಿತವಾಗಿ ನವೀಕರಿಸಿದ ವಸ್ತುಗಳನ್ನು ರಚಿಸಲು, ಮಲ್ಟಿಮೀಡಿಯಾವನ್ನು ನಿಯಂತ್ರಿಸಲು, ಗ್ರಾಫಿಕ್ಸ್ ಅನ್ನು ಅನಿಮೇಟ್ ಮಾಡಲು ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ಮಾಡಲು ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಯಾಗಿದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯು ಕೆಲವು ಪ್ರಮಾಣಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೊಂದಿದೆ, ಅದು ನಿಮಗೆ ಈ ರೀತಿಯ ಕೆಲಸಗಳನ್ನು ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ:
- ವೆಬ್ ಪುಟದಲ್ಲಿ ಕೆಲವು ಘಟನೆಗಳು ಸಂಭವಿಸಿದಾಗ, ನೀವು ಚಾಲನೆಯಲ್ಲಿರುವ ಕೋಡ್‌ಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಬಹುದು.
- ಉಪಯುಕ್ತ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ನೀವು ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.
- ನೀವು "ಸ್ಟ್ರಿಂಗ್ಸ್" ಅನ್ನು ಬಳಸಬಹುದು ಅದು ಪಠ್ಯ ಸಂಪಾದನೆ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ
ಬಳಕೆದಾರ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಯ ಮೇಲೆ ಸೇರಿಸಲಾದ ಕಾರ್ಯಚಟುವಟಿಕೆಯು ಮತ್ತೊಂದೆಡೆ, ಇನ್ನಷ್ಟು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ. ಅಪ್ಲಿಕೇಶನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಇಂಟರ್‌ಫೇಸ್‌ಗಳು (API ಗಳು) ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಹೆಚ್ಚುವರಿ ಕಾರ್ಯಗಳನ್ನು ನೀಡುತ್ತವೆ.
ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ, ನೀವು ಕೋಡಿಂಗ್ ಮಾಡುತ್ತಿರುವುದನ್ನು ನಿಯಂತ್ರಿಸಲು JavaScript ಬಹಳಷ್ಟು ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ಈ ಕಾರ್ಯಗಳಲ್ಲಿ printIn ಮತ್ತು console.log ಸೇರಿವೆ.
PrintIn ಎಂದರೇನು?
ಕೋಡಿಂಗ್
PrintIn ಎಂಬುದು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಪಠ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಒಂದು ಜಾವಾ ವಿಧಾನವಾಗಿದೆ. ಈ ವಿಧಾನವು ಈ ಪಠ್ಯವನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನ ರೂಪದಲ್ಲಿ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಮುಂದಿನ ಸಾಲಿನ ಪ್ರಾರಂಭದಲ್ಲಿ ಕರ್ಸರ್ ಅನ್ನು ಇರಿಸಿಕೊಂಡು ಪಠ್ಯವನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುತ್ತದೆ.
ಮುಂದಿನ ಮುದ್ರಣ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ . ಹಲವಾರು printIn ವಿಧಾನಗಳಿವೆ:
| void printIn() | ಪ್ರಸ್ತುತ ಸಾಲನ್ನು ಕೊನೆಗೊಳಿಸಲು ಲೈನ್ ವಿಭಜಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬರೆಯುತ್ತದೆ. |
| ಅನೂರ್ಜಿತ ಪ್ರಿಂಟ್‌ಇನ್(ಬೂಲಿಯನ್ x) | ಬೂಲಿಯನ್ ಅನ್ನು ಮುದ್ರಿಸಿದ ನಂತರ ಲೈನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| ಅನೂರ್ಜಿತ ಪ್ರಿಂಟ್‌ಇನ್(ಚಾರ್ x) | ಅಕ್ಷರವನ್ನು ಮುದ್ರಿಸಿದ ನಂತರ ರೇಖೆಯನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| ಅನೂರ್ಜಿತ ಮುದ್ರಣ(ಚಾರ್ [ ] x) | ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಯನ್ನು ಮುದ್ರಿಸಿದ ನಂತರ ಸಾಲನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| ಅನೂರ್ಜಿತ ಪ್ರಿಂಟ್‌ಇನ್(ಡಬಲ್ x) | ಡಬಲ್ ಲೈನ್ ಅನ್ನು ಮುದ್ರಿಸಿದ ನಂತರ ಲೈನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗಿದೆ. |
| ಅನೂರ್ಜಿತ ಪ್ರಿಂಟ್‌ಇನ್(ಫ್ಲೋಟ್ x) | ಆಫ್ಲೋಟ್ ಪ್ರಿಂಟ್ ಮಾಡಿದ ನಂತರ ಲೈನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| ಶೂನ್ಯprintIn(int x) | ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ಮುದ್ರಿಸಿದ ನಂತರ ರೇಖೆಯನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| ಅನೂರ್ಜಿತ ಮುದ್ರಣIn(long x) | ಮುದ್ರಿಸಿದ ನಂತರ ಸಾಲನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| ಅನೂರ್ಜಿತ ಪ್ರಿಂಟ್‌ಇನ್(ಆಬ್ಜೆಕ್ಟ್ x) | ಒಂದು ವಸ್ತುವನ್ನು ಮುದ್ರಿಸಿದ ನಂತರ ರೇಖೆಯನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. |
| ಅನೂರ್ಜಿತ ಪ್ರಿಂಟ್‌ಇನ್(ಸ್ಟ್ರಿಂಗ್ x) | ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮುದ್ರಿಸಿದ ನಂತರ ಲೈನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗುತ್ತದೆ. |
ಪ್ರಿಂಟ್‌ಇನ್‌ನಲ್ಲಿ ವಿಭಿನ್ನ ವಿಧಾನಗಳ ಬಳಕೆ
ನಿಮ್ಮ ಕೆಲಸವನ್ನು ಕೋಡಿಂಗ್ ಮಾಡಲು ನೀವು ಬಳಸಬಹುದಾದ ಹಲವು ವಿಧಾನಗಳನ್ನು ಇದು ಹೊಂದಿದ್ದರೂ, ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಪಠ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಲು ನೀವು ಇನ್ನೊಂದು ವಿಧಾನವನ್ನು ಎದುರಿಸಬಹುದು. ಕನ್ಸೋಲ್‌ನಲ್ಲಿ, ನಿಮ್ಮ ಕೆಲಸವನ್ನು ನೀವು ಮುದ್ರಿಸಬಹುದಾದ ಎರಡು ವಿಧಾನಗಳಿವೆ, ಮೊದಲನೆಯದು ಪ್ರಿಂಟ್‌ಇನ್ ಆಗಿದ್ದರೆ ಇನ್ನೊಂದು ಪ್ರಿಂಟ್ ಆಗಿದೆ.
ಈ ಎರಡು ಮುದ್ರಣ ವಿಧಾನಗಳ ನಡುವೆ ನೀವು ಗೊಂದಲಕ್ಕೀಡಾಗದಿರಲು, ನಾವು ನೋಡೋಣ ಮುದ್ರಣದಲ್ಲಿ ಎರಡನೇ ವಿಧಾನದ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ವಿವರಿಸಿ, ಮುದ್ರಣ.
ಪ್ರಿಂಟ್ ಎಂಬುದು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಪಠ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಜಾವಾ ವಿಧಾನವಾಗಿದೆ. ಈ ವಿಧಾನವು ಈ ಪಠ್ಯವನ್ನು ಒಂದು ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್. ಈ ವಿಧಾನವು ಕೆಳಗಿನ ಸಾಲಿನ ಕೊನೆಯಲ್ಲಿ ಕರ್ಸರ್ ಅನ್ನು ಇರಿಸಿಕೊಂಡು ಪಠ್ಯವನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುತ್ತದೆ.
ಮುಂದಿನ ಮುದ್ರಣ ಇಲ್ಲಿಯೇ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ . ಹಲವಾರು ಪ್ರಿಂಟ್‌ಇನ್ ವಿಧಾನಗಳಿವೆ:
| ಶೂನ್ಯ ಮುದ್ರಣ(ಬೂಲಿಯನ್ ಬಿ) | ಒಂದು ಬೂಲಿಯನ್ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ. | 18>
| ಶೂನ್ಯ ಮುದ್ರಣ(ಚಾರ್ ಸಿ) | ಒಂದು ಅಕ್ಷರವನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ. |
| ಶೂನ್ಯ ಮುದ್ರಣ(ಚಾರ್ []ಗಳು) | ಅಕ್ಷರಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ. |
| ಶೂನ್ಯ ಮುದ್ರಣ(ಡಬಲ್ ಡಿ) | ಎರಡು-ನಿಖರತೆ ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಯನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ. |
| ಶೂನ್ಯ ಮುದ್ರಣ(ಫ್ಲೋಟ್ ಎಫ್) | ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಯನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ. |
| ಶೂನ್ಯ ಮುದ್ರಣ(int i) | ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ. |
| ಅನೂರ್ಜಿತ ಮುದ್ರಣ(ದೀರ್ಘ l ) | ಉದ್ದದ ಪೂರ್ಣಾಂಕವನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ. |
| ಅನೂರ್ಜಿತ ಮುದ್ರಣ(ಆಬ್ಜೆಕ್ಟ್ obj) | ಒಂದು ವಸ್ತುವನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ . |
| ಶೂನ್ಯ ಮುದ್ರಣ(ಸ್ಟ್ರಿಂಗ್ ಗಳು) | ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮುದ್ರಿಸಲಾಗಿದೆ. |
ಮುದ್ರಣದಲ್ಲಿ ವಿಭಿನ್ನ ವಿಧಾನಗಳ ಬಳಕೆ
ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಎರಡರ ನಡುವಿನ ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಮುದ್ರಿಸಲಾದ ಪಠ್ಯದ ಸ್ಥಾನ. PrintIn ಕೆಳಗಿನ ಸಾಲಿನ ಪ್ರಾರಂಭದಲ್ಲಿ ಪ್ರಿಂಟ್ ಇದೆ ಕೆಳಗಿನ ಸಾಲಿನ ಕೊನೆಯಲ್ಲಿ.
ನೀವು windows 10-pro ಮತ್ತು pro-n ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳಲು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ, ಪರಿಶೀಲಿಸಿ ನನ್ನ ಇತರ ಲೇಖನವನ್ನು ಹೊರಗಿಡಿ.
Console.log ಎಂದರೇನು?
Console.log
ಕನ್ಸೋಲ್ ಒಂದು JavaScript ವಸ್ತುವಾಗಿದ್ದು ಅದು ನಿಮಗೆ ಬ್ರೌಸರ್‌ನ ಡೀಬಗ್ ಮಾಡುವ ಕನ್ಸೋಲ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ನೀಡುತ್ತದೆ.
console.log ಒಂದು JavaScript ಆಗಿದೆ. ಅದರಲ್ಲಿ ಹಿಂದೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಯಾವುದೇ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಮುದ್ರಿಸುವ ಕಾರ್ಯ, ಹಾಗೆಯೇ ಬಳಕೆದಾರರಿಗೆ ತೋರಿಸಬೇಕಾದ ಯಾವುದೇ ಮಾಹಿತಿ.
ಔಟ್‌ಪುಟ್ ಅನ್ನು ಹೆಚ್ಚಾಗಿ ಟರ್ಮಿನಲ್‌ಗೆ ಲಾಗ್ ಮಾಡಲಾಗಿದೆ (ಮುದ್ರಿಸಲಾಗಿದೆ). ಸ್ಟ್ರಿಂಗ್‌ಗಳು, ಅರೇಗಳು, ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಮತ್ತು ಬೂಲಿಯನ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಯಾವುದೇ ಪ್ರಕಾರವನ್ನು ಲಾಗ್() ಗೆ ರವಾನಿಸಬಹುದು.
The console.log() ವಿಧಾನದಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಗೋಚರಿಸುತ್ತದೆ, ಇದನ್ನು ಬ್ರೌಸರ್‌ನ ಡೆವಲಪರ್ ಟೂಲ್ ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದು. ನೀವು console.log() ನೊಂದಿಗೆ ಯಾವುದೇ ಔಟ್‌ಪುಟ್ ಮಾಡಿದರೂ ಅವರ ಗುಂಪು ಅಥವಾ ಪಾತ್ರವನ್ನು ಲೆಕ್ಕಿಸದೆಯೇ ಎಲ್ಲಾ ಅಂತಿಮ ಬಳಕೆದಾರರಿಗೆ ಪ್ರವೇಶಿಸಬಹುದಾಗಿದೆ.
ನೀವು ಅದನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಮತ್ತು ಈ ಕಾರ್ಯವನ್ನು ಬಳಸಿದ ನಂತರ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡೋಣ.
| ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ | ಔಟ್‌ಪುಟ್ |
// console. log() ವಿಧಾನ | abc 1 ನಿಜ ಶೂನ್ಯ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ ಅರೇ(4) [ 1, 2, 3, 4 ] ವಸ್ತು { a : 1, b : 2 , c : 3 }
|
console.log ಬಳಸಿಕೊಂಡು ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್
ಎಂದರೇನು Javascript ನಲ್ಲಿ Console.log ವಿಧಾನದೊಂದಿಗೆ ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುವುದೇ?
ಇದು JavaScript ನ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಮತ್ತು ವ್ಯಾಪಕವಾಗಿ ಬಳಸುವ ಕನ್ಸೋಲ್ ವಿಧಾನವಾಗಿದೆ. ಕನ್ಸೋಲ್‌ಗೆ ವಿವಿಧ ಸಂದೇಶಗಳು ಅಥವಾ ಲೆಕ್ಕಾಚಾರದ ಫಲಿತಾಂಶಗಳನ್ನು ಮುದ್ರಿಸಲು ಅಥವಾ ಕೋಡ್ ಡೀಬಗ್ ಮಾಡುವಾಗಲೂ ಈ ವಿಧಾನವನ್ನು ಆಗಾಗ್ಗೆ ಬಳಸಲಾಗುತ್ತದೆ.
ನೀವು ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಸೇರಿಸುವ ಕೆಲವು ಕೋಡ್ ಅನ್ನು ಬರೆದಿರುವಿರಿ ಮತ್ತು ನೀವು ಫಲಿತಾಂಶವನ್ನು ನೋಡಲು ಬಯಸುತ್ತೀರಿ ಕನ್ಸೋಲ್‌ನಲ್ಲಿನ ಆ ಕಾರ್ಯಾಚರಣೆಯ; ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು console.log() ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು.
9564
Console.log ಸಿಂಕ್ರೊನಸ್ ಅಥವಾ ಅಸಮಕಾಲಿಕವಾಗಿದೆಯೇ?
console.log ಸಿಂಕ್ರೊನಸ್ ಅಥವಾ ಅಸಮಕಾಲಿಕವಾಗಿದೆಯೇ ಎಂದು ನಾನು ನಿಮ್ಮೊಂದಿಗೆ ಚರ್ಚಿಸುವ ಮೊದಲು, ಸಿಂಕ್ರೊನಸ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಯಾವುದು ಎಂಬುದನ್ನು ನಾನು ಮೊದಲು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇನೆ.
ಸಿಂಕ್ರೊನಸ್ ಎಂದರೆ ಅದು ಅದೇ ಸಮಯದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ ಆದರೆ ಅಸಮಕಾಲಿಕ ಎಂದರೆ ಅದು ಇದು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಸಂಭವಿಸುವುದಿಲ್ಲ. ಆದ್ದರಿಂದಸಿಂಕ್ರೊನಸ್‌ನಲ್ಲಿ ಭಾಗವಹಿಸುವವರು/ಬಳಕೆದಾರರು ತಕ್ಷಣವೇ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪಡೆಯಬಹುದು. ಅಸಿಂಕ್ರೊನಸ್ ನಿಮ್ಮ ಸ್ವಂತ ಸಮಯದಲ್ಲಿ ಕಲಿಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಉತ್ತರಿಸಲು, concole.log ಅಸಮಕಾಲಿಕವಾಗಿದೆ. ಅದು ಏಕೆ ಎಂದು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ, ಉದಾಹರಣೆಗಳನ್ನು ತೋರಿಸುವ ಮೂಲಕ, ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ರೀತಿಯಲ್ಲಿ ವಸ್ತುಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸಿ. ಪ್ರಾರಂಭಿಸೋಣ.
ನಿಮ್ಮ ರಚನೆಯಲ್ಲಿ ನೀವು ಈ ಕೆಳಗಿನ ವಸ್ತುಗಳನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಹೇಳೋಣ:
| ಬಳಕೆದಾರರಿಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡಿ = [ {ಹೆಸರು: “ನಿಕೋಲ್” , ವಯಸ್ಸು: 20, ಉಪನಾಮ: “ಲೂನಾ” } , {ಹೆಸರು: “ಕಾರಾ” , ವಯಸ್ಸು: 21, ಉಪನಾಮ: “ಲಿಮ್” } , {ಹೆಸರು: “ಲಾರಾ” , ವಯಸ್ಸು: 20, ಉಪನಾಮ: “ತುವಾಜಾನ್”}; ] |
ಅರೇ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು
ನೀವು ಈ ಶ್ರೇಣಿಯನ್ನು ಕ್ಷೇತ್ರದ ಹೆಸರಿನ ಮೂಲಕ ವಿಂಗಡಿಸಬೇಕು, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಈ ಕೆಳಗಿನಂತೆ ಮಾಡಲಾಗುತ್ತದೆ.
| / / ಹೆಸರಿನಿಂದ ( ಕಾರಾ, ಲಾರಾ, ನಿಕೋಲ್ ) ಬಳಕೆದಾರರು 0>/ / ವಯಸ್ಸಿನ ಪ್ರಕಾರ (ಲಾರಾ, ನಿಕೋಲ್, ಕಾರಾ ) ಬಳಕೆದಾರರು.sort ( ( a, b ) => a.age > b.name ? 1 : -1); ಸಹ ನೋಡಿ: ಕ್ರೀಮ್ VS ಕ್ರೀಮ್: ವಿಧಗಳು ಮತ್ತು ವ್ಯತ್ಯಾಸಗಳು - ಎಲ್ಲಾ ವ್ಯತ್ಯಾಸಗಳು
|
ಅರೇ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ವಿಂಗಡಿಸುವುದು
ಅದನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಜೋಡಿಸಲು, ನೀವು ಈ ರೀತಿ ಹೊಂದಿರುತ್ತೀರಿ:
| users.sort(byField('name')); users.sort(byField('age' )); |
ಅರೇ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ವಿಂಗಡಿಸುವುದು (ಸರಳ ಮಾರ್ಗ)
ಹಾಗೆ ಮಾಡಲು, ನೀವು "ಬೈಫೀಲ್ಡ್" ಫಂಕ್ಷನ್ ಅನ್ನು ಪಾಸ್ ಮಾಡಲು ಬರೆಯಬೇಕು ಮತ್ತು ಅದನ್ನು Array.prototype.sort ಗೆ ನಿಮ್ಮ ಅರೇಯಲ್ಲಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ವಿಂಗಡಿಸಬೇಕು. ಸರಿ, ಇದು ಈ ಲೇಖನದ ಪ್ರಾಥಮಿಕ ಗಮನವಲ್ಲ ಆದರೆ ಮೇಲಿನ ಉದಾಹರಣೆಯನ್ನು ಸರಳ ರೀತಿಯಲ್ಲಿ ಪೂರ್ಣಗೊಳಿಸಲು ದಯವಿಟ್ಟು ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ನೋಡಿ.
| > ಬಳಕೆದಾರರಿಗೆ ಅವಕಾಶ ಕೊಡಿ =[ {ಹೆಸರು: “ನಿಕೋಲ್” , ವಯಸ್ಸು: 20, ಉಪನಾಮ: “ಲೂನಾ” } , {ಹೆಸರು: “ಕಾರಾ” , ವಯಸ್ಸು: 21, ಉಪನಾಮ: “ಲಿಮ್” } , {ಹೆಸರು: “ಲಾರಾ” , ವಯಸ್ಸು: 20, ಉಪನಾಮ: “ಟುವಾಜಾನ್”}; ] Function byField (fieldName ){ return (a, b ) => a[fieldName] ? 1 : -1 ; } users.sort(byField('name') ); concole.log(users); users.sort(byField('age' ) ); concole.log(users); (3) [ { … }, { … }, { …} ] > 0: {ಹೆಸರು: ” ಲಾರಾ “, ವಯಸ್ಸು: ” 20 ” , ಉಪನಾಮ: ” Tuazon ” } > 1: {ಹೆಸರು: ” ನಿಕೋಲ್ “, ವಯಸ್ಸು: ” 20 ” , ಉಪನಾಮ: ” ಲೂನಾ ” } > 1: {ಹೆಸರು: ” ಕಾರಾ “, ವಯಸ್ಸು: ” 21 ” , ಉಪನಾಮ: ” ಲಿಮ್ ” } ಉದ್ದ: 3 > _proto_: Array (0) (3) [ { … }, { … }, { … } ] > 0: {ಹೆಸರು: ” ಲಾರಾ “, ವಯಸ್ಸು: ” 20 ” , ಉಪನಾಮ: ” Tuazon ” } > 1: {ಹೆಸರು: ” ನಿಕೋಲ್ “, ವಯಸ್ಸು: ” 20 ” , ಉಪನಾಮ: ” ಲೂನಾ ” } > 1: {ಹೆಸರು: ” ಕಾರಾ “, ವಯಸ್ಸು: ” 21 ” , ಉಪನಾಮ: ” ಲಿಮ್ ” } ಉದ್ದ: 3 > _proto_: Array (0)
|
ವಿಂಗಡಿಸಲಾದ ರಚನೆಯ ವಸ್ತುಗಳು
ನಾನು ವಿಂಗಡಿಸುವುದನ್ನು ಮೇಲಿನ ಕೋಷ್ಟಕದಿಂದ ನೀವು ನೋಡಬಹುದು ಅರೇ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಎರಡು ಬಾರಿ, ನಾನು ಮೊದಲು ಹೆಸರಿನಿಂದ, ಮುಂದಿನ ವಯಸ್ಸಿನ ಪ್ರಕಾರ ವಿಂಗಡಿಸುತ್ತೇನೆ ಮತ್ತು ಪ್ರತಿ ರೀತಿಯ ಕಾರ್ಯಾಚರಣೆಯ ನಂತರ, ನಾನು console.log () ಅನ್ನು ರನ್ ಮಾಡುತ್ತೇನೆ. ಅಲ್ಲದೆ, ನೀವು console.log() ಪ್ರತಿ ರೀತಿಯ ಫಲಿತಾಂಶಕ್ಕಾಗಿ ಒಂದೇ ರೀತಿಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುಸ್ಥಾಪಿಸಿರುವುದನ್ನು ನೀವು ಗಮನಿಸಿರಬಹುದು, ಆದರೆ ಇದು ಹಾಗಲ್ಲ; ಏಕೆ ಎಂದು ನಾನು ವಿವರಿಸುತ್ತೇನೆ.
ನಾನು ಮೇಲಿನ ಕೋಡ್ ಅನ್ನು ಏಕಕಾಲದಲ್ಲಿ ರನ್ ಮಾಡಿದ್ದೇನೆ, ನಂತರ console.log () ನಿಂದ ಪ್ರತಿ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ವಿಸ್ತರಿಸಲು ನಿರ್ಧರಿಸಿದೆ. ಇದು ಮಹತ್ವದ್ದಾಗಿದೆ ಏಕೆಂದರೆ console.log() ಆಗಿದೆಅಸಮಕಾಲಿಕ.
ಈವೆಂಟ್ ಲೂಪ್ ವಿಷಯದಲ್ಲಿ, ಎಲ್ಲಾ ಅಸಮಕಾಲಿಕ ವೈಶಿಷ್ಟ್ಯಗಳು ಈವೆಂಟ್ ಟೇಬಲ್‌ಗೆ ಬರುತ್ತವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, console.log() ಅನ್ನು ತಂದ ನಂತರ, ಇದು ಈವೆಂಟ್ ಟೇಬಲ್‌ಗೆ ಮುಂದುವರಿಯುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಘಟನೆ ಸಂಭವಿಸುವವರೆಗೆ ಕಾಯುತ್ತದೆ.
ಈವೆಂಟ್ ಸಂಭವಿಸಿದಾಗ, console.log() ಅನ್ನು ಈವೆಂಟ್ ಕ್ಯೂಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ, ಅಲ್ಲಿ ನಿಮ್ಮ console.log ಅನ್ನು ಇರಿಸಿದಾಗ ಈಗಾಗಲೇ ಇರುವ ಈವೆಂಟ್ ಸರದಿಯಲ್ಲಿನ ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳು ಮತ್ತು ಕರೆಗೆ ಕಳುಹಿಸುವವರೆಗೆ ಅದು ಕಾಯುತ್ತದೆ. ಸ್ಟ್ಯಾಕ್ ಮಾಡಿ, ನಂತರ ನಿಮ್ಮ console.log() ಅನ್ನು ಈ ಕಾಲ್ ಸ್ಟ್ಯಾಕ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತಿದೆ.
Javascript Console.log ಅನ್ನು ಹೇಗೆ ತೆರೆಯುವುದು?
ವೆಬ್ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ, ಕನ್ಸೋಲ್ ಹಲವಾರು ಡೆವಲಪರ್ ಪರಿಕರಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ನಿಮ್ಮ JavaScript ಕೋಡ್ ಅನ್ನು ನಿವಾರಿಸಲು, ನೀವು ಕನ್ಸೋಲ್ ಅನ್ನು ಬಳಸಬಹುದು. ಬ್ರೌಸರ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಕನ್ಸೋಲ್ ಅನ್ನು ಹಲವು ಸ್ಥಳಗಳಲ್ಲಿ ಕಾಣಬಹುದು.
ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಿಮ್ಮ Google Chrome ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಕನ್ಸೋಲ್ ಅನ್ನು ಎಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬೇಕೆಂದು ನಾನು ನಿಮಗೆ ಕಲಿಸುತ್ತೇನೆ.
Chrome ನಲ್ಲಿ ಕನ್ಸೋಲ್ ಲಾಗ್ ಅನ್ನು ಹೇಗೆ ತೆರೆಯುವುದು ಎಂಬುದರ ಕುರಿತು ಹಂತಗಳು
Chrome ಕನ್ಸೋಲ್ ಲಾಗ್ ಅನ್ನು ಹೇಗೆ ತೆರೆಯುವುದು ಎಂದು ನೋಡೋಣ.
- Chrome ಬ್ರೌಸರ್ ತೆರೆದಿರುವಾಗ ಪಾಪ್-ಅಪ್ ಮೆನುವಿನಿಂದ ಪರೀಕ್ಷಿಸಿ ಆಯ್ಕೆಮಾಡಿ.
- ಡೆವಲಪರ್ ಪರಿಕರಗಳ "ಎಲಿಮೆಂಟ್‌ಗಳು "ನೀವು Inspect ಅನ್ನು ರನ್ ಮಾಡಿದಾಗ ಡೀಫಾಲ್ಟ್ ಆಗಿ ಟ್ಯಾಬ್ ತೆರೆಯುತ್ತದೆ. "ಎಲಿಮೆಂಟ್ಸ್" ಬಲಕ್ಕೆ, "ಕನ್ಸೋಲ್" ಕ್ಲಿಕ್ ಮಾಡಿ.
- ನೀವು ಈಗ ಕನ್ಸೋಲ್ ಅನ್ನು ವೀಕ್ಷಿಸಬಹುದು ಮತ್ತು ಕನ್ಸೋಲ್ ಲಾಗ್‌ಗೆ ರೆಕಾರ್ಡ್ ಮಾಡಲಾದ ಯಾವುದೇ ಔಟ್‌ಪುಟ್ ಅನ್ನು ವೀಕ್ಷಿಸಬಹುದು.
ನೀವು ಇದನ್ನು ಸಹ ತೆರೆಯಬಹುದು. ಹಲವಾರು ಶಾರ್ಟ್‌ಕಟ್ ಕೀಗಳನ್ನು ಬಳಸುವ Chrome ಡೆವಲಪರ್ ಪರಿಕರಗಳು. ನಿಮ್ಮ Chrome ನ ಆವೃತ್ತಿಯ ಪ್ರಕಾರ, ನೀವುಕೆಳಗಿನ ಶಾರ್ಟ್‌ಕಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು:
Windows ಮತ್ತು Linux ಗಾಗಿ,
| Ctrl + Shift + I | ಡೆವಲಪರ್ ಟೂಲ್ಸ್ ವಿಂಡೋ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. |
| Ctrl + Shift + J | ಡೆವಲಪರ್ ಪರಿಕರಗಳಲ್ಲಿ ಕನ್ಸೋಲ್ ಟ್ಯಾಬ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತದೆ. |
| Ctrl + Shift + C<17 | ಎಲಿಮೆಂಟ್ ಮೋಡ್ ಟಾಗಲ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ |
ಶಾರ್ಟ್‌ಕಟ್ ಕೀಗಳು
ಅಂತಿಮ ಆಲೋಚನೆಗಳು
ಮುಖ್ಯ ವ್ಯತ್ಯಾಸ printIn ನಡುವೆ ಮತ್ತು console.log ಅವರ ಕಾರ್ಯ ಮತ್ತು ಕೋಡ್‌ನ ಫಲಿತಾಂಶ . PrintIn ಪಠ್ಯವನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸುತ್ತದೆ ಆದರೆ console.log ಯಾವುದೇ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಮೊದಲು ಕೋಡ್ ಮಾಡಲಾದ ಸ್ಟ್ರಿಂಗ್‌ಗಳೊಂದಿಗೆ ಮುದ್ರಿಸುತ್ತದೆ.
ಮೂಲತಃ, Javascript ನ ಈ ಕಾರ್ಯಗಳು ಕನ್ಸೋಲ್‌ಗೆ ವೇರಿಯೇಬಲ್‌ಗಳು ಮತ್ತು ಪಠ್ಯವನ್ನು ಮುದ್ರಿಸಲು ಮತ್ತು ಪ್ರದರ್ಶಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. JavaScript ನಲ್ಲಿ, ನೀವು ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮುದ್ರಿಸಬಹುದು.
ಸಹ ನೋಡಿ: ವೆಲೋಸಿರಾಪ್ಟರ್ ಮತ್ತು ಡೈನೋನಿಕಸ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು? (ಇನ್ಟು ದಿ ವೈಲ್ಡ್) - ಎಲ್ಲಾ ವ್ಯತ್ಯಾಸಗಳುಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕನ್ಸೋಲ್ ಲಾಗ್ ವಿಧಾನವು ಡೀಬಗ್ ಮಾಡುವಾಗ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಆಯ್ಕೆಯಾಗಿದೆ. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಡೀಬಗ್ ಮಾಡಲು, ನೀವು ಎಲ್ಲವನ್ನೂ ಅಭ್ಯಾಸ ಮಾಡಬೇಕು ಮತ್ತು ಅವುಗಳನ್ನು ಸರಿಯಾಗಿ ಬಳಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಕಲಿಯಬೇಕು.
ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಮತ್ತು ಡೆವಲಪರ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಅದರಲ್ಲಿ ಪೂರ್ವನಿರ್ಧರಿತವಾಗಿರುವ ಯಾವುದೇ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಮುದ್ರಿಸಲು ಮತ್ತು ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಮಾಹಿತಿಯನ್ನು ಮುದ್ರಿಸಲು ಬಳಸುತ್ತಾರೆ. ಬಳಕೆದಾರರಿಗೆ ಪ್ರಸ್ತುತಪಡಿಸಲು.
