ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕ

ಪರಿಚಯ

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಪೋಸಿಕ್ಸ್ ಟೈಮ್ ಅಥವಾ ಎಪೋಕ್ ಟೈಮ್ ಎಂದು ಕೂಡ ಕರೆಯಲಾಗುತ್ತದೆ) ಕಾಲದ ಒಂದು ಬಿಂದುವನ್ನು ವರ್ಣಿಸಲು ಬಳಸುವ ಒಂದು ವ್ಯವಸ್ಥೆ. ಇದು 1970 ಜನವರಿ 1 ರಿಂದ (ಮಧ್ಯಾಹ್ನ UTC/GMT) ಲೀಪ್ ಸೆಕೆಂಡುಗಳನ್ನು ಪರಿಗಣಿಸದೆ ಕಳೆದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ. ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಕಂಪ್ಯೂಟರ್ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಮತ್ತು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಅವವು ನಿರ್ದಿಷ್ಟ ಕ್ಷಣವನ್ನು ಸೂಚಿಸಲು ಸಂಕೀರ್ಣ, ಭಾಷಾ-ಸ್ವಾತಂತ್ರ್ಯವಾದ ಪ್ರತಿನಿಧಿಯನ್ನು ಒದಗಿಸುತ್ತವೆ.

ಈ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ನಿಂದ ದಿನಾಂಕ ಪರಿವರ್ತಕ ವಿವಿಧ ಉದ್ದಗಳ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಗುರುತಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು), ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು), ಮತ್ತು ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (10 ಅಂಕಿಗಳು) ಒಳಗೊಂಡಿವೆ. ಈ ಸಾಧನವು ಇನ್ಪುಟ್ ಉದ್ದವನ್ನು ಆಧರಿಸಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪವನ್ನು ಗುರುತಿಸುತ್ತದೆ, ಇದನ್ನು ಮಾನವ ಓದಲು ಸುಲಭವಾದ ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರರು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅಗತ್ಯವಿಲ್ಲದೆ ಫಲಿತಾಂಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಇದು 12-ಗಂಟೆಗಳ (ಎಮ್/ಪಿಎಂ) ಮತ್ತು 24-ಗಂಟೆಗಳ ಸಮಯ ರೂಪಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಇದು ವಿಭಿನ್ನ ಪ್ರಾದೇಶಿಕ ಮತ್ತು ವೈಯಕ್ತಿಕ ಆದ್ಯತೆಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ.

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಯುನಿಕ್ಸ್ ಎಪೋಕ್ (1970 ಜನವರಿ 1, 00:00:00 UTC) ರಿಂದ ಕಳೆದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯಂತೆ ಲೆಕ್ಕಹಾಕಲ್ಪಡುತ್ತವೆ. ಇದು ಸಮಯ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಲೆಕ್ಕಹಾಕಲು ಮತ್ತು ದಿನಾಂಕಗಳನ್ನು ಸಂಕೀರ್ಣ ರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿಸುತ್ತದೆ.

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

1. ಯುನಿಕ್ಸ್ ಎಪೋಕ್ (1970 ಜನವರಿ 1, 00:00:00 UTC) ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ
2. ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ನಲ್ಲಿ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೇರಿಸಿ
3. ಲೀಪ್ ವರ್ಷಗಳು, ಬದಲಾಗುವ ತಿಂಗಳ ಉದ್ದಗಳು ಮತ್ತು ಇತರ ಕ್ಯಾಲೆಂಡರ್ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಪರಿಗಣಿಸಿ
4. ಅಗತ್ಯವಿದ್ದರೆ ಟೈಮ್‌ಜೋನ್ ಸಮನ್ವಯಗಳನ್ನು ಅನ್ವಯಿಸಿ

ಉದಾಹರಣೆಗೆ, ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 1609459200 ಶನಿವಾರ, 2021 ಜನವರಿ 1, 00:00:00 UTC ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಪರಿವರ್ತನೆಯ ಸೂತ್ರವನ್ನು ಈ ರೀತಿಯಾಗಿ ವ್ಯಕ್ತಪಡಿಸಬಹುದು:

$\text{ದಿನಾಂಕ} = \text{ಯುನಿಕ್ಸ್ ಎಪೋಕ್} + \text{ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳಲ್ಲಿ)}$

ಬಹುಮಟ್ಟದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಮತ್ತು ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳು ಈ ಪರಿವರ್ತನೆಯನ್ನು ನಿರ್ವಹಿಸಲು ನಿರ್ಮಿತ ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ಸಂಕೀರ್ಣ ಕ್ಯಾಲೆಂಡರ್ ಲೆಕ್ಕಹಾಕುವಿಕೆಗಳನ್ನು ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಮಾಡುತ್ತದೆ.

ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪಗಳು ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಗುರುತಿಸುವಿಕೆ

ನಮ್ಮ ಪರಿವರ್ತಕವು ಮೂರು ಸಾಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಇದು ಅಂಕಿಗಳ ಸಂಖ್ಯೆಯ ಆಧಾರದಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಗುರುತಿಸಲಾಗುತ್ತದೆ:

1. ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (10 ಅಂಕಿಗಳು): ಯುನಿಕ್ಸ್ ಎಪೋಕ್‌ನಿಂದ ಸೆಕೆಂಡುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: 1609459200 (2021 ಜನವರಿ 1, 00:00:00 UTC)

2. ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು): ಯುನಿಕ್ಸ್ ಎಪೋಕ್‌ನಿಂದ ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: 1609459200000 (2021 ಜನವರಿ 1, 00:00:00 UTC)

3. ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು): ಯುನಿಕ್ಸ್ ಎಪೋಕ್‌ನಿಂದ ಮೈಕ್ರೋಸೆಕೆಂಡುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಉದಾಹರಣೆ: 1609459200000000 (2021 ಜನವರಿ 1, 00:00:00 UTC)

ಸ್ವಯಂಚಾಲಿತ ಗುರುತಿಸುವಿಕೆ ಇನ್ಪುಟ್‌ನ ಉದ್ದವನ್ನು ವಿಶ್ಲೇಷಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:

• ಇನ್ಪುಟ್ 10 ಅಂಕಿಗಳನ್ನು ಒಳಗೊಂಡರೆ, ಇದು ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು) ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ
• ಇನ್ಪುಟ್ 13 ಅಂಕಿಗಳನ್ನು ಒಳಗೊಂಡರೆ, ಇದು ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ
• ಇನ್ಪುಟ್ 16 ಅಂಕಿಗಳನ್ನು ಒಳಗೊಂಡರೆ, ಇದು ಮೈಕ್ರೋಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ

ಈ ಸ್ವಯಂಚಾಲಿತ ಗುರುತಿಸುವಿಕೆ ಬಳಕೆದಾರರಿಗೆ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅಗತ್ಯವಿಲ್ಲದೆ, ಸಾಧನವನ್ನು ಹೆಚ್ಚು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುತ್ತದೆ.

ಟೈಮ್ ರೂಪ ಆಯ್ಕೆಗಳು

