ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕಕ್ಕೆ ಡೆವೆಲಪರ್ಗಳ ಮಾರ್ಗದರ್ಶಿ
ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕವನ್ನು ಮಾಸ್ಟರ್ ಮಾಡಿ. ಎಪಾಕ್ ಸಮಯವನ್ನು ಮಾನವ ಓದಲು ಸುಲಭವಾದ ದಿನಾಂಕಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು, ವಿಭಿನ್ನ ಭಾಷೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಸಾಮಾನ್ಯ ಡೆವೆಲಪರ್ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ಕಲಿಯಿರಿ.
ಒಂದು ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕವು ಡೆವೆಲಪರ್ ಅಥವಾ ಡೇಟಾ ವಿಶ್ಲೇಷಕನಂತೆ ನೀವು ನಿರಂತರವಾಗಿ ಬಳಸುವ ಅಗತ್ಯವಿರುವ ಸಾಧನಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಇದು ದೀರ್ಘ, ತೋಚಿದ ಸಂಖ್ಯೆಯನ್ನು ನಾವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ದಿನಾಂಕ ಮತ್ತು ಸಮಯದಲ್ಲಿ ಅನುವಾದಿಸುವ ಸುಲಭ ಉಪಕರಣವಾಗಿದೆ. ಈ ಅನುವಾದವು ನೀವು ವ್ಯವಸ್ಥೆಯ ಲಾಗ್ಗಳನ್ನು ತೀವ್ರವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತಿರುವಾಗ, API ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿರುವಾಗ ಅಥವಾ ಸಮಯವು ಈ ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಸ್ವರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿತವಾಗಿರುವ ಡೇಟಾಬೇಸ್ಗಳನ್ನು ಕೇಳುವಾಗ ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದೆ.
ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಏನು ಮತ್ತು ಇದು ಏಕೆ ಮುಖ್ಯವಾಗಿದೆ
ಒಂದು ಉತ್ತಮ ಪರಿವರ್ತಕವನ್ನು ನೀವು ನಿಜವಾಗಿಯೂ ಮೆಚ್ಚಲು, ನೀವು ಆ ಸಂಖ್ಯೆಯ ಅರ್ಥವೇನು ಎಂಬುದನ್ನು ತಿಳಿಯಬೇಕು ಅದು ಏನು. ಇದರ ಮೂಲದಲ್ಲಿ, ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಎಂದರೆ ಸೆಕೆಂಡುಗಳ ಓಟದ ಎಣಿಕೆ. ಇದು 1970ರ ಜನವರಿ 1 ರಂದು 00:00:00 UTC ನಂತರ ಕಳೆದ ಒಟ್ಟು ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ. ಆ ನಿರ್ದಿಷ್ಟ ಕ್ಷಣವನ್ನು "ಯುನಿಕ್ಸ್ ಎಪಾಕ್" ಎಂದು ಪ್ರಸಿದ್ಧವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ.
ಆಗ ಈ ವಿಧಾನ ಏಕೆ? ಸರಳತೆ ಮತ್ತು ಪರಿಣಾಮಕಾರಿತ್ವ. ಸಮಯವನ್ನು ಒಬ್ಬ ಒಬ್ಬ ಇಂಟೆಜರ್ ರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದು "ಶುಕ್ರವಾರ, ಜನವರಿ 1, 2021 12:00:00 AM GMT" ಎಂಬ ವಿಸ್ತಾರವಾದ ಸ್ಟ್ರಿಂಗ್ಗಿಂತ ಹೆಚ್ಚು ಸಂಕೋಚನ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮವಾಗಿದೆ. ಇದು ಕೆಲವು ಪ್ರಮುಖ ಕ್ಷೇತ್ರಗಳಿಗೆ ಪರಿಪೂರ್ಣವಾಗಿದೆ:
- ಡೇಟಾಬೇಸ್ ಸಂಗ್ರಹಣೆ: ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳು ಸಣ್ಣವಾಗಿದ್ದು, ಇವುಗಳನ್ನು ಶೀಘ್ರವಾಗಿ ಸೂಚ್ಯಂಕ ಮತ್ತು ಕೇಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಇದು ಕಾರ್ಯಕ್ಷಮತೆಗೆ ದೊಡ್ಡ ಗೆಲುವಾಗಿದೆ.
- API ಪೇಲೋಡ್ಗಳು: ಒಬ್ಬ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುವುದು ಸಂಪೂರ್ಣ ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಕಳುಹಿಸುವುದಕ್ಕಿಂತ ಬಾಂಡ್ವಿಡ್ತ್ನಲ್ಲಿ ಹೆಚ್ಚು ಹಗುರವಾಗಿದೆ, ಇದು ಶೀಘ್ರ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.
- ಲಾಗ್ ಫೈಲ್ಗಳು: ನೀವು ವಿವಿಧ ವ್ಯವಸ್ಥೆಗಳ ಲಾಗ್ಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತಿರುವಾಗ, ಸಮಾನ, ಭಾಷಾ-ಅಜ್ಞಾತ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಹೊಂದಿರುವುದು ಜೀವನರಕ್ಷಕವಾಗಿದೆ.
- ಹಣಕಾಸು: ಒಂದು ಪ್ರಕ್ರಿಯೆಗೆ ಎಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಂಡಿತು ಎಂದು ತಿಳಿಯಬೇಕೇ? ಪ್ರಾರಂಭದ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಕೊನೆಯ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ನಿಂದ ಕಡಿತಮಾಡಿ. ಇದು ಸರಳ ಇಂಟೆಜರ್ ಗಣಿತವಾಗಿದೆ.
ಸೆಕೆಂಡುಗಳು vs. ಮಿಲಿಸೆಕೆಂಡುಗಳು ಮತ್ತು ಇತರವು
ಕ್ಲಾಸಿಕ್ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಒಂದು 10-ಅಂಕಿಯ ಸಂಖ್ಯೆಯಾಗಿದೆ, ಇದು ಸೆಕೆಂಡುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಆದರೆ ತಂತ್ರಜ್ಞಾನ ಅಭಿವೃದ್ಧಿಯೊಂದಿಗೆ, ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮವಾದ ಸಮಯದ ನಿರ್ವಹಣೆಯ ಅಗತ್ಯವಾಯಿತು. ಇದು ನೀವು ವಿಭಿನ್ನ ಉದ್ದದ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ನೋಡಲು ಆರಂಭಿಸುತ್ತಿರುವ ಸ್ಥಳವಾಗಿದೆ, ಮತ್ತು ಇದು ಸಾಮಾನ್ಯವಾಗಿ ತಪ್ಪು ಮಾಡುವ ಸ್ಥಳವಾಗಿದೆ.
ಇಲ್ಲಿ ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಎದುರಿಸುವುದಕ್ಕೆ ಶೀಘ್ರವಾದ ವಿವರಣೆ ಇದೆ. ಒಂದನ್ನು ಇನ್ನೊಂದರೊಂದಿಗೆ ತಪ್ಪಾಗಿ ಗುರುತಿಸುವುದು "ಹಜಾರಿನಲ್ಲಿ ತಪ್ಪಾಗಿದೆ" ಎಂಬ ದೋಷವಾಗಿದೆ, ಇದು ಕೆಲವು ಬಹಳ ಗೊಂದಲಕಾರಿಯಾದ ಬಗ್ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
ಸಾಮಾನ್ಯ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಸ್ವರೂಪಗಳು
| ಯೂನಿಟ್ | ಅಂಕಿಗಳು | ಸಾಮಾನ್ಯ ಬಳಕೆ ಪ್ರಕರಣ | ಉದಾಹರಣೆ ಮೌಲ್ಯ (ಅದೇ ಕ್ಷಣಕ್ಕೆ) |
|---|---|---|---|
| ಸೆಕೆಂಡುಗಳು | 10 | ಅಧಿಕಾರಿತ ಬ್ಯಾಕ್ಎಂಡ್ ವ್ಯವಸ್ಥೆ, ಡೇಟಾಬೇಸ್ಗಳು ಮತ್ತು API ಗಳಿಗೆ ಪ್ರಮಾಣಿತ. | 1609459200 |
| ಮಿಲಿಸೆಕೆಂಡುಗಳು | 13 | ವೆಬ್ ತಂತ್ರಜ್ಞಾನದಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಬಹಳ ಸಾಮಾನ್ಯವಾಗಿದೆ. | 1609459200000 |
| ಮೈಕ್ರೋಸೆಕೆಂಡುಗಳು | 16 | ಹೈ-ಫ್ರೀಕ್ವೆನ್ಸಿ ವ್ಯಾಪಾರ ಅಥವಾ ವೈಜ್ಞಾನಿಕ ಗಣನೆಯಲ್ಲಿನ ಬಳಕೆ. | 1609459200000000 |
ಈ ಸ್ವರೂಪಗಳನ್ನು ಸರಿಯಾಗಿ ತಿಳಿಯುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಒಂದು ಸಾಧನವು ಸೆಕೆಂಡುಗಳನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತಿದ್ದರೆ ಮತ್ತು ನೀವು ಅದಕ್ಕೆ ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ನೀಡಿದರೆ, ನೀವು ಸಾವಿರಾರು ವರ್ಷಗಳ ನಂತರದ ದಿನಾಂಕವನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಇದು ನಾವು ಎಲ್ಲರಿಗೂ ಯಾವಾಗಲಾದರೂ ಮಾಡಿದ ತಪ್ಪಾಗಿದೆ!
ಪ್ರಸಿದ್ಧ 2038 ವರ್ಷದ ಸಮಸ್ಯೆ
ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ನ ಸುಂದರ ಸರಳತೆಯು "2038 ವರ್ಷದ ಸಮಸ್ಯೆ" ಎಂಬ ಟಿಕಿಂಗ್ ಟೈಮ್ ಬಾಂಬ್ ಅನ್ನು ಸಹ ನಿರ್ಮಿಸಿದೆ. ಹಳೆಯ 32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಸೈನ್ ಮಾಡಿದ 32-ಬಿಟ್ ಇಂಟೆಜರ್ ರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿತ್ತು. ಸಮಸ್ಯೆ ಏನೆಂದರೆ, ಈ ರೀತಿಯ ಇಂಟೆಜರ್ಗಳಿಗೆ ಒಂದು ಮೇಲ್ಮಟ್ಟವಿದೆ—ಇದು 2,147,483,647ಕ್ಕಿಂತ ದೊಡ್ಡ ಸಂಖ್ಯೆಯನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಜಾನವರಿ 19, 2038 ರಂದು, 03:14:07 UTC ರಂದು, ಎಪಾಕ್ನಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯು ಆ ಮಿತಿಯನ್ನು ಮೀರಿಸುತ್ತದೆ. ಆಗ, ಇಂಟೆಜರ್ "ಮರುಕಟ್ಟುತ್ತದೆ" ಮತ್ತು ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಯಾಗಿ ಬದಲಾಗುತ್ತದೆ. ಇದು ಅಪಾಯಕ್ಕೆ ಒಳಪಟ್ಟ ವ್ಯವಸ್ಥೆಗಳನ್ನು 1901 ರಲ್ಲಿ ಹಿಂದಕ್ಕೆ ದಿನಾಂಕವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಾರಣವಾಗಬಹುದು, ಇದು ಇನ್ನೂ ಅಲ್ಲಿ ಇರುವ ಬಿಲಿಯನ್ಗಳಷ್ಟು ಹಳೆಯ ಸಾಧನಗಳನ್ನು ಕ್ರ್ಯಾಶ್ ಮಾಡಬಹುದು. ಯುನಿಕ್ಸ್ ಎಪಾಕ್ ಮತ್ತು ಅದರ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು ಮಾಹಿತಿ ಪಡೆಯಲು ನೀವು StrongDM ನ ತಜ್ಞರಿಂದ ಮಾಹಿತಿ ಪಡೆಯಬಹುದು.
ದೊಡ್ಡದಾಗಿ, ಇದು ಬಹಳಷ್ಟು ಜನರಿಗೆ ದಿನನಿತ್ಯದ ಚಿಂತೆಯ ವಿಷಯವಲ್ಲ. ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳ ಬಹಳಷ್ಟು ಭಾಗವು ಸಮಯದ ನಿರ್ವಹಣೆಗೆ 64-ಬಿಟ್ ಇಂಟೆಜರ್ಗಳಿಗೆ ಸ್ಥಳಾಂತರಗೊಂಡಿದೆ. 64-ಬಿಟ್ ಇಂಟೆಜರ್ ಇಷ್ಟು ದೊಡ್ಡದು, ಇದು ಇನ್ನೂ 292 ಬಿಲಿಯನ್ ವರ್ಷಗಳು ಹರಿಯುವುದಿಲ್ಲ, ಪರಿಣಾಮವಾಗಿ ಸಮಸ್ಯೆಯನ್ನು ಶಾಶ್ವತವಾಗಿ ಪರಿಹರಿಸುತ್ತದೆ.
ಆದರೆ, ಇದು ಗಣಕಯಂತ್ರದ ಐತಿಹಾಸಿಕ ದೃಷ್ಟಿಯಿಂದ ಅದ್ಭುತವಾದ ವಿಷಯ ಮತ್ತು ಹಳೆಯ ಎಂಬೆಡ್ಡಡ್ ವ್ಯವಸ್ಥೆಗಳ ಅಥವಾ ಹಳೆಯ ಕೋಡ್ಬೇಸ್ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ನೀವು ಹೊಂದಿರುವ ಪ್ರಮುಖ ಮಾಹಿತಿಯ ತುಂಡಾಗಿದೆ. ಈ ಮೂಲಭೂತಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿಮ್ಮ ಕೈಗಳಲ್ಲಿ ಯಾವುದೇ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕವನ್ನು ಹೆಚ್ಚು ಶಕ್ತಿಶಾಲಿ ಸಾಧನವಾಗಿಸುತ್ತದೆ.
ನಿಮ್ಮ ಬ್ರೌಸರ್ನಲ್ಲಿ ಪರಿವರ್ತನೆಗಳನ್ನು ಸುಲಭಗೊಳಿಸುವುದು
ಟರ್ಮಿನಲ್ ಆಜ್ಞೆ ಅಥವಾ ಕೋಡ್ ಸ್ನಿಪ್ಪೆಟ್ ಅನ್ನು ಬಳಸುವುದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೂ, ಇದು ಯಾವಾಗಲೂ ಕಾರ್ಯಗಳನ್ನು ಮುಗಿಸಲು ವೇಗವಾದ ಮಾರ್ಗವಲ್ಲ. ಕೆಲವೊಮ್ಮೆ, ನೀವು ನಿಮ್ಮ ಗಮನವನ್ನು ಮುರಿಯದೆ ಅಥವಾ ಕಿಟಕಿಗಳನ್ನು ಬದಲಾಯಿಸದೇ ಈಗಲೇ ಉತ್ತರವನ್ನು ಬೇಕಾಗಿರುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಬ್ರೌಸರ್ನಲ್ಲಿ ನಿಖರವಾದ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕ ಇರುವಾಗ, ಉತ್ತಮ ಬ್ರೌಸರ್ ಆಧಾರಿತ ಸಾಧನವು ತನ್ನ ಮೌಲ್ಯವನ್ನು ತೋರಿಸುತ್ತದೆ.
ಇಲ್ಲಿ ನಿಜವಾದ ಮಾಯಾಜಾಲವು ಹರಿಯುವಿಕೆಯಲ್ಲಿ ಉಳಿಯುವುದರ ಬಗ್ಗೆ. ಈ ದೃಶ್ಯವನ್ನು ಕಲ್ಪಿಸಿ: ನೀವು ನಿಮ್ಮ ಬ್ರೌಸರ್ನ ಡೆವೆಲಪರ್ ಟೂಲ್ಸ್ನಲ್ಲಿ API ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿದ್ದೀರಿ ಮತ್ತು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಗಮನಿಸುತ್ತೀರಿ.
ಇನ್ನೊಂದು ಟ್ಯಾಬ್ ತೆರೆಯುವ ಅಥವಾ ಟರ್ಮಿನಲ್ ಅನ್ನು ಆರಂಭಿಸುವ ಬದಲು, ನೀವು ವೇಗವಾದ ಕೀಬೋರ್ಡ್ ಶಾರ್ಟ್ಕಟ್ ಅನ್ನು ಒತ್ತುತ್ತೀರಿ, ಸಂಖ್ಯೆಯನ್ನು ಪೇಸ್ಟ್ ಮಾಡುತ್ತೀರಿ ಮತ್ತು ತಕ್ಷಣವೇ ಉತ್ತರವನ್ನು ಪಡೆಯುತ್ತೀರಿ. ShiftShift Extensions ಮುಂತಾದ ಸಾಧನಗಳೊಂದಿಗೆ ನೀವು ಪಡೆಯುವ ನಿರಂತರ ಕಾರ್ಯವಿಧಾನವೇ ಇದು, ಇದು ಒಬ್ಬ ಕಮಾಂಡ್ ಪ್ಯಾಲೆಟ್ನಲ್ಲಿ ಹಲವಾರು ಉಪಯುಕ್ತ ಉಪಕರಣಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ.
ಕೀಬೋರ್ಡ್ ಶಾರ್ಟ್ಕಟ್ನೊಂದಿಗೆ ತಕ್ಷಣದ ಉತ್ತರಗಳನ್ನು ಪಡೆಯಿರಿ
ಇದು ವೇಗಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ. ShiftShift ಮುಂತಾದ ಸಾಧನದೊಂದಿಗೆ, Shift ಕೀ (ಅಥವಾ Macನಲ್ಲಿ Cmd+Shift+P) ಅನ್ನು ವೇಗವಾಗಿ ಡಬಲ್-ಟಾಪ್ ಮಾಡಿದರೆ, ಕಮಾಂಡ್ ಬಾರ್ ತೆರೆದಿಡುತ್ತದೆ. "timestamp" ಎಂದು ಟೈಪ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಿ, ಮತ್ತು ಪರಿವರ್ತಕ ಪ್ರकटವಾಗುತ್ತದೆ. ನಿಮ್ಮ ಮೌಲ್ಯವನ್ನು ಪೇಸ್ಟ್ ಮಾಡಿ, ಮತ್ತು ನೀವು ಸ್ಥಳದಲ್ಲಿಯೇ ಮಾನವ-ಓದುವ ದಿನಾಂಕವನ್ನು ಹೊಂದಿದ್ದೀರಿ.
ಇದು ಹೇಗೆ ಕಾಣಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಇಲ್ಲಿ ನೋಡಿ—ಕಮಾಂಡ್ ಪ್ಯಾಲೆಟ್ ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಪುಟದ ಮೇಲೆ ಟೈಮ್ಸ್ಟಾಂಪ್ ಅನ್ನು ಪರಿವರ್ತಿಸಲು ತಯಾರಾಗಿದೆ ಮತ್ತು ಕಾಯುತ್ತಿದೆ.
ಅತ್ಯುತ್ತಮ ಭಾಗವೆಂದರೆ ಇದು ನಿಮ್ಮ ಮಾರ್ಗದಲ್ಲಿ ಬಾಧಿಸುತ್ತಿಲ್ಲ. ಪರಿವರ್ತಕವು ಒಂದೇ ಓವರ್ಲೇನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಹಲವಾರು ಉಪಕರಣಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ನೀವು ಮಾಡುತ್ತಿರುವುದನ್ನು ಬಿಟ್ಟು ಹೋಗಬೇಕಾಗಿಲ್ಲ.
ಈ ವಿಧಾನವು ಡೆವೆಲಪರ್ಗಳಿಗೆ, ಟೆಸ್ಟರ್ಗಳಿಗೆ ಮತ್ತು ತಮ್ಮ ಬ್ರೌಸರ್ನಲ್ಲಿ ವಾಸಿಸುತ್ತಿರುವ ಇತರ ಯಾರಿಗಾದರೂ ಜೀವದಾಯಕವಾಗಿದೆ. ಜೊತೆಗೆ, ಪರಿವರ್ತನೆ ಸಂಪೂರ್ಣವಾಗಿ ನಿಮ್ಮ ಯಂತ್ರದಲ್ಲಿ ನಡೆಯುತ್ತದೆ. ಲಾಗ್ಗಳಿಂದ ಅಥವಾ API ಪ್ರತಿಕ್ರಿಯೆಗಳಿಂದ ಸಂವೇದನಶೀಲ ಡೇಟಾ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಅನ್ನು ತಲುಪುವುದಿಲ್ಲ, ಇದು ಗೌಪ್ಯತೆಗೆ ದೊಡ್ಡ ಜಯವಾಗಿದೆ.
ಟೈಮ್ಸ್ಟಾಂಪ್ ಅನ್ನು ಪರಿವರ್ತಿಸಲು, ಅಸಂಗತ JSON ಬ್ಲಾಬ್ ಅನ್ನು ಪುನಃ ಸ್ವರೂಪಗೊಳಿಸಲು ಮತ್ತು ನಂತರ ಸಮಯದ ವ್ಯತ್ಯಾಸವನ್ನು ಲೆಕ್ಕಹಾಕಲು—ಎಲ್ಲಾ ಒಂದೇ ಇಂಟರ್ಫೇಸ್ನಿಂದ—ಇದು ದೊಡ್ಡ ಸಮಯ-ಉಳುವಿಕೆ. ಇದು ಒಂದು ತೊಂದರೆಯ, ಬಹು-ಉಪಕರಣದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಒಬ್ಬ ಒಬ್ಬ ಸುಗಮ ಕ್ರಿಯೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ಒಂದು ಟ್ರಿಕ್ ಪೋನಿ ಮಾತ್ರವಲ್ಲ
ಒಂದು ಉತ್ತಮ ಬ್ರೌಸರ್ನಲ್ಲಿ ಉಪಯುಕ್ತವಾದ ಸಾಧನವು ಸಾಮಾನ್ಯವಾಗಿ ಏಕಕಾಲದಲ್ಲಿ ಒಂದೇ ಉಪಕರಣವಲ್ಲ; ಇದು ಸಂಪೂರ್ಣ ಉಪಕರಣಕೋಶದ ಭಾಗವಾಗಿದೆ. ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಟೈಮ್ಸ್ಟಾಂಪ್ ಪರಿವರ್ತಕವನ್ನು ಇತರ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಬಳಸುತ್ತೀರಿ.
ಉದಾಹರಣೆಗೆ, ನೀವು ಇದನ್ನು ಜೋಡಿಸಬಹುದು:
- ಟೈಮ್ಸ್ಟಾಂಪ್ ಅನ್ನು ತೆಗೆದು ಹಾಕುವ ಮೊದಲು ಕೆಲವು ಕೋಡ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು JSON ಅಥವಾ SQL ಫಾರ್ಮ್ಯಾಟರ್ ಅನ್ನು.
- ಎಪೋಚ್ ಮೌಲ್ಯಗಳ ಮೇಲೆ ವೇಗವಾಗಿ ಗಣಿತ ಮಾಡಲು ಬಿಲ್ಟ್-ಇನ್ ಕ್ಯಾಲ್ಕುಲೇಟರ್. (ShiftShift ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಪುಟದಲ್ಲಿ ಸಮಾನವಾದ ಸಾಧನವನ್ನು ಪ್ರಯೋಗಿಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಬಹುದು ShiftShift ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಪುಟ ಅನ್ನು ನೋಡಿ).
- ಎರಡು API ಪ್ರತಿಕ್ರಿಯೆಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಗುರುತಿಸಲು ಪಠ್ಯ ಹೋಲಿಸುವ ಸಾಧನ.
ಈ ಎಲ್ಲ ಅಗತ್ಯಗಳನ್ನು ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಹೊಂದಿರುವುದು ಹೆಚ್ಚು ವೇಗವಾದ ಮತ್ತು ಸಮಗ್ರ ಕಾರ್ಯವಿಧಾನವನ್ನು ರೂಪಿಸುತ್ತದೆ. ಇದು ಕೇವಲ ಸುಲಭತೆಯ ಬಗ್ಗೆ ಮಾತ್ರವಲ್ಲ—ಇದು ದಿನದ ಒಟ್ಟು ಸಮಯದಲ್ಲಿ ನಿಮ್ಮ ಉತ್ಪಾದಕತೆಯನ್ನು ಕೊಲ್ಲುವ ಎಲ್ಲಾ ಸಣ್ಣ, ಪುನರಾವೃತ್ತ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಬಗ್ಗೆ.
ಕೋಡ್ನಲ್ಲಿ ವ್ಯವಹಾರಿಕ ಟೈಮ್ಸ್ಟಾಂಪ್ ಪರಿವರ್ತನೆಗಳು
ನೀವು ಡೆವೆಲಪರ್ ಆಗಿದ್ದರೆ, ಟೈಮ್ಸ್ಟಾಂಪ್ಗಳೊಂದಿಗೆ ತೊಡಕುವುದು ಕೆಲಸದ ಭಾಗವಾಗಿದೆ ಎಂಬುದನ್ನು ನೀವು ತಿಳಿದಿದ್ದೀರಿ. ಆದರೆ ನಾವು ಸತ್ಯವನ್ನು ಹೇಳೋಣ, ಒಂದೊಂದು ಭಾಷೆಯಿಂದ ಮತ್ತೊಂದು ಭಾಷೆಗೆ ವ್ಯಾಕರಣವು ಎಂದಿಗೂ ಒಂದೇ ರೀತಿಯಲ್ಲಿರಲ್ಲ. ಈ ವಿಭಾಗವು ನಿಮ್ಮಗೆ ಬೇಕಾದ ಕೋಡ್ ಸ್ನಿಪ್ಪೆಟ್ಗಳನ್ನು ಹಿಡಿದುಕೊಳ್ಳಲು ಮತ್ತು ಬಳಸಲು ನಿಮ್ಮಗೆ ಬೇಕಾದ ಚೀಟ್ ಶೀಟ್ ಆಗಿದೆ. ಹಳೆಯ Stack Overflow ಥ್ರೆಡ್ಗಳನ್ನು ತೋಡಬೇಕಾಗಿಲ್ಲ—ನೀವು ಚಲಿಸಲು ಬೇಕಾದ ವ್ಯವಹಾರಿಕ ಉದಾಹರಣೆಗಳು ಮಾತ್ರ.
ನೀವು ವೆಬ್ ಫ್ರಂಟ್-ಎಂಡ್ನಲ್ಲಿ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರುವಾಗ, Python ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯುವಾಗ ಅಥವಾ ಡೇಟಾಬೇಸ್ನಲ್ಲಿ ಕ್ವೆರಿಯಿಂಗ್ ಮಾಡುವಾಗ, ಎಪೋಚ್ ಸಮಯವನ್ನು ಪರಿವರ್ತಿಸುವುದು ಮೂಲಭೂತ ಕೌಶಲ್ಯವಾಗಿದೆ. ಓದುಗರಿಗೆ ಓದಲು ಸುಲಭವಾದ ಸ್ಟ್ರಿಂಗ್ಗೆ ಎಪೋಚ್ ಪೂರ್ಣಾಂಕವನ್ನು ಪರಿವರ್ತಿಸುವುದರಿಂದ ಆರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಎಲ್ಲವನ್ನೂ ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.
JavaScript ನಲ್ಲಿ ಟೈಮ್ಸ್ಟಾಂಪ್ಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದು
JavaScript ನ Date ವಸ್ತುವು ನಿಮ್ಮ ಪ್ರಮುಖ ಸಾಧನವಾಗಿದೆ, ಆದರೆ ಇದು ಡೆವೆಲಪರ್ಗಳನ್ನು ನಿರಂತರವಾಗಿ ತೊಡಗಿಸುವ ದೊಡ್ಡ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಹೊಂದಿದೆ: ಇದು ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಅಲ್ಲ. ಇದು ನಿಮ್ಮ ಫ್ರಂಟ್ಎಂಡ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್ 10-ಅಂಕಿಯ, ಸೆಕೆಂಡು ಆಧಾರಿತ ಟೈಮ್ಸ್ಟಾಂಪ್ಗಳನ್ನು ಬಳಸುವ ಬ್ಯಾಕ್ಎಂಡ್ಗೊಮ್ಮೆ ಮಾತನಾಡಿದಾಗ ದೋಷಗಳ ಶ್ರೇಣಿಯ ಶ್ರೇಣಿಯ ಮೂಲವಾಗಿದೆ.
ನೀವು ಮಾನದಂಡ Unix ಟೈಮ್ಸ್ಟಾಂಪ್ ಅನ್ನು (ಸೆಕೆಂಡುಗಳಲ್ಲಿ) ಸರಿಯಾಗಿ Date ವಸ್ತುವಾಗಿ ಪರಿವರ್ತಿಸಲು, ನೀವು ಅದನ್ನು 1000 ರಿಂದ ಗುಣಿಸಬೇಕು.
// ಮಾನದಂಡ 10-ಅಂಕಿಯ Unix ಟೈಮ್ಸ್ಟಾಂಪ್ (ಸೆಕೆಂಡುಗಳಲ್ಲಿ)
const unixTimestamp = 1672531200;
// ಮಿಲಿಸೆಕೆಂಡುಗಳಿಗೆ ಪರಿವರ್ತಿಸಿ, ನಂತರ Date ವಸ್ತುವನ್ನು ರಚಿಸಿ
const dateObject = new Date(unixTimestamp * 1000);
// ಓದುಗರಿಗೆ UTC ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಸ್ವರೂಪಗೊಳಿಸಿ
// ಔಟ್ಪುಟ್: ಭಾನುವಾರ, 01 ಜನವರಿ 2023 00:00:00 GMT
console.log(dateObject.toUTCString());
ಪ್ರಸ್ತುತ ಟೈಮ್ಸ್ಟಾಂಪ್ ಬೇಕಾ? Date.now() ಇದು ನಿಮಗೆ ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ನೀಡುತ್ತದೆ. ಮಾನದಂಡ 10-ಅಂಕಿಯ ಟೈಮ್ಸ್ಟಾಂಪ್ ಅನ್ನು API ಗೆ ಹಿಂದಿರುಗಿಸುವ ಮೊದಲು 1000 ರಿಂದ ಭಾಗಿಸಿ ಮತ್ತು ಕೆಳಗೆ ವೃತ್ತೀಕರಿಸಲು ಮಾತ್ರ ನೆನಪಿಡಿ.
Python ನಲ್ಲಿ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು
ಬ್ಯಾಕ್ಎಂಡ್ನಲ್ಲಿ, Python ನ datetime ಮೋಡ್ಯೂಲ್ ಶಕ್ತಿ ಕೇಂದ್ರವಾಗಿದೆ. ಇದು ಅತ್ಯಂತ ಲವಚಿಕವಾಗಿದೆ ಮತ್ತು ವಿವಿಧ ಪ್ರದೇಶಗಳಲ್ಲಿ ಸಮಯವನ್ನು ನಿಖರವಾಗಿ ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿರುವ ಸೇವೆಗಳಿಗಾಗಿ ಅದ್ಭುತ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ.
ಟೈಮ್ಸ್ಟಾಂಪ್ ಅನ್ನು datetime ಲೈಬ್ರರಿಯೊಂದಿಗೆ ಪರಿವರ್ತಿಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವೇ ಇಲ್ಲ:
import datetime
ಮಾನದಂಡ 10-ಅಂಕಿಯ Unix ಟೈಮ್ಸ್ಟಾಂಪ್
unix_timestamp = 1672531200
ಟೈಮ್ಸ್ಟಾಂಪ್ ಅನ್ನು datetime ವಸ್ತುವಾಗಿ ಪರಿವರ್ತಿಸಿ
datetime_obj = datetime.datetime.fromtimestamp(unix_timestamp)
ಇದನ್ನು ಸ್ವಚ್ಛ, ಮಾನವ-ಓದುವ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಸ್ವರೂಪಗೊಳಿಸಿ
ಔಟ್ಪುಟ್: 2023-01-01 00:00:00
print(datetime_obj.strftime('%Y-%m-%d %H:%M:%S'))
ಈ ಸರಳ ವಿಧಾನವು ನಿಮ್ಮ Python ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ ಎಪೋಚ್ ಸಮಯವನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಸ್ವಚ್ಛ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ. ಮತ್ತು ನೀವು ಟೈಮ್ಸ್ಟಾಂಪ್ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ JSON ಮುಂತಾದ ಸಂಕೀರ್ಣ ಡೇಟಾ ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಡಿಬಗ್ ಮಾಡಲು JSON ಫಾರ್ಮ್ಯಾಟರ್ ಅನ್ನು ಬಳಸುವ ಕುರಿತು ನಮ್ಮ ಮಾರ್ಗದರ್ಶಿ ನಿಮಗೆ ಉಪಯುಕ್ತವಾಗಬಹುದು.
SQL ಮೂಲಕ ಡೇಟಾಬೇಸ್ ಪರಿವರ್ತನೆಗಳು
ಡೇಟಾಬೇಸ್ಗಳು ಸಾಮಾನ್ಯವಾಗಿ Unix ಟೈಮ್ಸ್ಟಾಂಪ್ಗಳನ್ನು ಸಮಯವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತವೆ ಏಕೆಂದರೆ ಅವು ಪರಿಣಾಮಕಾರಿವಾಗಿವೆ. ಉತ್ತಮ ಸುದ್ದಿ ಎಂದರೆ, ಹೆಚ್ಚಿನ SQL ಉಲ್ಲೇಖಗಳು ಈ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿಮ್ಮ ಕ್ವೆರಿಗಳ ಒಳಗೆ ನಿರ್ವಹಿಸಲು ನಿರ್ಮಿತ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿವೆ.
ಇದು ಕಚ್ಚಾ ಪೂರ್ಣಾಂಕ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು çekು ಮಾಡುವುದಕ್ಕಿಂತ ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ನಲ್ಲಿ ಅವುಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ.
ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪ್ರಾಯೋಗಿಕವಾಗಿ ವಿಶ್ವವ್ಯಾಪಿಯಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಇದು 90% ಕ್ಕಿಂತ ಹೆಚ್ಚು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ—ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನ Date.now() ರಿಂದ ಪೈಥಾನ್ನ time.time()—ದಿನಕ್ಕೆ ಟ್ರಿಲ್ಲಿಯನ್ಗಳ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಶಕ್ತಿ ನೀಡುತ್ತದೆ. ಟೈಮ್ಜೋನ್ಗಳನ್ನು ಸರಿಯಾಗಿ ಪಡೆಯುವುದು ಅತ್ಯಂತ ಮುಖ್ಯ; ಒಂದು ಶಕ್ತಿಶಾಲಿ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕ 400 ಕ್ಕಿಂತ ಹೆಚ್ಚು IANA ವಲಯಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು, ಇದು ಟೈಮ್ಜೋನ್ಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ವಹಿಸುತ್ತಿಲ್ಲದ ವಿಶ್ವದ ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ ಶ್ರೇಣೀಬದ್ಧವಾದ 62% ದೋಷಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಸಾಧನಗಳ ಜಾಗತಿಕ ಸ್ವೀಕೃತಿಯ ಕುರಿತು ಹೆಚ್ಚಿನ ವಿವರಗಳನ್ನು Fossa ನಲ್ಲಿ ಕಾಣಬಹುದು.
ವಿಕಾಸಕರಿಗಾಗಿ, SQL ಅನ್ನು ಫಾರ್ಮಾಟ್ ಮಾಡಲು, ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಎಪೋಚ್ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಲೆಕ್ಕಹಾಕಲು ನಿಮ್ಮ ಯಂತ್ರವನ್ನು ಬಿಟ್ಟು ಹೋಗದೆ ಇರುವುದರಿಂದ ಇದು ದೊಡ್ಡ ಉತ್ಪಾದಕತೆಯ ಗೆಲುವಾಗಿದೆ. ಈ ಸ್ಥಳೀಯ-ಮೊದಲು ದೃಷ್ಟಿಕೋನವು GDPR ಮತ್ತು CCPAಂತಹ ಆಧುನಿಕ ಡೇಟಾ ಗೌಪ್ಯತೆಯ ಮಾನದಂಡಗಳಿಗೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ.
MySQL ಉದಾಹರಣೆ
MySQL ನಲ್ಲಿ, FROM_UNIXTIME() ಕಾರ್ಯವನ್ನು ನೀವು ಹೆಚ್ಚು ಬಳಸುತ್ತೀರಿ. ಇದು ಒಂದು ಎಪೋಚ್ ಪೂರ್ಣಾಂಕವನ್ನು ತೆಗೆದು ಅದನ್ನು ಸುಂದರವಾಗಿ DATETIME ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.
SELECT FROM_UNIXTIME(1672531200);
-- ಹಿಂತಿರುಗಿಸುತ್ತದೆ: '2023-01-01 00:00:00'
ಮರುದಿಕ್ಕಿಗೆ ಹೋಗಲು—ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಎಪೋಚ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗೆ ಹಿಂತಿರುಗಿಸಲು—ಕೆಲವು UNIX_TIMESTAMP() ಅನ್ನು ಬಳಸಿರಿ.
SELECT UNIX_TIMESTAMP('2023-01-01 00:00:00');
-- ಹಿಂತಿರುಗಿಸುತ್ತದೆ: 1672531200
PostgreSQL ಉದಾಹರಣೆ
PostgreSQL ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ಆದರೆ ಸಮಾನ ಶಕ್ತಿಯ ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತದೆ: to_timestamp(). ಈ ಕಾರ್ಯವು ನೇರವಾಗಿ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು TIMESTAMP WITH TIME ZONE ಮೌಲ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.
SELECT to_timestamp(1672531200);
-- ಹಿಂತಿರುಗಿಸುತ್ತದೆ: 2023-01-01 00:00:00+00
ಇದು ಬಾಕ್ಸ್ನಿಂದ ಹೊರಗೊಮ್ಮಲು ಟೈಮ್ಜೋನ್-ಜಾಗೃತವಾಗಿದೆ, ಇದು ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗೆ ಸೇವೆ ನೀಡುವ ಅಪ್ಲಿಕೇಶನ್ಗಳಿಗೆ ಬಹಳ ಶಕ್ತಿಶಾಲಿ ಆಯ್ಕೆಯಾಗಿದೆ, ಅಲ್ಲಿ ಟೈಮ್ ನಿಖರತೆ ಒಪ್ಪಿಗೆಯಲ್ಲ.
ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆಗಳನ್ನು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಮಾಸ್ಟರ್ ಮಾಡುವುದು
ನೀವು ಕಮಾಂಡ್ ಲೈನ್ನಲ್ಲಿ ಬದುಕಿದರೆ, ತ್ವರಿತ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆಗಾಗಿ ಬ್ರೌಸರ್ ಅಥವಾ GUI ಗೆ ಬದಲಾಯಿಸುವುದು ನಿಜವಾದ ಕಾರ್ಯಪಟು ಕೊಲ್ಲುವದು. ಇದು ನಿಮ್ಮ ಗಮನವನ್ನು ಕಿತ್ತುಹಾಕುತ್ತದೆ. ಉತ್ತಮ ಸುದ್ದಿ ಏನೆಂದರೆ ನೀವು ಮಾಡಬೇಕಾಗಿಲ್ಲ; ಲಿನಕ್ಸ್ ಮತ್ತು ಮ್ಯಾಕ್ಒಎಸ್ ಎರಡೂ ಟರ್ಮಿನಲ್ ಅನ್ನು ಬಿಟ್ಟು ಹೋಗದೆ ಈ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಶಕ್ತಿಶಾಲಿ, ಸ್ಥಳೀಯ ಸಾಧನಗಳನ್ನು ಹೊಂದಿವೆ.
ಇದರಿಗಾಗಿ ಹೋಗುವ ಉಪಕರಣವೆಂದರೆ ನಿಖರವಾದ date ಆಜ್ಞೆ. ಇದು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಪ್ರತಿಯೊಂದು ಯುನಿಕ್ಸ್-ಹೋಲಿಯ ವ್ಯವಸ್ಥೆಯಲ್ಲಿದೆ, ಆದರೆ ಒಂದು ಹಿಡಿತವಿದೆ: ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕ ಎಂದು ಬಳಸಲು ಇದರ ವ್ಯಾಕರಣವು ಲಿನಕ್ಸ್ (GNU) ಮತ್ತು ಮ್ಯಾಕ್ಒಎಸ್ (BSD) ನಡುವಿನ ವ್ಯತ್ಯಾಸವಾಗಿದೆ. ಇದನ್ನು ಸರಿಯಾಗಿ ಪಡೆಯಲು ವ್ಯತ್ಯಾಸವನ್ನು ತಿಳಿಯುವುದು ಮುಖ್ಯವಾಗಿದೆ.
ಲಿನಕ್ಸ್ನಲ್ಲಿ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದು
ಲಿನಕ್ಸ್ನಲ್ಲಿ, ವ್ಯಾಕರಣ ಸ್ವಚ್ಛ ಮತ್ತು ನೆನಪಿನಲ್ಲಿ ಇಡಲು ಸುಲಭವಾಗಿದೆ. ನೀವು ದಿನಾಂಕವನ್ನು ಸೂಚಿಸಲು -d ಧ್ವಜವನ್ನು ಬಳಸುತ್ತೀರಿ, ಆದರೆ ನೀವು ಇದನ್ನು ಎಪೋಚ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಒದಗಿಸುತ್ತಿರುವುದಾಗಿ ಹೇಳಬೇಕಾಗಿದೆ, ಇದನ್ನು @ ಚಿಹ್ನೆಗಳಿಂದ ಮುಂಚಿತವಾಗಿ ಸೇರಿಸುವ ಮೂಲಕ.
ನೀವು ಲಾಗ್ಗಳನ್ನು ತೋಡುತ್ತಿದ್ದರೆ ಮತ್ತು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ 1704067200 ಅನ್ನು ಗಮನಿಸುತ್ತಿದ್ದರೆ. ಅದು ಅರ್ಥವಿಲ್ಲದಂತೆ ನೋಡಲು, ನೀವು ಈ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುತ್ತೀರಿ:
date -d @1704067200
ತಕ್ಷಣ, ನೀವು ಮಾನವ-ಊಹಣೀಯ ದಿನಾಂಕವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತೀರಿ, ಉದಾಹರಣೆಗೆ Mon Jan 1 00:00:00 UTC 2024. ನೀವು ನಿಮ್ಮದೇ ಆದ ಕಸ್ಟಮ್ ಸ್ವರೂಪವನ್ನು ಬಳಸಿಕೊಂಡು ಆ ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಬಹುದು.
date -d @1704067200 +"%Y-%m-%d %H:%M:%S"
ಔಟ್ಪುಟ್: 2024-01-01 00:00:00
ಪ್ರೊ ಟಿಪ್: ನೀವು ಇತರ ಆಜ್ಞೆಗಳನ್ನು ಇದಕ್ಕೆ ಪೈಪ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಈ ಆಜ್ಞೆ ನಿಜವಾದ ಶಕ್ತಿಯ ಕೇಂದ್ರವಾಗುತ್ತದೆ. ನೀವು ದೊಡ್ಡ ಲಾಗ್ ಫೈಲ್ನಿಂದ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು
grepಮಾಡಬಹುದು ಮತ್ತು ಅದನ್ನು ತಕ್ಷಣ ಪರಿವರ್ತನೆಗಾಗಿdateಗೆ ನೇರವಾಗಿ ಒದಗಿಸಬಹುದು. ಇದು ಬಹು-ಹಂತ ಡಿಬಗ್ಗಿಂಗ್ ಕಾರ್ಯವನ್ನು ಒಬ್ಬ ಏಕಕಾಲದಲ್ಲಿ, ಸುಂದರವಾದ ಒಬ್ಬ-ಲೈನರ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ಮ್ಯಾಕ್ಒಎಸ್ನಲ್ಲಿ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು
ಈಗ, ನೀವು ಆ ಅದೇ ಲಿನಕ್ಸ್ ಆಜ್ಞೆಯನ್ನು ಮ್ಯಾಕ್ನಲ್ಲಿ ನಿರ್ವಹಿಸಿದರೆ, ಇದು ದೋಷವನ್ನು ತರುತ್ತದೆ. ಮ್ಯಾಕ್ಒಎಸ್ ಬಳಸುವ BSD ಆವೃತ್ತಿಯ date ಆಜ್ಞೆಗೆ -r ಧ್ವಜವನ್ನು ಅಗತ್ಯವಿದೆ, ಮತ್ತು ಇದಕ್ಕೆ @ ಮುಂಚಿತವಾಗಿ ಸೇರಿಸಲು ಅಗತ್ಯವಿಲ್ಲ.
ನೀವು ಮ್ಯಾಕ್ನಲ್ಲಿ ಅದೇ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಪರಿವರ್ತಿಸಲು ಹೇಗೆ:
date -r 1704067200
ಲಿನಕ್ಸ್ ಆವೃತ್ತಿಯಂತೆ, ನೀವು ಬಯಸುವ ನಿಖರವಾದ ಔಟ್ಪುಟ್ ಪಡೆಯಲು ಸ್ವರೂಪ ಆಯ್ಕೆಯನ್ನು ಸೇರಿಸಬಹುದು.
date -r 1704067200 +"%Y-%m-%d %T %Z"
ಔಟ್ಪುಟ್: 2024-01-01 00:00:00 UTC
ಈ ಸಣ್ಣ ವ್ಯತ್ಯಾಸವು ಲಿನಕ್ಸ್ ಮತ್ತು ಮ್ಯಾಕ್ಒಎಸ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ನಿರಂತರವಾಗಿ ಜಿಗಿಯುವ ಯಾರಿಗಾದರೂ ಕ್ಲಾಸಿಕ್ stumbling ಬ್ಲಾಕ್ ಆಗಿದೆ. ಎರಡೂ ಆವೃತ್ತಿಗಳನ್ನು ನೆನಪಿಸುವುದು ನಿಮ್ಮನ್ನು ಮುಂದಿನ ಹಂತಗಳಲ್ಲಿ ಬಹಳಷ್ಟು ತಲೆನೋವುಗಳನ್ನು ಉಳಿಸುತ್ತದೆ.
ನೀವು ಈ ಆಜ್ಞೆಗಳನ್ನು ತಿಳಿದ ನಂತರ, ನೀವು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆಗಳನ್ನು ನೇರವಾಗಿ ನಿಮ್ಮ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ಗಳಲ್ಲಿ ಮತ್ತು ಲಾಗ್ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಹೂಡಬಹುದು. ಇದು ಒಂದು ಸಣ್ಣ ಕೌಶಲ್ಯ, ಆದರೆ ಇದು ಕೆಲವು ಗಂಭೀರ ಉತ್ಪಾದಕತೆಯ ಲಾಭಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ, ನಿಮ್ಮನ್ನು ವಲಯದಲ್ಲಿ ಮತ್ತು ಮುಖ್ಯವಾದ ಕೆಲಸದಲ್ಲಿ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ.
ಸಾಮಾನ್ಯ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ತಪ್ಪುಗಳು ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ತಪ್ಪಿಸಲು
ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಮೇಲ್ಮಟ್ಟದಲ್ಲಿ ಸರಳವಾಗಿರುವಂತೆ ಕಾಣುತ್ತದೆ, ಆದರೆ ಕೆಲವು ಕ್ಲಾಸಿಕ್ ತಪ್ಪುಗಳು ಕೆಲವು ವಾಸ್ತವವಾಗಿ ಕೋಪಗೊಳ್ಳುವ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಈ ಸಮಸ್ಯೆಗಳು ದೋಷವು ವಾಸ್ತವವಾಗಿ ಸಂಭವಿಸಿದ ಸ್ಥಳದಿಂದ ದೂರದಲ್ಲಿ ತೋರಿಸಲು ಕೆಟ್ಟ ಅಭ್ಯಾಸವನ್ನು ಹೊಂದಿವೆ, ಅವುಗಳನ್ನು ಡಿಬಗ್ ಮಾಡಲು ನಿಜವಾದ ತಲೆನೋವುಗಳನ್ನು ಮಾಡುತ್ತವೆ. ಈ ವಿಭಾಗವನ್ನು ನಾನು ವರ್ಷಗಳಿಂದ ನೋಡಿದ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಬಿಕ್ಕಟ್ಟುಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ತಪ್ಪಿಸಲು ನಿಮ್ಮ ಕ್ಷೇತ್ರದ ಮಾರ್ಗದರ್ಶಿಯಾಗಿ ಪರಿಗಣಿಸಿ.
ಸೆಕೆಂಡುಗಳು ಮತ್ತು ಮಿಲಿಸೆಕೆಂಡುಗಳ ಮಿಶ್ರಣ
ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ದೋಷವೆಂದರೆ ಸೆಕೆಂಡುಗಳನ್ನು ಮಿಲಿಸೆಕೆಂಡುಗಳೊಂದಿಗೆ ಗೊಂದಲಗೊಳಿಸುತ್ತಿದೆ. ಒಂದು ಪ್ರಮಾಣಿತ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಒಂದು 10-ಅಂಕಿಯ ಪೂರ್ಣಾಂಕವಾಗಿದೆ, ಇದು ಎಪೋಚ್ನಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಆದರೆ ಅನೇಕ ವ್ಯವಸ್ಥೆಗಳು, ವಿಶೇಷವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಜಗತ್ತಿನಲ್ಲಿ, 13-ಅಂಕಿಯ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಮಿಲಿಸೆಕೆಂಡುಗಳಿಗಾಗಿ ಬಳಸುತ್ತವೆ.
ಒಂದು ಫ್ರಂಟ್-ಎಂಡ್ ಅಪ್ಲಿಕೇಶನ್ ಸೆಕೆಂಡುಗಳನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತಿರುವ ಬ್ಯಾಕ್ಎಂಡ್ಗೆ ಮಿಲಿಸೆಕೆಂಡು ಮೌಲ್ಯವನ್ನು ಒದಗಿಸಿದಾಗ, ವಿಷಯಗಳು ಹಾಳಾಗುತ್ತವೆ.
ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕ ಗೆ, ಆ 13-ಅಂಕಿಯ ಸಂಖ್ಯೆ ಭವಿಷ್ಯದ ಸಾವಿರಾರು ವರ್ಷಗಳ ಕಾಲದ ದಿನಾಂಕವಾಗಿ ಕಾಣುತ್ತದೆ. ಇದು ಡೇಟಾ ಮಾನ್ಯತೆ, ಶೆಡ್ಯೂಲಿಂಗ್ ತರ್ಕ ಮತ್ತು ನೀವು ಉಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಯಾವುದೇ ಐತಿಹಾಸಿಕ ದಾಖಲೆಗಳನ್ನು ಶಾಂತವಾಗಿ ಹಾಳು ಮಾಡಬಹುದು. ಇದು ನೀವು ವಾರಗಳ ಕಾಲ ಗಮನಿಸದಿರುವಂತಹ ಸೂಕ್ಷ್ಮ ಡೇಟಾ ಹಾಳಾಗುವಿಕೆಯ ಪ್ರಕಾರವಾಗಿದೆ.
ಟೈಮ್ಜೋನ್ ಟ್ರಾಪ್
ಅನೇಕ ಅನುಭವ ಹೊಂದಿರುವ ಡೆವೆಲಪರ್ಗಳನ್ನು ಹಿಡಿಯುವ ಮತ್ತೊಂದು ಬಿಕ್ಕಟ್ಟಾಗಿದೆ ಟೈಮ್ಜೋನ್ ನಿರ್ವಹಣೆ. ಅದರ ಸ್ವಭಾವದಲ್ಲಿ, ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಯಾವಾಗಲೂ ಸಮನ್ವಿತ ವಿಶ್ವಕಾಲದಲ್ಲಿ (UTC) ಇರುತ್ತದೆ. ಇದು ಸ್ಥಳದಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ಸ್ವಾಯತ್ತವಾದ ಒಂದು ಏಕಕಾಲದಲ್ಲಿ, ವಿಶ್ವದಾದ್ಯಂತ ಇರುವ ಕ್ಷಣವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ನೀವು ಇದನ್ನು ಮರೆಯುವಾಗ ಮತ್ತು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಬಳಕೆದಾರನ ಸ್ಥಳೀಯ ಸಮಯವನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ ಎಂದು ಊಹಿಸುವಾಗ, ಈ ಬಿಕ್ಕಟ್ಟಿನ ಬಾಗಿಲು ತೆರುತ್ತದೆ.
ಈ ತಪ್ಪು ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ನನ್ನು ಓದಬಹುದಾದ ದಿನಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತಿರುವಾಗ, ಟೈಮ್ಜೋನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಗೊಳಿಸದೇ ಸಂಭವಿಸುತ್ತದೆ. ನಿಮ್ಮ ವ್ಯವಸ್ಥೆ ಸಾಮಾನ್ಯವಾಗಿ ಸರ್ವರ್ನ ಸ್ಥಳೀಯ ಸಮಯವನ್ನು ಡಿಫಾಲ್ಟ್ಗೊಳಿಸುತ್ತದೆ, ಇದರಿಂದ ಅಕ್ರಮ ಉಂಟಾಗುತ್ತದೆ. ನ್ಯೂಯಾರ್ಕ್ನಲ್ಲಿ ಇರುವ ಬಳಕೆದಾರನು ಲಂಡನ್ನಲ್ಲಿ ಯಾರಿಗಾದರೂ ಉದ್ದೇಶಿತ ಸಮಯವನ್ನು ನೋಡಬಹುದು, ಆದರೆ ಇದು ಹಲವಾರು ಗಂಟೆಗಳ ವ್ಯತ್ಯಾಸದಲ್ಲಿದೆ.
ಸುವರ್ಣ ನಿಯಮ ಸರಳವಾಗಿದೆ: ನಿಮ್ಮ ಬ್ಯಾಕ್ಎಂಡ್ನಲ್ಲಿ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಯಾವಾಗಲೂ UTC ಎಂದು ಪರಿಗಣಿಸಿ. ಅವುಗಳನ್ನು UTC ಯಂತೆ ಸಂಗ್ರಹಿಸಿ, UTC ಯಂತೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ, ಮತ್ತು ಪ್ರದರ್ಶನದ ಕ್ಷಣದಲ್ಲಿ ಮಾತ್ರ ಬಳಕೆದಾರನ ಸ್ಥಳೀಯ ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿ.
ಸಾಮಾನ್ಯ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ ದೋಷಗಳನ್ನು ಪರಿಹರಿಸುವುದು
ವಿಷಯಗಳು ತಪ್ಪಾಗಿದಾಗ, ಲಕ್ಷಣಗಳು ಗೊಂದಲ ಉಂಟುಮಾಡಬಹುದು. ನಿಮಗೆ ತಕ್ಷಣವೇ ನಿರ್ಧಾರ ಮಾಡಲು ಸಹಾಯ ಮಾಡಲು ನಾನು ಅನುಭವದಿಂದ ಒದಗಿಸಿರುವ ಶೀಘ್ರ ಉಲ್ಲೇಖ ಪಟ್ಟಿಯಾಗಿದೆ.
| ಲಕ್ಷಣ | ಸಾಧ್ಯವಾದ ಕಾರಣ | ಪರಿಹಾರ |
|---|---|---|
| ದಿನಾಂಕ 52361ನೇ ವರ್ಷದಲ್ಲಿ ಅಥವಾ ಇತರ ದೂರದ ಭವಿಷ್ಯದಲ್ಲಿ ಇದೆ. | ಮಿಲಿಸೆಕೆಂಡುಗಳು vs. ಸೆಕೆಂಡುಗಳು. ನೀವು 10-ಅಂಕಿಯ ಸೆಕೆಂಡು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತಿರುವ ಕಾರ್ಯಕ್ಕೆ 13-ಅಂಕಿಯ ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಒದಗಿಸುತ್ತಿದ್ದೀರಿ. | ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೊದಲು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು 1000 ರಿಂದ ಹಂಚಿ. ಬರುವ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳ ಅಂಕಿ ಸಂಖ್ಯೆಯನ್ನು ಯಾವಾಗಲೂ ಮಾನ್ಯಗೊಳಿಸಿ. |
| ಸಮಯವು ಕೆಲವು ಗಂಟೆಗಳ ವ್ಯತ್ಯಾಸದಲ್ಲಿದೆ, ಆದರೆ ದಿನಾಂಕ ಸರಿಯಾಗಿದೆ. | ಟೈಮ್ಜೋನ್ ತಪ್ಪಾಗಿ ನಿರ್ವಹಣೆ. ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಬಳಕೆದಾರನ ಅಥವಾ UTC ಬದಲು ಸರ್ವರ್ನ ಸ್ಥಳೀಯ ಸಮಯವನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿವರ್ತಿಸಲಾಗಿದೆ. | ಎಲ್ಲಾ ಪರಿವರ್ತನೆಗಳು ಗುರಿ ಟೈಮ್ಜೋನ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಸ್ಥಳೀಯ ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಮಾತ್ರ ಕ್ಲೈಂಟ್-ಪಕ್ಷದಲ್ಲಿ. |
| ದಿನಾಂಕ ಜನವರಿ 1, 1970 ರಲ್ಲಿ ಅಡಗಿದೆ. | ಅಮಾನ್ಯ ಅಥವಾ ಶೂನ್ಯ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್. ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಮೌಲ್ಯವು ಬಹುಶಃ 0, null, ಅಥವಾ undefined ಆಗಿರಬಹುದು. |
ಪರಿವರ್ತನೆಯ ಪ್ರಯತ್ನ ಮಾಡುವ ಮೊದಲು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಮಾನ್ಯ ಸಕಾರಾತ್ಮಕ ಪೂರ್ಣಾಂಕವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಲು ಒಂದು ಪರಿಶೀಲನೆಯನ್ನು ಸೇರಿಸಿ. ಬದಲಾವಣೆ ಮೌಲ್ಯವನ್ನು ಒದಗಿಸಿ. |
"ಅಮಾನ್ಯ ದಿನಾಂಕ" ಅಥವಾ NaN ದೋಷವನ್ನು ಪಡೆಯುವುದು. |
ತಪ್ಪಾದ ಡೇಟಾ ಪ್ರಕಾರ. ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಸಂಖ್ಯೆಯ ಅಗತ್ಯವಿರುವಾಗ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಇತರ ಅಂಕೀಯವಲ್ಲದ ಪ್ರಕಾರವಾಗಿ ಪರಿಗಣಿಸಲಾಗುತ್ತಿದೆ. | ದಿನಾಂಕ ಕಾರ್ಯಗಳಲ್ಲಿ ಬಳಸುವ ಮೊದಲು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಪೂರ್ಣಾಂಕಕ್ಕೆ ಸ್ಪಷ್ಟವಾಗಿ ಪಾರ್ಸ್ ಮಾಡಿ (parseInt() JS ನಲ್ಲಿ, int() ಪೈಥಾನ್ನಲ್ಲಿ). |
ನಿಮ್ಮನ್ನು ತಲುಪುವ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳ ಉಲ್ಲೇಖವನ್ನು ಶೀಘ್ರವಾಗಿ ಪರಿಶೀಲಿಸುವುದು, ನಿಮ್ಮನ್ನು ಮುಂದಿನ ದೋಷ ಪರಿಹಾರದಲ್ಲಿ ಗಂಟೆಗಳ ಕಾಲ ಉಳಿಸುತ್ತದೆ.
ಮಾನದಂಡ ರೂಪಗಳೊಂದಿಗೆ ಗೊಂದಲವನ್ನು ತಪ್ಪಿಸುವುದು
ವ್ಯವಸ್ಥೆಗಳ ನಡುವಿನ ಡೇಟಾ ಹಸ್ತಾಂತರಿಸುವಾಗ ಕಚ್ಚಾ ಪೂರ್ಣಾಂಕ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳಿಗೆ ಅವಲಂಬಿಸುವುದು ಗೊಂದಲಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು. ಈ ಕಾರಣದಿಂದಾಗಿ ISO 8601 (2022-05-17T12:00:00Z) ಎಂಬ ವಿಶ್ವದಾದ್ಯಂತದ ಸ್ಟ್ರಿಂಗ್ ರೂಪವನ್ನು ಮಾನದಂಡಗೊಳಿಸುವುದು ಉತ್ತಮ ರಕ್ಷಣಾತ್ಮಕ ಚಲನೆ. ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು (ಉದಾ: 1652905200) ಈ ರೀತಿಯ ಸ್ಪಷ್ಟ, ಸ್ವಯಂ-ದಾಖಲೆ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು, ಕ್ರಾಸ್-ಟೈಮ್ಜೋನ್ API ಕರೆಗಳಲ್ಲಿ 37% ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
72% ಫಾರ್ಚ್ಯೂನ್ 500 ಕಂಪನಿಗಳು ಲಾಗ್ ವಿಶ್ಲೇಷಣೆಗೆ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಬಳಸುತ್ತವೆ, ಅಲ್ಲಿ ಒಬ್ಬ ಒಬ್ಬ ತಪ್ಪು $10,000 ಕ್ಕಿಂತ ಹೆಚ್ಚು ನಿಲ್ಲುವಿಕೆಗೆ ವೆಚ್ಚವಾಗಬಹುದು, ಶ್ರೇಷ್ಠತೆಯು ಎಲ್ಲವನ್ನೂ ಹೊಂದಿದೆ. ವಿಭಿನ್ನ ಉದ್ಯಮಗಳಲ್ಲಿ ಎಪೋಚ್ ಸಮಯವನ್ನು ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ನೀವು EpochConverter ನಲ್ಲಿ ಹೆಚ್ಚು ಓದುತ್ತೀರಿ.
ಡೇಟಾಬೇಸ್ಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಿರುವವರಿಗೆ, ನಿರಂತರ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ನಿರ್ವಹಣೆ ತಕ್ಷಣವೇ ಮಹತ್ವಪೂರ್ಣವಾಗಿದೆ. ನಿಮ್ಮ ಡೇಟಾಬೇಸ್ನಲ್ಲಿ ವಿಭಿನ್ನ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ರೂಪಗಳೊಂದಿಗೆ ನಿರಂತರವಾಗಿ ಹೋರಾಡುತ್ತಿದ್ದರೆ, ಶಕ್ತಿಯುತ SQL ಫಾರ್ಮ್ಯಾಟರ್ ಅನ್ನು ಬಳಸುವ ಕುರಿತು ನಮ್ಮ ಮಾರ್ಗದರ್ಶನವು ನಿಮ್ಮ ಕ್ವೆರಿಗಳನ್ನು ಸ್ವಚ್ಛ ಮತ್ತು ನಿರೀಕ್ಷಿತವಾಗಿರಿಸಲು ಸಹಾಯ ಮಾಡಬಹುದು.
ಈ ನಿರ್ಧಾರ ಮರವು ನಿಮ್ಮ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗೆ ಸರಿಯಾದ ಆದೇಶವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಶೀಘ್ರ ಪರಿವರ್ತನೆಯಾಗುವಾಗ ವ್ಯಾಕರಣ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.
ಮೇಲಿನ ಫ್ಲೋಚಾರ್ಟ್ ಲಿನಕ್ಸ್ನಲ್ಲಿ date ಆದೇಶದ (-d @...) ಮತ್ತು macOS (-r ...) ನಡುವಿನ ಪ್ರಮುಖ ವ್ಯಾಕರಣ ವ್ಯತ್ಯಾಸವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ತೋರಿಸುತ್ತದೆ—ವಿಭಿನ್ನ ಪರಿಸರಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ಡೆವೆಲಪರ್ಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಬಿಕ್ಕಟ್ಟಾಗುತ್ತದೆ.
ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಬಲಗೊಳಿಸಲು, ಬರುವ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ನ ಉದ್ದವನ್ನು ಮಾನ್ಯಗೊಳಿಸಲು ಯಾವಾಗಲೂ ಪರಿಶೀಲನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ. 10-ಅಂಕಿಯ (ಸೆಕೆಂಡುಗಳು) ಅಥವಾ 13-ಅಂಕಿಯ (ಮಿಲಿಸೆಕೆಂಡುಗಳು) ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುವ ಸರಳ ಕಾರ್ಯವು ಈ ದೋಷಗಳನ್ನು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ನ ತರ್ಕವನ್ನು ಹಾಳು ಮಾಡುವ ಮೊದಲು ಹಿಡಿಯಬಹುದು.
ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳು
ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಬಳಸಲು ನೀವು ಹ್ಯಾಂಗ್ ಆದ ನಂತರ, ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಪ್ರಶ್ನೆಗಳು ಬಹಳಷ್ಟು ಸಮಯದಲ್ಲಿ ಉದ್ಭವಿಸುತ್ತವೆ. ನಾನು ಈ ಪ್ರಶ್ನೆಗಳನ್ನು ಎಲ್ಲಾ ಮಟ್ಟದ ಡೆವೆಲಪರ್ಗಳನ್ನು ತಲುಪಿಸುತ್ತಿರುವುದನ್ನು ನೋಡಿದ್ದೇನೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ದಿನನಿತ್ಯದ ಕೆಲಸದಲ್ಲಿ ನೀವು ಎದುರಿಸುವ ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದವುಗಳನ್ನು ಸ್ಪಷ್ಟಗೊಳಿಸೋಣ.
ಇಷ್ಟು APIs ಯು ISO 8601 ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಬದಲು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಬಳಸುತ್ತವೆ ಏಕೆ?
ಇದು ಕಚ್ಚಾ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಬರುವುದಾಗಿದೆ. ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಕೇವಲ ಒಂದು ಸಂಖ್ಯೆಯಾಗಿದೆ, ಇದನ್ನು '2023-10-27T10:00:00Z' ಎಂಬ ಸ್ಟ್ರಿಂಗ್ಗಿಂತ ಬಹಳ ಹೆಚ್ಚು ಸಂಕೋಚನಗೊಳಿಸುತ್ತದೆ.
ಅದು ಚಿಕ್ಕ ಗಾತ್ರವು ಕೇಬಲ್ ಮೂಲಕ ಕಳುಹಿಸಲು ಕಡಿಮೆ ಡೇಟಾವನ್ನು ಅರ್ಥೈಸುತ್ತದೆ, ಇದು ಬ್ಯಾಂಡ್ವಿಡ್ತ್ ಅನ್ನು ಉಳಿಸುತ್ತದೆ ಮತ್ತು API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ.
ಅವು ಸಂಪೂರ್ಣವಾಗಿ ಭಾಷಾ-ಅಜ್ಞಾತವಾಗಿವೆ. ಇಲ್ಲಿ ಯಾವುದೇ ಅಸ್ಪಷ್ಟತೆ, ಯಾವುದೇ ಪಾರ್ಸಿಂಗ್ ವಿಚಿತ್ರತೆಗಳು ಮತ್ತು ಯಾವುದೇ ಪ್ರಾದೇಶಿಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಗ್ಗೆ ಚಿಂತನ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ. ಯಂತ್ರಕ್ಕಾಗಿ, ಸಂಖ್ಯೆಗಳ ಗಣನೆ ಯಾವಾಗಲೂ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದಕ್ಕಿಂತ ವೇಗವಾಗಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಯಾವುದೇ ದಿನಾಂಕದ ಲೆಕ್ಕಾಚಾರಗಳು—ಎರಡು ಘಟನೆಗಳ ನಡುವಿನ ಸಮಯವನ್ನು ನಿರ್ಧರಿಸುವಂತಹ—ಗಣಿತಾತ್ಮಕವಾಗಿ ಕಡಿಮೆ ವೆಚ್ಚದಾಗಿರುತ್ತವೆ. ಉನ್ನತ ಕಾರ್ಯಕ್ಷಮತೆಯ ವ್ಯವಸ್ಥೆಗಳಿಗಾಗಿ, ಈ ಸರಳತೆ ದೊಡ್ಡ ಜಯವಾಗಿದೆ.
ಕಾಲವಲಯಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಲು ಸರಿಯಾದ ಮಾರ್ಗವೇನು?
ಇದು ದೊಡ್ಡದು. ಇಲ್ಲಿದೆ ಬೆಳ್ಳಿ ನಿಯಮ: ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಯಾವಾಗಲೂ, ಯಾವಾಗಲೂ UTCನಲ್ಲಿ ಇರುತ್ತದೆ. ಇದರಲ್ಲಿ ಕಾಲವಲಯದ ಯಾವುದೇ ಪರಿಕಲ್ಪನೆಯಿಲ್ಲ. ಇದು ಕೇವಲ ಯುಗದಿಂದ ಸೆಕೆಂಡುಗಳ ಕಚ್ಚಾ ಸಂಖ್ಯೆಯಾಗಿದೆ.
ಕಾಲವಲಯಗಳು ನೀವು ಆ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಮಾನವನಿಗೆ ತೋರಿಸಲು ಬೇಕಾದಾಗ ಮಾತ್ರ ಮುಖ್ಯವಾಗುತ್ತವೆ.
ನನ್ನ ಸಲಹೆ ಏನು? ಬ್ಯಾಕ್ಎಂಡ್ನಲ್ಲಿ ಎಲ್ಲದರಿಗಾಗಿ UTCಗೆ ಅಂಟಿಕೊಳ್ಳಿ. ನಿಮ್ಮ ಡೇಟಾಬೇಸ್ನಲ್ಲಿ UTC ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಆಗಿ ಇದನ್ನು ಸಂಗ್ರಹಿಸಿ, ನಿಮ್ಮ APIs ಮೂಲಕ UTCನಲ್ಲಿ ಕಳುಹಿಸಿ, ಮತ್ತು ನಿಮ್ಮ ಸರ್ವರ್-ಪಕ್ಷದ ತರ್ಕವನ್ನು UTCನಲ್ಲಿ ಮಾಡಿ. ನೀವು ಅದನ್ನು ಸ್ಥಳೀಯ ಕಾಲವಲಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಬೇಕಾದ ಏಕೈಕ ಸಮಯವು ಬಳಕೆದಾರನಿಗೆ ತೋರಿಸುವ ಮೊದಲು ಮುಂಭಾಗದಲ್ಲಿ ಆಗಿರುತ್ತದೆ. ಈ ಏಕೈಕ ಅಭ್ಯಾಸವು ನಿಮಗೆ ಕಾಲವಲಯ ಮತ್ತು ದಿನದ ಬೆಳಕು ಉಳಿಸುವ ದೋಷಗಳ ಸಂಪೂರ್ಣ ಬ್ರಹ್ಮಾಂಡದಿಂದ ನಿಮ್ಮನ್ನು ಉಳಿಸುತ್ತದೆ.
ನಾನು 2038 ವರ್ಷದ ಸಮಸ್ಯೆ ಬಗ್ಗೆ ಇನ್ನೂ ಚಿಂತನ ಮಾಡಬೇಕೆ?
ಬಹುತೇಕ ಹೊಸ ಯೋಜನೆಗಳಿಗೆ, ಬಹುಶಃ ಇಲ್ಲ. "2038 ವರ್ಷದ ಸಮಸ್ಯೆ" ಎಂಬುದು 32-ಬಿಟ್ ಸಹಿ ಪೂರ್ಣಾಂಕ ಅನ್ನು ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸುವ ಹಳೆಯ ವ್ಯವಸ್ಥೆಗಳ ಒಂದು ಹಂಗೋವರ್ ಆಗಿದೆ. ಆ ಸಂಖ್ಯೆಯು ತುಂಬಾ ದೊಡ್ಡದಾದಾಗ, ಇದು ಸುತ್ತುತ್ತದೆ ಮತ್ತು ಋಣಾತ್ಮಕವಾಗುತ್ತದೆ, ದಿನಾಂಕಗಳನ್ನು 1901ಕ್ಕೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಧನ್ಯವಾದಗಳು, ಪ್ರಾಯೋಗಿಕವಾಗಿ ಎಲ್ಲಾ ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳು—ಆಪರೇಟಿಂಗ್ ವ್ಯವಸ್ಥೆಗಳಿಂದ ಡೇಟಾಬೇಸ್ಗಳಿಗೆ—ಹಳೆಯದಾಗಿ 64-ಬಿಟ್ ಪೂರ್ಣಾಂಕಗಳಿಗೆ ಹೋಗಿವೆ. ಇದು ವಾಸ್ತವವಾಗಿ ಕ್ಯಾಂನ್ನು ಇಷ್ಟು ದೂರ (ವಾಸ್ತವವಾಗಿ ಶತಕೋಟಿ ವರ್ಷಗಳು) ತಳ್ಳುತ್ತದೆ, ಇದು ಈಗ ನಮ್ಮಿಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಚಿಂತನವಲ್ಲ.
ಆದರೆ, ನೀವು ಹಳೆಯ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತಿದ್ದರೆ ಅಥವಾ ಎಂಬೆಡ್ಡೆಡ್ ಹಾರ್ಡ್ವೇರ್ನಲ್ಲಿ (IoT ಸಾಧನಗಳನ್ನು ಯೋಚಿಸಿ) ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಇದು ಖಂಡಿತವಾಗಿಯೂ ಗಮನದಲ್ಲಿರಬೇಕಾದ ವಿಷಯವಾಗಿದೆ. ನೀವು ಯಾವ ರೀತಿಯ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂಬುದನ್ನು ಯಾವಾಗಲೂ ತಿಳಿಯಿರಿ.
ನಾನು ಎಕ್ಸೆಲ್ ಅಥವಾ ಗೂಗಲ್ ಶೀಟ್ಸ್ನಲ್ಲಿ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಶೀಘ್ರವಾಗಿ ಹೇಗೆ ಪರಿವರ್ತಿಸಬಹುದು?
ನೀವು ಈಗಾಗಿ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಪ್ರತ್ಯೇಕ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕದಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ. ಒಂದು ಸರಳ ಸೂತ್ರವು ಕೆಲಸ ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ A1 ಸೆಲ್ನಲ್ಲಿ ಇದ್ದರೆ:
- ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳಿಗಾಗಿ (10 ಅಂಕಿಗಳು):
=A1 / 86400 + DATE(1970,1,1) - ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳಿಗಾಗಿ (13 ಅಂಕಿಗಳು):
=A1 / 86400000 + DATE(1970,1,1)
ಅದರ ಸೂತ್ರವನ್ನು ಹಾಕಿ, ನಂತರ ಸೆಲ್ ಅನ್ನು "ದಿನಾಂಕ" ಅಥವಾ "ದಿನಾಂಕ ಸಮಯ" ಎಂದು ಫಾರ್ಮಾಟ್ ಮಾಡಿ. ನೀವು ಶೀಘ್ರವಾಗಿ ಡೇಟಾ ಎಕ್ಸ್ಪೋರ್ಟ್ಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತಿರುವಾಗ ಮತ್ತು ನಿಮ್ಮ ಹರಿವನ್ನು ಮುರಿಯಲು ಬಯಸುವುದಿಲ್ಲ, ಇದು ಜೀವ ಉಳಿಸುವುದು.
ಸರಳ ಕಾರ್ಯಗಳಿಗೆ ನಿಮ್ಮ ಸಂಪಾದಕ, ಕಮಾಂಡ್ ಲೈನ್ ಮತ್ತು ಹತ್ತು ಬ್ರೌಸರ್ ಟ್ಯಾಬ್ಗಳ ನಡುವೆ ನಿರಂತರವಾಗಿ ಬದಲಾಯಿಸಲು ಕಳವಳವಾಗಿದ್ದೀರಾ? ShiftShift Extensions ಪ್ಯಾಕೇಜ್ ಶಕ್ತಿಶಾಲಿ ಯುನಿಕ್ಸ್ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕ, JSON ಫಾರ್ಮ್ಯಾಟರ್, SQL ಸುಂದರೀಕರಿಸುವಿಕೆ ಮತ್ತು ಇತರವುಗಳನ್ನು ನಿಮ್ಮ ಬ್ರೌಸರ್ನಲ್ಲಿ ನೇರವಾಗಿ ಒಡನೆ ಒಯ್ಯುತ್ತದೆ. ನೀವು ಬೇಕಾದ ಎಲ್ಲವೂ ಕೀಬೋರ್ಡ್ ಶಾರ್ಟ್ಕಟ್ಗಳಿಗೆ ಹತ್ತಿರವೇ ಇದೆ.