ಈ ಪರಿವರ್ತಕವು ಎರಡು ಟೈಮ್ ರೂಪ ಆಯ್ಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ:

1. 24-ಗಂಟೆಗಳ ರೂಪ (ಕೆಲವು ಸಮಯದಲ್ಲಿ "ಸೈನಿಕ ಸಮಯ" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ): ಗಂಟೆಗಳು 0 ರಿಂದ 23 ರವರೆಗೆ, ಮತ್ತು ಎಮ್/ಪಿಎಂ ನಿರ್ಧಾರವಿಲ್ಲ. ಉದಾಹರಣೆ, 3:00 PM ಅನ್ನು 15:00 ಎಂದು ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.

2. 12-ಗಂಟೆಗಳ ರೂಪ: ಗಂಟೆಗಳು 1 ರಿಂದ 12 ರವರೆಗೆ, ಮಧ್ಯಾಹ್ನದಿಂದ ಮುಂಜಾನೆ (ಎಮ್) ಮತ್ತು ಮಧ್ಯಾಹ್ನದಿಂದ ರಾತ್ರಿ (ಪಿಎಂ) ಸಮಯಗಳಿಗೆ. ಉದಾಹರಣೆಗೆ, 24-ಗಂಟೆಗಳ ರೂಪದಲ್ಲಿ 15:00 ಅನ್ನು 3:00 PM ಎಂದು ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.

ಈ ರೂಪಗಳ ನಡುವಿನ ಆಯ್ಕೆ ಬಹುಶಃ ಪ್ರಾದೇಶಿಕ ಪರಂಪರೆ ಮತ್ತು ವೈಯಕ್ತಿಕ ಆದ್ಯತೆಗಳ ವಿಷಯವಾಗಿದೆ:

• 24-ಗಂಟೆಗಳ ರೂಪವು ಯುರೋಪ್, ಲ್ಯಾಟಿನ್ ಅಮೆರಿಕಾ ಮತ್ತು ಏಷ್ಯಾದ ಹೆಚ್ಚಿನ ಭಾಗಗಳಲ್ಲಿ, ವಿಜ್ಞಾನ, ಸೇನೆ ಮತ್ತು ವೈದ್ಯಕೀಯ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ವಿಶ್ವಾದ್ಯಾಂತ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.
• 12-ಗಂಟೆಗಳ ರೂಪವು ಯುನೈಟೆಡ್ ಸ್ಟೇಟ್ಸ್, ಕೆನಡಾ, ಆಸ್ಟ್ರೇಲಿಯಾ ಮತ್ತು ಇತರ ಕೆಲವು ಇಂಗ್ಲಿಷ್ ಮಾತನಾಡುವ ದೇಶಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಎಜ್ ಕೇಸ್‌ಗಳು ಮತ್ತು ನಿರ್ಬಂಧಗಳು

ವಿವಿಧ ಶುದ್ಧತೆಗಳ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಹಲವಾರು ಎಜ್ ಕೇಸ್‌ಗಳು ಮತ್ತು ನಿರ್ಬಂಧಗಳನ್ನು ತಿಳಿಯುವುದು ಮುಖ್ಯವಾಗಿದೆ:

1. ಊರ್ಬ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು: ಇವು ಯುನಿಕ್ಸ್ ಎಪೋಕ್ (1970 ಜನವರಿ 1) ಗೆ ಮುಂಚಿನ ದಿನಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ. ಗಣಿತೀಯವಾಗಿ ಮಾನ್ಯವಾದರೂ, ಕೆಲವು ವ್ಯವಸ್ಥೆಗಳು ಊರ್ಬ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಇದು ಎಲ್ಲಾ ಮೂರು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪಗಳಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ.

2. 2038 ಸಮಸ್ಯೆ: ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (10 ಅಂಕಿಗಳು) ಸಾಮಾನ್ಯವಾಗಿ 32-ಬಿಟ್ ಸಹಾಯಿತ ಸಂಖ್ಯೆಗಳ ರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಇದು 2038 ಜನವರಿಯ 19 ರಂದು ಓವರ್ಫ್ಲೋ ಆಗುತ್ತದೆ. ಈ ಬಿಂದು ನಂತರ, 32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳು ಸರಿಯಾಗಿ ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅಸಮರ್ಥವಾಗುತ್ತವೆ, ಏಕೆಂದರೆ ಅವುಗಳನ್ನು ದೊಡ್ಡ ಸಂಖ್ಯಾ ಪ್ರಕಾರವನ್ನು ಬಳಸಲು ಪರಿಷ್ಕೃತಗೊಳಿಸಲಾಗಿಲ್ಲ.

3. ಶುದ್ಧತೆ ಪರಿಗಣನೆಗಳು:

   • ಮಾನಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (10 ಅಂಕಿಗಳು) ಸೆಕೆಂಡು-ಮಟ್ಟದ ಶುದ್ಧತೆಗೆ ಹೊಂದಿವೆ, ಇದು ಬಹುತೇಕ ದಿನನಿತ್ಯದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸಾಕಷ್ಟು.
   • ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (13 ಅಂಕಿಗಳು) ಹೆಚ್ಚು ಶುದ್ಧತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ, ಹೆಚ್ಚು ನಿಖರವಾದ ಸಮಯವನ್ನು ಅಗತ್ಯವಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ.
   • ಮೈಕ್ರೋಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (16 ಅಂಕಿಗಳು) ಇನ್ನಷ್ಟು ಸೂಕ್ಷ್ಮವಾದ ಶುದ್ಧತೆಯನ್ನು (1,000,000ನೇ ಸೆಕೆಂಡು) ಒದಗಿಸುತ್ತವೆ, ಇದು ಉನ್ನತ ಕಾರ್ಯಕ್ಷಮತೆ ಕಂಪ್ಯೂಟಿಂಗ್, ವೈಜ್ಞಾನಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಕೆಲವು ಹಣಕಾಸು ವ್ಯವಹಾರಗಳಿಗೆ ಅಗತ್ಯವಿದೆ.

4. ಅತಿಯಾಗಿ ದೊಡ್ಡ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು: ಬಹಳ ದೂರದ ಭವಿಷ್ಯದ ದಿನಾಂಕಗಳನ್ನು ಕೆಲವು ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಪ್ರತಿನಿಧಿಸಲಾಗದಿರಬಹುದು, ಅಥವಾ ಅಸಮಾನವಾಗಿ ನಿರ್ವಹಿಸಲಾಗಬಹುದು. ಇದು ವಿಶೇಷವಾಗಿ ಮಿಲಿಸೆಕೆಂಡು ಮತ್ತು ಮೈಕ್ರೋಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದೆ, ಏಕೆಂದರೆ ಅವುಗಳು ದೊಡ್ಡ ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುತ್ತವೆ.

5. ಲೀಪ್ ಸೆಕೆಂಡುಗಳು: ಯುನಿಕ್ಸ್ ಸಮಯವು ಲೀಪ್ ಸೆಕೆಂಡುಗಳನ್ನು ಪರಿಗಣಿಸುವುದಿಲ್ಲ, ಇದು UTC ಗೆ ಸಮಾನಾಂತರವಾಗಿ ಭೂಮಿ ಅಸಮಾನವಾದ ತಿರುಗುವಿಕೆಯನ್ನು ಪರಿಹರಿಸಲು ಸಮಯದಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಇದು ಯುನಿಕ್ಸ್ ಸಮಯವು ಜ್ಯೋತಿಷ್ಯ ಸಮಯದೊಂದಿಗೆ ನಿಖರವಾಗಿ ಸಮನ್ವಯಿತವಾಗಿಲ್ಲ ಎಂದು ಅರ್ಥವಾಗುತ್ತದೆ.

6. ಟೈಮ್‌ಜೋನ್ ಪರಿಗಣನೆಗಳು: ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು UTC ನಲ್ಲಿ ಕ್ಷಣಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ. ಸ್ಥಳೀಯ ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲು, ನೀವು ದಿನಾಂಕವನ್ನು ಪರಿವರ್ತಿಸುವ ನಂತರ ಸೂಕ್ತವಾದ ಟೈಮ್‌ಜೋನ್ ಮಾಹಿತಿಯನ್ನು ಅನ್ವಯಿಸಲು ಅಗತ್ಯವಿದೆ.

7. ಡೇಲೈಟ್ ಸೆವಿಂಗ್ ಟೈಮ್: ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಸ್ಥಳೀಯ ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸುವಾಗ, ಡೇಲೈಟ್ ಸೆವಿಂಗ್ ಟೈಮ್ ಪರಿವರ್ತನೆಗಳ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಪರಿಗಣಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ.

8. ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪದ ಗೊಂದಲ: ಸರಿಯಾದ ಗುರುತಿಸುವಿಕೆಯಿಲ್ಲದೆ, 13-ಅಂಕಿಯ ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಸೆಕೆಂಡು ಆಧಾರಿತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಎಂದು ಪರಿಗಣಿಸಿದರೆ, ಬಹಳ ದೂರದ ಭವಿಷ್ಯದ ದಿನಾಂಕವಾಗಿ ತಪ್ಪಾಗಿ ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳಬಹುದು. ನಮ್ಮ ಪರಿವರ್ತಕವು ಅಂಕಿಗಳ ಉದ್ದವನ್ನು ಆಧರಿಸಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರೂಪವನ್ನು ಗುರುತಿಸುವ ಮೂಲಕ ಇದನ್ನು ತಡೆಯುತ್ತದೆ.

ಬಳಕೆದಾರಿಕೆಗಳು

ವಿವಿಧ ಶುದ್ಧತೆಗಳ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಕಂಪ್ಯೂಟಿಂಗ್ ಮತ್ತು ಡೇಟಾ ನಿರ್ವಹಣೆಯ ಅನೇಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ:

1. ಡೇಟಾಬೇಸ್ ದಾಖಲೆಗಳು: ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಎಂಟ್ರಿಗಳು ಯಾವಾಗ ರಚಿಸಲಾದವು ಅಥವಾ ಪರಿಷ್ಕೃತವಾಗಿರುವುದನ್ನು ದಾಖಲಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

   • ಮಾನಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (10 ಅಂಕಿಗಳು) ಸಾಮಾನ್ಯ ಡೇಟಾಬೇಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸಾಕಷ್ಟು.
   • ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (13 ಅಂಕಿಗಳು) ಹೆಚ್ಚು ನಿಖರವಾದ ಘಟನೆಗಳ ಕ್ರಮವನ್ನು ಅಗತ್ಯವಿರುವಾಗ ಬಳಸಲಾಗುತ್ತವೆ.

2. ವೆಬ್ ಅಭಿವೃದ್ಧಿ: HTTP ಹೆಡರ್‌ಗಳು, ಕುಕ್ಕೀಗಳು ಮತ್ತು ಕ್ಯಾಶಿಂಗ್ ಯಂತ್ರಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ.

   • ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ Date.now() ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು (13 ಅಂಕಿಗಳು) ನೀಡುತ್ತದೆ.

3. ಲಾಗ್ ಫೈಲ್‌ಗಳು: ವ್ಯವಸ್ಥೆಯ ಲಾಗ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಘಟನೆಗಳನ್ನು ನಿಖರವಾದ ಕಾಲಕ್ರಮದಲ್ಲಿ ದಾಖಲಿಸಲು ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ದಾಖಲಿಸುತ್ತವೆ.

   • ಉನ್ನತ-ಆವೃತ್ತಿಯ ಲಾಗಿಂಗ್ ವ್ಯವಸ್ಥೆಗಳು ಮಿಲಿಸೆಕೆಂಡು ಅಥವಾ ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಯನ್ನು ಬಳಸಬಹುದು.

4. ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗಳು: ಗಿಟ್ ಮತ್ತು ಇತರ VCS ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ, ಯಾವಾಗ ಕಮಿಟ್‌ಗಳನ್ನು ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ದಾಖಲಿಸಲು.

5. API ಪ್ರತಿಸ್ಪಂದನೆಗಳು: ಅನೇಕ ವೆಬ್ APIಗಳು ಡೇಟಾ ಉತ್ಪಾದನೆಯಾಗಿರುವಾಗ ಅಥವಾ ಸಂಪತ್ತುಗಳನ್ನು ಕೊನೆಯ ಬಾರಿ ಪರಿಷ್ಕೃತವಾಗಿರುವಾಗ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ತಮ್ಮ ಪ್ರತಿಸ್ಪಂದನೆಗಳಲ್ಲಿ ಒಳಗೊಂಡಿರುತ್ತವೆ.

   • REST APIಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ.

6. ಫೈಲ್ ವ್ಯವಸ್ಥೆಗಳು: ಫೈಲ್ ನಿರ್ಮಾಣ ಮತ್ತು ಪರಿಷ್ಕರಣೆ ಸಮಯಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳಂತೆ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತವೆ.

7. ಸೆಷನ್ ನಿರ್ವಹಣೆ: ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಬಳಕೆದಾರ ಸೆಷನ್‌ಗಳು ಯಾವಾಗ ಅಂತ್ಯಗೊಳ್ಳಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ.

8. ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ: ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ವಿಶ್ಲೇಷಣಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ತಾತ್ಕಾಲಿಕ ಡೇಟಾವನ್ನು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಪ್ರಮಾಣಿತವಾಗಿ ಕೆಲಸ ಮಾಡುವ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ.

9. ಉನ್ನತ-ಆವೃತ್ತಿಯ ವ್ಯಾಪಾರ: ಹಣಕಾಸು ವ್ಯವಸ್ಥೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಯನ್ನು (16 ಅಂಕಿಗಳು) ಅಗತ್ಯವಿದೆ, ಇದರಿಂದ ವ್ಯವಹಾರಗಳನ್ನು ಸರಿಯಾಗಿ ಕ್ರಮಬದ್ಧಗೊಳಿಸಲು.

10. ವಿಜ್ಞಾನ ಮಾಪನಗಳು: ಸಂಶೋಧನಾ ಸಾಧನಗಳು ನಿಖರವಾದ ತಾತ್ಕಾಲಿಕ ವಿಶ್ಲೇಷಣೆಗೆ ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಯೊಂದಿಗೆ ನಿರೀಕ್ಷಣಗಳನ್ನು ದಾಖಲಿಸುತ್ತವೆ.

ಪರ್ಯಾಯಗಳು

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುವಾಗ, ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ ಹೆಚ್ಚು ಸೂಕ್ತವಾದ ಪರ್ಯಾಯ ಕಾಲದ ಪ್ರತಿನಿಧಿ ರೂಪಗಳು ಇವೆ:

1. ಐಎಸ್‌ಒ 8601: ಮಾನವ ಓದಲು ಸುಲಭವಾದ ಸ್ಟ್ರಿಂಗ್ ರೂಪ (ಉದಾಹರಣೆ: "2021-01-01T00:00:00Z") ಇದು ಶ್ರೇಣೀಬದ್ಧತೆಯನ್ನು ಕಾಪಾಡುತ್ತದೆ. ಇದು ಡೇಟಾ ವಿನಿಮಯ ಮತ್ತು ಬಳಕೆದಾರ ಮುಖಾಮುಖಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ಇಷ್ಟವಾಗಿದೆ.

2. RFC 3339: ಇಂಟರ್‌ನೆಟ್ ಪ್ರೋಟೋಕಾಲ್‌ಗಳಲ್ಲಿ ಬಳಸುವ ಐಎಸ್‌ಒ 8601 ನ ಒಂದು ಪ್ರೊಫೈಲ್, ಕಠಿಣ ರೂಪಾಂತರ ಅಗತ್ಯಗಳನ್ನು ಹೊಂದಿದೆ.

3. ಮಾನವ ಓದಲು ಸುಲಭವಾದ ರೂಪಗಳು: ಸ್ಥಳೀಯ ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್‌ಗಳು (ಉದಾಹರಣೆ: "ಜನವರಿ 1, 2021") ನೇರ ಬಳಕೆದಾರ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಾಗಿ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿವೆ ಆದರೆ ಲೆಕ್ಕಾಚಾರಕ್ಕಾಗಿ ಕಡಿಮೆ ಸೂಕ್ತವಾಗಿವೆ.

4. ಮೈಕ್ರೋಸಾಫ್ಟ್ ಫೈಲ್‌ಟೈಮ್: 1601 ಜನವರಿ 1 ರಿಂದ 100-ನಾನುಸೆಕೆಂಡುಗಳ ಅಂತರವನ್ನು ಪ್ರತಿನಿಧಿಸುವ 64-ಬಿಟ್ ಮೌಲ್ಯ, ವಿಂಡೋಸ್ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

5. ಜುಲಿಯನ್ ದಿನಾಂಕ ಸಂಖ್ಯೆ: ಜ್ಯೋತಿಷ್ಯ ಮತ್ತು ಕೆಲವು ವೈಜ್ಞಾನಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ, 4713 BCE ಜನವರಿ 1 ರಿಂದ ದಿನಗಳನ್ನು ಎಣಿಸುತ್ತದೆ.

ಕಾಲದ ರೂಪವನ್ನು ಆಯ್ಕೆ ಮಾಡುವಾಗ, ಈ ಕೆಳಗಿನ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ:

• ಅಗತ್ಯವಿರುವ ಶುದ್ಧತೆ
• ಮಾನವ ಓದುವ ಅಗತ್ಯಗಳು
• ಸಂಗ್ರಹಣೆ ನಿರ್ಬಂಧಗಳು
• ಈಗಿನ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆ
• ಪ್ರತಿನಿಧಿಸಲು ಅಗತ್ಯವಿರುವ ದಿನಾಂಕಗಳ ಶ್ರೇಣಿಯು

ಐತಿಹಾಸಿಕ

ಯುನಿಕ್ಸ್ ಸಮಯದ ಪರಿಕಲ್ಪನೆ 1960ರ ದಶಕದ ಕೊನೆಯಲ್ಲಿ ಮತ್ತು 1970ರ ಆರಂಭದಲ್ಲಿ ಬೆಲ್ ಲ್ಯಾಬ್‌ಗಳಲ್ಲಿ ಯುನಿಕ್ಸ್ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯ ಅಭಿವೃದ್ಧಿಯೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಯಿತು. ಎಪೋಕ್ ಅನ್ನು 1970 ಜನವರಿ 1 ಎಂದು ಬಳಸಲು ನಿರ್ಧಾರವು ಸ್ವಲ್ಪ ಅಕ್ರಮವಾಗಿದ್ದರೂ, ಆದರೆ ಸಮಯದಲ್ಲಿ ಶ್ರೇಣೀಬದ್ಧತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಇದು ಪ್ರಾಯೋಗಿಕವಾಗಿತ್ತು, ಆದರೆ ಇಷ್ಟಪಡುವ ದಿನಾಂಕಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಲು ಇದು ಹಳೆಯದಾಗಿತ್ತು.

ಮೂಲ ಅನುಷ್ಠಾನವು 32-ಬಿಟ್ ಸಹಾಯಿತ ಸಂಖ್ಯೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತಿತ್ತು, ಇದು ಆ ಸಮಯದಲ್ಲಿ ನಿರೀಕ್ಷಿತ ಯುನಿಕ್ಸ್ ವ್ಯವಸ್ಥೆಗಳ ಜೀವನಾವಧಿಗೆ ಸಾಕಷ್ಟು. ಆದರೆ, ಈ ನಿರ್ಧಾರವು 2038 ಸಮಸ್ಯೆಗೆ (ಕೆಲವು ಸಮಯದಲ್ಲಿ "Y2K38" ಅಥವಾ "ಯುನಿಕ್ಸ್ ಮಿಲೆನಿಯಮ್ ಬಗ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಕಾರಣವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ 32-ಬಿಟ್ ಸಹಾಯಿತ ಸಂಖ್ಯೆಗಳು 1970 ಜನವರಿ 1 ರಿಂದ 2038 ಜನವರಿ 19 (03:14:07 UTC) ವರೆಗೆ ದಿನಾಂಕಗಳನ್ನು ಮಾತ್ರ ಪ್ರತಿನಿಧಿಸಬಹುದು.

ಕಂಪ್ಯೂಟಿಂಗ್ ಅಗತ್ಯಗಳು ಅಭಿವೃದ್ಧಿ ಹೊಂದಿದಂತೆ, ಹೆಚ್ಚಿನ ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಅಗತ್ಯವಾಯಿತು:

• ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು) ಪರಸ್ಪರ ಕಂಪ್ಯೂಟಿಂಗ್ ಮತ್ತು ಬಳಕೆದಾರ ಇಂಟರ್‌ಫೇಸ್ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಅಳೆಯಲು ಅಗತ್ಯವಾಯಿತು.

• ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು) ಉನ್ನತ ಕಾರ್ಯಕ್ಷಮತೆ ಕಂಪ್ಯೂಟಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಸಮಯದ ಅತ್ಯಂತ ನಿಖರವಾದ ಸಮಯವನ್ನು ಅಗತ್ಯವಿರುವ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಉದಯಿಸುತ್ತವೆ.

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

ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳು ಹೆಚ್ಚು ಶ್ರೇಣಿಯ 64-ಬಿಟ್ ಸಂಖ್ಯೆಗಳಿಗಾಗಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ, ಇದು ಎಪೋಕ್‌ನಿಂದ ಸುಮಾರು 292 ಬಿಲಿಯನ್ ವರ್ಷಗಳ ಕಾಲ ಪ್ರತಿನಿಧಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಇದು 2038 ಸಮಸ್ಯೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿಹರಿಸುತ್ತದೆ. ಆದರೆ, ಹಳೆಯ ವ್ಯವಸ್ಥೆಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಇನ್ನೂ ಅಪಾಯದಲ್ಲಿರಬಹುದು.

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳ ಸರಳತೆ ಮತ್ತು ಉಪಯುಕ್ತತೆ ಅದರ ಮುಂದಿನ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸಿದೆ, ಹೆಚ್ಚು ಸುಧಾರಿತ ಕಾಲದ ಪ್ರತಿನಿಧಿ ರೂಪಗಳ ಅಭಿವೃದ್ಧಿಯ ನಂತರವೂ. ಇದು ಕಂಪ್ಯೂಟಿಂಗ್‌ನಲ್ಲಿ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಯಾಗಿದ್ದು, ನಮ್ಮ ಡಿಜಿಟಲ್ ಮೂಲಸೌಕರ್ಯವನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.

ಕೋಡ್ ಉದಾಹರಣೆಗಳು

ಇಲ್ಲಿ ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ವಿವಿಧ ಶುದ್ಧತೆಯ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಮಾನವ ಓದಲು ಸುಲಭವಾದ ದಿನಾಂಕಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

1// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ ಸ್ವಯಂಚಾಲಿತ ರೂಪ ಗುರುತಿಸುವಿಕೆಯಿಂದ
2function convertTimestamp(timestamp, use12Hour = false) {
3  // ಅಗತ್ಯವಿದ್ದರೆ ಸಂಖ್ಯೆಗೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪರಿವರ್ತಿಸಿ
4  const numericTimestamp = Number(timestamp);
5  
6  // ಅಂಕಿಗಳ ಉದ್ದವನ್ನು ಆಧರಿಸಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪವನ್ನು ಗುರುತಿಸಿ
7  let date;
8  if (timestamp.length === 16) {
9    // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (ಸೆಕೆಂಡುಗಳನ್ನು ಪಡೆಯಲು 1,000,000 ರಿಂದ ಭಾಗಿಸಿ)
10    date = new Date(numericTimestamp / 1000);
11    console.log("ಗುರುತಿಸಲಾಗಿದೆ: ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್");
12  } else if (timestamp.length === 13) {
13    // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ
14    date = new Date(numericTimestamp);
15    console.log("ಗುರುತಿಸಲಾಗಿದೆ: ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್");
16  } else if (timestamp.length === 10) {
17    // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)
18    date = new Date(numericTimestamp * 1000);
19    console.log("ಗುರುತಿಸಲಾಗಿದೆ: ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)");
20  } else {
21    throw new Error("ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ. 10, 13, ಅಥವಾ 16 ಅಂಕಿಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.");
22  }
23  
24  // ರೂಪ ಆಯ್ಕೆಗಳು
25  const options = {
26    year: 'numeric',
27    month: 'long',
28    day: 'numeric',
29    weekday: 'long',
30    hour: use12Hour ? 'numeric' : '2-digit',
31    minute: '2-digit',
32    second: '2-digit',
33    hour12: use12Hour
34  };
35  
36  // ಸ್ಥಳೀಯ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಿ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಿ
37  return date.toLocaleString(undefined, options);
38}
39
40// ಉದಾಹರಣಾ ಬಳಕೆ
41try {
42  // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (10 ಅಂಕಿಗಳು)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# ಪೈಥಾನ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ ಸ್ವಯಂಚಾಲಿತ ರೂಪ ಗುರುತಿಸುವಿಕೆಯಿಂದ
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # ಸಂಖ್ಯೆಗೆ ಪರಿವರ್ತಿಸಿ
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # ಅಂಕಿಗಳ ಉದ್ದವನ್ನು ಆಧರಿಸಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪವನ್ನು ಗುರುತಿಸಿ
10    if len(timestamp) == 16:
11        # ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (ಸೆಕೆಂಡುಗಳನ್ನು ಪಡೆಯಲು 1,000,000 ರಿಂದ ಭಾಗಿಸಿ)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("ಗುರುತಿಸಲಾಗಿದೆ: ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್")
14    elif len(timestamp) == 13:
15        # ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (ಸೆಕೆಂಡುಗಳನ್ನು ಪಡೆಯಲು 1,000 ರಿಂದ ಭಾಗಿಸಿ)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("ಗುರುತಿಸಲಾಗಿದೆ: ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್")
18    elif len(timestamp) == 10:
19        # ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("ಗುರುತಿಸಲಾಗಿದೆ: ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)")
22    else:
23        raise ValueError("ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ. 10, 13, ಅಥವಾ 16 ಅಂಕಿಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.")
24    
25    # ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರೂಪಿಸಲು
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-ಗಂಟೆಗಳ ರೂಪ AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-ಗಂಟೆಗಳ ರೂಪ
30    
31    return date.strftime(format_string)
32
33# ಉದಾಹರಣಾ ಬಳಕೆ
34try:
35    # ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (10 ಅಂಕಿಗಳು)
36    print(convert_timestamp("1609459200", False))
37    
38    # ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು)
39    print(convert_timestamp("1609459200000", False))
40    
41    # ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// PHP ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ ಸ್ವಯಂಚಾಲಿತ ರೂಪ ಗುರುತಿಸುವಿಕೆಯಿಂದ
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // ಸ್ಟ್ರಿಂಗ್‌ಗಾಗಿ ಇನ್ಪುಟ್ ಅನ್ನು ಟ್ರಿಮ್ ಮಾಡಿ
5    $timestamp = trim((string)$timestamp);
6    
7    // ಅಂಕಿಗಳ ಉದ್ದವನ್ನು ಆಧರಿಸಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪವನ್ನು ಗುರುತಿಸಿ
8    if (strlen($timestamp) === 16) {
9        // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (ಸೆಕೆಂಡುಗಳನ್ನು ಪಡೆಯಲು 1,000,000 ರಿಂದ ಭಾಗಿಸಿ)
10        $seconds = (float)$timestamp / 1000000;
11        echo "ಗುರುತಿಸಲಾಗಿದೆ: ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್\n";
12    } elseif (strlen($timestamp) === 13) {
13        // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (ಸೆಕೆಂಡುಗಳನ್ನು ಪಡೆಯಲು 1,000 ಅನ್ನು ಭಾಗಿಸಿ)
14        $seconds = (float)$timestamp / 1000;
15        echo "ಗುರುತಿಸಲಾಗಿದೆ: ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್\n";
16    } elseif (strlen($timestamp) === 10) {
17        // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)
18        $seconds = (float)$timestamp;
19        echo "ಗುರುತಿಸಲಾಗಿದೆ: ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)\n";
20    } else {
21        throw new Exception("ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ. 10, 13, ಅಥವಾ 16 ಅಂಕಿಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.");
22    }
23    
24    // ರೂಪ ಸ್ಟ್ರಿಂಗ್
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12-ಗಂಟೆಗಳ ರೂಪ AM/PM
27        : 'l, F j, Y H:i:s';   // 24-ಗಂಟೆಗಳ ರೂಪ
28    
29    // ದಿನಾಂಕವನ್ನು ಪರಿವರ್ತಿಸಿ ಮತ್ತು ರೂಪಿಸಿ
30    return date($formatString, $seconds);
31}
32
33// ಉದಾಹರಣಾ ಬಳಕೆ
34try {
35    // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (10 ಅಂಕಿಗಳು)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// ಜಾವಾ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ ಸ್ವಯಂಚಾಲಿತ ರೂಪ ಗುರುತಿಸುವಿಕೆಯಿಂದ
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class TimestampConverter {
8    public static String convertTimestamp(String timestamp, boolean use12Hour) {
9        // ಇನ್ಪುಟ್ ಅನ್ನು ಟ್ರಿಮ್ ಮಾಡಿ
10        timestamp = timestamp.trim();
11        
12        // ಅಂಕಿಗಳ ಉದ್ದವನ್ನು ಆಧರಿಸಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪವನ್ನು ಗುರುತಿಸಿ
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (ಸೆಕೆಂಡುಗಳನ್ನು ಪಡೆಯಲು 1,000,000 ರಿಂದ ಭಾಗಿಸಿ)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // ನಾನೋಸೆಕೆಂಡುಗಳಿಗೆ ಪರಿವರ್ತಿಸಿ
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("ಗುರುತಿಸಲಾಗಿದೆ: ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್");
20        } else if (timestamp.length() == 13) {
21            // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("ಗುರುತಿಸಲಾಗಿದೆ: ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್");
26        } else if (timestamp.length() == 10) {
27            // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("ಗುರುತಿಸಲಾಗಿದೆ: ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)");
32        } else {
33            throw new IllegalArgumentException("ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ. 10, 13, ಅಥವಾ 16 ಅಂಕಿಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.");
34        }
35        
36        // ಅಗತ್ಯವಿರುವ ರೂಪವನ್ನು ಆಧರಿಸಿ ಫಾರ್ಮ್ಯಾಟರ್ ಅನ್ನು ರಚಿಸಿ
37        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
38            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
39        );
40        
41        // ದಿನಾಂಕವನ್ನು ರೂಪಿಸಿ
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (10 ಅಂಕಿಗಳು)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ ಸ್ವಯಂಚಾಲಿತ ರೂಪ ಗುರುತಿಸುವಿಕೆಯಿಂದ
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // ಇನ್ಪುಟ್ ಅನ್ನು ಟ್ರಿಮ್ ಮಾಡಿ
9        timestamp = timestamp.Trim();
10        
11        // ಅಂಕಿಗಳ ಉದ್ದವನ್ನು ಆಧರಿಸಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪವನ್ನು ಗುರುತಿಸಿ
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (ಸೆಕೆಂಡುಗಳನ್ನು ಪಡೆಯಲು 1,000,000 ರಿಂದ ಭಾಗಿಸಿ)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ");
18                
19            // ಮೈಕ್ರೋಸೆಕೆಂಡುಗಳನ್ನು DateTime ಗೆ ಪರಿವರ್ತಿಸಿ
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("ಗುರುತಿಸಲಾಗಿದೆ: ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("ಗುರುತಿಸಲಾಗಿದೆ: ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("ಗುರುತಿಸಲಾಗಿದೆ: ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)");
40        }
41        else
42        {
43            throw new ArgumentException("ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ. 10, 13, ಅಥವಾ 16 ಅಂಕಿಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.");
44        }
45        
46        // 12-ಗಂಟೆಗಳ ಅಥವಾ 24-ಗಂಟೆಗಳ ಆದ್ಯತೆಯನ್ನು ಆಧರಿಸಿ ರೂಪ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಚಿಸಿ
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-ಗಂಟೆಗಳ ರೂಪ AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-ಗಂಟೆಗಳ ರೂಪ
50        
51        // ರೂಪಿತ ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (10 ಅಂಕಿಗಳು)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

ಎಜ್ ಕೇಸ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ವಿವಿಧ ಶುದ್ಧತೆಗಳ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಎಜ್ ಕೇಸ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಇಲ್ಲಿ ಸಮಗ್ರ ಎಜ್ ಕೇಸ್ ನಿರ್ವಹಣೆಯನ್ನು ತೋರಿಸುವ ಉದಾಹರಣೆ ಇದೆ:

1// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಮಗ್ರ ಎಜ್ ಕೇಸ್ ನಿರ್ವಹಣೆ ಹಲವಾರು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪಗಳಿಗೆ
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // ಇನ್ಪುಟ್ ಪರಿಶೀಲನೆ
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "ದೋಷ: ಖಾಲಿ ಅಥವಾ ನಿರ್ಧರಿಸಲಾಗದ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್";
6  }
7  
8  // ಅಂಕಿಗಳ ಉದ್ದವನ್ನು ಪರಿಶೀಲಿಸಲು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಖಚಿತಪಡಿಸಿ
9  const timestampStr = String(timestamp).trim();
10  
11  // ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ನಲ್ಲಿ ಕೇವಲ ಅಂಕಿಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಿ
12  if (!/^\d+$/.test(timestampStr)) {
13    return "ದೋಷ: ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಕೇವಲ ಅಂಕಿಗಳನ್ನು ಒಳಗೊಂಡಿರಬೇಕು";
14  }
15  
16  // ರೂಪವನ್ನು ಆಧರಿಸಿ ಗುರುತಿಸಿ
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // ಮಿಲಿಸೆಕೆಂಡುಗಳಿಗೆ ಪರಿವರ್ತಿಸಿ
23      console.log("ಮೈಕ್ರೋಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಿದೆ (16 ಅಂಕಿಗಳು)");
24      
25      // ಅಮಾನ್ಯ ದಿನಾಂಕವನ್ನು ಪರಿಶೀಲಿಸಿ
26      if (isNaN(date.getTime())) {
27        return "ದೋಷ: ಅಮಾನ್ಯ ಮೈಕ್ರೋಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್";
28      }
29    } else if (timestampStr.length === 13) {
30      // ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಿದೆ (13 ಅಂಕಿಗಳು)");
34      
35      // ಅಮಾನ್ಯ ದಿನಾಂಕವನ್ನು ಪರಿಶೀಲಿಸಿ
36      if (isNaN(date.getTime())) {
37        return "ದೋಷ: ಅಮಾನ್ಯ ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್";
38      }
39    } else if (timestampStr.length === 10) {
40      // ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಸೆಕೆಂಡುಗಳು)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("ಮಾನಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಿದೆ (10 ಅಂಕಿಗಳು)");
44      
45      // ಅಮಾನ್ಯ ದಿನಾಂಕವನ್ನು ಪರಿಶೀಲಿಸಿ
46      if (isNaN(date.getTime())) {
47        return "ದೋಷ: ಅಮಾನ್ಯ ಮಾನಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್";
48      }
49      
50      // Y2K38 ಸಮಸ್ಯೆಗಾಗಿ ಪರಿಶೀಲಿಸಿ (32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳಿಗೆ)
51      const maxInt32 = 2147483647; // 32-ಬಿಟ್ ಸಹಾಯಿತ ಸಂಖ್ಯೆಯ ಗರಿಷ್ಠ ಮೌಲ್ಯ
52      if (seconds > maxInt32) {
53        console.warn("ಎಚ್ಚರಿಕೆ: ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 32-ಬಿಟ್ ಸಂಖ್ಯೆಯ ಮಿತಿ ಮೀರಿಸುತ್ತದೆ (Y2K38 ಸಮಸ್ಯೆ)");
54      }
55    } else {
56      return "ದೋಷ: ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಉದ್ದ. 10, 13, ಅಥವಾ 16 ಅಂಕಿಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.";
57    }
58    
59    // ದಿನಾಂಕವನ್ನು ರೂಪಿಸಿ
60    const options = {
61      year: 'numeric',
62      month: 'long',
63      day: 'numeric',
64      weekday: 'long',
65      hour: use12Hour ? 'numeric' : '2-digit',
66      minute: '2-digit',
67      second: '2-digit',
68      hour12: use12Hour
69    };
70    
71    return date.toLocaleString(undefined, options);
72  } catch (error) {
73    return "ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಿಸುವಾಗ ದೋಷ: " + error.message;
74  }
75}
76
77// ವಿವಿಧ ಎಜ್ ಕೇಸ್‌ಗಳೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಿ
78console.log(safeConvertTimestamp("1609459200"));      // ಮಾನಕ (10 ಅಂಕಿಗಳು)
79console.log(safeConvertTimestamp("1609459200000"));   // ಮಿಲಿಸೆಕೆಂಡು (13 ಅಂಕಿಗಳು)
80console.log(safeConvertTimestamp("1609459200000000")); // ಮೈಕ್ರೋಸೆಕೆಂಡು (16 ಅಂಕಿಗಳು)
81console.log(safeConvertTimestamp("abc123"));          // ಅಂಕಿಯಲ್ಲದ
82console.log(safeConvertTimestamp("12345"));           // ಅಮಾನ್ಯ ಉದ್ದ
83console.log(safeConvertTimestamp("9999999999999999")); // ಬಹಳ ದೊಡ್ಡ ಮೈಕ್ರೋಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್
84console.log(safeConvertTimestamp(""));                // ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್
85

ಸಾಮಾನ್ಯವಾಗಿ ಕೇಳುವ ಪ್ರಶ್ನೆಗಳು

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಏನು?

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 1970 ಜನವರಿ 1 ರಿಂದ (ಮಧ್ಯಾಹ್ನ UTC/GMT) ಲೀಪ್ ಸೆಕೆಂಡುಗಳನ್ನು ಪರಿಗಣಿಸದೆ ಕಳೆದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ. ಇದು ನಿರ್ದಿಷ್ಟ ಕ್ಷಣವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಸಂಕೀರ್ಣ, ಭಾಷಾ-ಸ್ವಾತಂತ್ರ್ಯವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಸ್ವಯಂಚಾಲಿತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪ ಗುರುತಿಸುವಿಕೆ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ?

ಪರಿವರ್ತಕವು ಅಂಕಿಗಳ ಸಂಖ್ಯೆಯ ಆಧಾರದಲ್ಲಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ರೂಪವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಗುರುತಿಸುತ್ತದೆ:

• 10 ಅಂಕಿಗಳು: ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (ಎಪೋಕ್‌ನಿಂದ ಸೆಕೆಂಡುಗಳು)
• 13 ಅಂಕಿಗಳು: ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್
• 16 ಅಂಕಿಗಳು: ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್

ನನಗೆ ಮಿಲಿಸೆಕೆಂಡು ಅಥವಾ ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ ಏಕೆ ಬೇಕಾಗಿದೆ?

ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ (13 ಅಂಕಿಗಳು) ಹೆಚ್ಚು ನಿಖರವಾದ ಸಮಯವನ್ನು ಅಗತ್ಯವಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ ಕಾರ್ಯಕ್ಷಮತೆ ಪತ್ತೆಹಚ್ಚುವುದು, ಬಳಕೆದಾರ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು ಮತ್ತು ಕೆಲವು ಹಣಕಾಸು ಅಪ್ಲಿಕೇಶನ್‌ಗಳು. ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆ (16 ಅಂಕಿಗಳು) ಉನ್ನತ ಕಾರ್ಯಕ್ಷಮತೆ ಕಂಪ್ಯೂಟಿಂಗ್, ವೈಜ್ಞಾನಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಉನ್ನತ-ಆವೃತ್ತಿಯ ವ್ಯಾಪಾರ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಅಗತ್ಯವಿದೆ.

ನಾನು ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು 1970 ಕ್ಕಿಂತ ಮುಂಚಿನ ದಿನಾಂಕಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ಬಳಸಬಹುದೇ?

ಹೌದು, 1970 ಜನವರಿ 1 ಕ್ಕೆ ಮುಂಚಿನ ದಿನಾಂಕಗಳನ್ನು ಊರ್ಬ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳ ಮೂಲಕ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ. ಆದರೆ, ಕೆಲವು ವ್ಯವಸ್ಥೆಗಳು ಊರ್ಬ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ಐತಿಹಾಸಿಕ ದಿನಾಂಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಈ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರೀಕ್ಷಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ.

2038 ಸಮಸ್ಯೆ ಏನು?

2038 ಸಮಸ್ಯೆ ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಅನೇಕ ವ್ಯವಸ್ಥೆಗಳು ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು 32-ಬಿಟ್ ಸಹಾಯಿತ ಸಂಖ್ಯೆಗಳ ರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತವೆ, ಇದು 2038 ಜನವರಿಯ 19 ರಂದು ಓವರ್ಫ್ಲೋ ಆಗುತ್ತದೆ. ಈ ಬಿಂದು ನಂತರ, 32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳು ಸರಿಯಾಗಿ ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅಸಮರ್ಥವಾಗುತ್ತವೆ. ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳು ಹೆಚ್ಚಾಗಿ 64-ಬಿಟ್ ಸಂಖ್ಯೆಗಳ ಬಳಸುತ್ತವೆ, ಈ ಸಮಸ್ಯೆಯನ್ನು ತಪ್ಪಿಸಲು.

ನಾನು ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಟೈಮ್‌ಜೋನ್ ಪರಿವರ್ತನೆಗಳಿಗೆ ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತೇನೆ?

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

ಯುನಿಕ್ಸ್ ಸಮಯ ಮತ್ತು ಐಎಸ್‌ಒ 8601 ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು?

ಯುನಿಕ್ಸ್ ಸಮಯವು ಸಂಖ್ಯಾತ್ಮಕ ಪ್ರತಿನಿಧಿ (ಎಪೋಕ್‌ನಿಂದ ಸೆಕೆಂಡುಗಳು), ಆದರೆ ಐಎಸ್‌ಒ 8601 ಒಂದು ಸ್ಟ್ರಿಂಗ್ ರೂಪ (ಉದಾಹರಣೆ: "2021-01-01T00:00:00Z"). ಯುನಿಕ್ಸ್ ಸಮಯವು ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಮತ್ತು ಸುಲಭವಾಗಿದೆ, ಆದರೆ ಐಎಸ್‌ಒ 8601 ಹೆಚ್ಚು ಮಾನವ ಓದಲು ಸುಲಭ ಮತ್ತು ಸ್ವಾಯತ್ತವಾಗಿದೆ.

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಎಷ್ಟು ನಿಖರವಾಗಿವೆ?

ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಸೆಕೆಂಡು-ಮಟ್ಟದ ಶುದ್ಧತೆಗೆ ಹೊಂದಿವೆ. ಹೆಚ್ಚು ಶುದ್ಧತೆಯನ್ನು ಅಗತ್ಯವಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಮಿಲಿಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (13 ಅಂಕಿಗಳು) 1/1000 ಸೆಕೆಂಡು ಶುದ್ಧತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ, ಮತ್ತು ಮೈಕ್ರೋಸೆಕೆಂಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು (16 ಅಂಕಿಗಳು) 1/1,000,000 ಸೆಕೆಂಡು ಶುದ್ಧತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ.

ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು ಲೀಪ್ ಸೆಕೆಂಡುಗಳನ್ನು ಪರಿಗಣಿಸುತ್ತವೆ?

ಇಲ್ಲ, ಯುನಿಕ್ಸ್ ಸಮಯವು ಲೀಪ್ ಸೆಕೆಂಡುಗಳನ್ನು ಪರಿಗಣಿಸುವುದಿಲ್ಲ, ಇದು UTC ಗೆ ಸಮಾನಾಂತರವಾಗಿ ಭೂಮಿ ಅಸಮಾನವಾದ ತಿರುಗುವಿಕೆಯನ್ನು ಪರಿಹರಿಸಲು ಸಮಯದಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಇದು ಯುನಿಕ್ಸ್ ಸಮಯವು ಜ್ಯೋತಿಷ್ಯ ಸಮಯದೊಂದಿಗೆ ನಿಖರವಾಗಿ ಸಮನ್ವಯಿತವಾಗಿಲ್ಲ ಎಂದು ಅರ್ಥವಾಗುತ್ತದೆ.

ನಾನು ಭವಿಷ್ಯದ ಘಟನೆಗಳನ್ನು ಯೋಜಿಸಲು ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಬಳಸಬಹುದೇ?

ಹೌದು, ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಯೋಜನೆಗೆ ಬಳಸಬಹುದು. ಆದರೆ, ಬಹಳ ದೂರದ ಭವಿಷ್ಯದ ದಿನಾಂಕಗಳಿಗೆ, 32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳಿಗಾಗಿ 2038 ಸಮಸ್ಯೆ ಮತ್ತು ಟೈಮ್‌ಜೋನ್ ಬದಲಾವಣೆಗಳು ಮತ್ತು ಡೇಲೈಟ್ ಸೆವಿಂಗ್ ಟೈಮ್ ಪರಿವರ್ತನೆಗಳ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ಉಲ್ಲೇಖಗಳು

1. "ಯುನಿಕ್ಸ್ ಟೈಮ್." ವಿಕಿಪೀಡಿಯಾ, ವಿಕಿಮೀಡಿಯಾ ಫೌಂಡೇಶನ್, https://en.wikipedia.org/wiki/Unix_time

2. "2038 ಸಮಸ್ಯೆ." ವಿಕಿಪೀಡಿಯಾ, ವಿಕಿಮೀಡಿಯಾ ಫೌಂಡೇಶನ್, https://en.wikipedia.org/wiki/Year_2038_problem

3. ಓಲ್ಸನ್, ಆರ್ಥರ್ ಡೇವಿಡ್. "ಕಾಲದ ಸಂಕೀರ್ಣತೆ." ಓಪನ್ ಗ್ರೂಪ್, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ಐಎಸ್‌ಒ 8601." ವಿಕಿಪೀಡಿಯಾ, ವಿಕಿಮೀಡಿಯಾ ಫೌಂಡೇಶನ್, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: ಇಂಟರ್‌ನೆಟ್‌ನಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯ: ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು." ಇಂಟರ್‌ನೆಟ್ ಎಂಜಿನಿಯರಿಂಗ್ ಟಾಸ್ಕ್ ಫೋರ್ಸ್ (IETF), https://tools.ietf.org/html/rfc3339

6. ಕೆರ್ಣಿಗನ್, ಬ್ರಿಯನ್ ಡಬ್ಲ್ಯೂ., ಮತ್ತು ಡೆನ್ನಿಸ್ ಎಮ್. ರಿಚಿ. "ಸಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ." ಪ್ರೆಂಟಿಸ್ ಹಾಲ್, 1988.

7. "ಉನ್ನತ ಕಾರ್ಯಕ್ಷಮತೆ ಕಂಪ್ಯೂಟಿಂಗ್‌ನಲ್ಲಿ ಶುದ್ಧತೆಯ ಸಮಯ." ACM ಕಂಪ್ಯೂಟಿಂಗ್ ಸಮೀಕ್ಷೆಗಳು, https://dl.acm.org/doi/10.1145/3232678

8. "ಹಣಕಾಸು ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಕಾಲದ ಪ್ರತಿನಿಧಿ." ಹಣಕಾಸು ತಂತ್ರಜ್ಞಾನ ಜರ್ನಲ್, https://www.fintech-journal.com/time-representation

ಈಗ ನಮ್ಮ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕವನ್ನು ಪ್ರಯತ್ನಿಸಿ, ಯಾವುದೇ ಶುದ್ಧತೆಯ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ಮಾನವ ಓದಲು ಸುಲಭವಾದ ದಿನಾಂಕಗಳಿಗೆ ಸುಲಭವಾಗಿ ಪರಿವರ್ತಿಸಲು. ನೀವು ಮಾನಕ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳು, ಮಿಲಿಸೆಕೆಂಡು ಶುದ್ಧತೆ, ಅಥವಾ ಮೈಕ್ರೋಸೆಕೆಂಡು ಶುದ್ಧತೆಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದರೂ, ನಮ್ಮ ಸಾಧನವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರೂಪವನ್ನು ಗುರುತಿಸುತ್ತದೆ ಮತ್ತು ನಿಖರವಾದ ಪರಿವರ್ತನೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.