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

ಪರಿಚಯ

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

ಈ ಪರಿವರ್ತಕವು ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ನನ್ನು ಮಾನವ-ಓದಲು ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ರೂಪದಲ್ಲಿ ಪರಿವರ್ತಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು 12-ಗಂಟೆ (ಎಎಂ/ಪಿಎಂ) ಮತ್ತು 24-ಗಂಟೆ ಸಮಯದ ರೂಪಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ವಿಭಿನ್ನ ಪ್ರಾದೇಶಿಕ ಮತ್ತು ವೈಯಕ್ತಿಕ ಆದ್ಯತೆಗಳನ್ನು ಪೂರೈಸಲು.

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

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

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

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

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

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

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

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

ಸಮಯದ ರೂಪ ಆಯ್ಕೆಗಳು

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

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ರ ಸಮಸ್ಯೆ: ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ 32-ಬಿಟ್ ಸಹಿ ಪೂರ್ಣಾಂಕಗಳಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಇದು 2038ರ ಜನವರಿ 19 ರಂದು ಓವರ್ಫ್ಲೋ ಆಗುತ್ತದೆ. ಈ ಸಮಯದ ನಂತರ, 32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳು ಸರಿಯಾಗಿ ಸಮಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

3. ಅತಿಯಾಗಿ ದೊಡ್ಡ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ಗಳು: ಬಹಳ ದೂರದ ಭವಿಷ್ಯದ ದಿನಾಂಕಗಳನ್ನು ಕೆಲವು ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಪ್ರತಿನಿಧಿಸಲಾಗುವುದಿಲ್ಲ, ಅಥವಾ ಅಸಮಾನವಾಗಿ ನಿರ್ವಹಿಸಲಾಗಬಹುದು.

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

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

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

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

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

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

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

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

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

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

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

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

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

ಪರ್ಯಾಯಗಳು

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

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-01-01 ರಿಂದ 2038-01-19 (03:14:07 UTC) ವರೆಗೆ ಮಾತ್ರ ದಿನಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

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

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

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

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

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

1// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3  // ಹೊಸ ದಿನಾಂಕ ವಸ್ತುವನ್ನು ರಚಿಸಿ (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ಬಳಸುತ್ತದೆ)
4  const date = new Date(timestamp * 1000);
5  
6  // ರೂಪಾಂತರ ಆಯ್ಕೆಗಳು
7  const options = {
8    year: 'numeric',
9    month: 'long',
10    day: 'numeric',
11    weekday: 'long',
12    hour: use12Hour ? 'numeric' : '2-digit',
13    minute: '2-digit',
14    second: '2-digit',
15    hour12: use12Hour
16  };
17  
18  // ಸ್ಥಳೀಯ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಿ
19  return date.toLocaleString(undefined, options);
20}
21
22// ಉದಾಹರಣೆಯ ಬಳಕೆ
23const timestamp = 1609459200; // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
24console.log(convertUnixTimestamp(timestamp, false)); // 24-ಗಂಟೆ ರೂಪ
25console.log(convertUnixTimestamp(timestamp, true));  // 12-ಗಂಟೆ ರೂಪ
26

1# ಪೈಥಾನ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5    # ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ದಿನಾಂಕ ವಸ್ತುವಾಗಿಗೆ ಪರಿವರ್ತಿಸಿ
6    date = datetime.datetime.fromtimestamp(timestamp)
7    
8    # ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರೂಪಿಸಲು
9    if use_12hour:
10        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
11    else:
12        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-ಗಂಟೆ ರೂಪ
13    
14    return date.strftime(format_string)
15
16# ಉದಾಹರಣೆಯ ಬಳಕೆ
17timestamp = 1609459200  # 2021ರ ಜನವರಿ 1, 00:00:00 UTC
18print(convert_unix_timestamp(timestamp, False))  # 24-ಗಂಟೆ ರೂಪ
19print(convert_unix_timestamp(timestamp, True))   # 12-ಗಂಟೆ ರೂಪ
20

1<?php
2// PHP ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4    // ರೂಪಾಂತರ ಸ್ಟ್ರಿಂಗ್
5    $formatString = $use12Hour 
6        ? 'l, F j, Y g:i:s A'  // 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
7        : 'l, F j, Y H:i:s';   // 24-ಗಂಟೆ ರೂಪ
8    
9    // ದಿನಾಂಕವನ್ನು ಪರಿವರ್ತಿಸಿ ಮತ್ತು ರೂಪಿಸಿ
10    return date($formatString, $timestamp);
11}
12
13// ಉದಾಹರಣೆಯ ಬಳಕೆ
14$timestamp = 1609459200; // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-ಗಂಟೆ ರೂಪ
16echo convertUnixTimestamp($timestamp, true) . "\n";  // 12-ಗಂಟೆ ರೂಪ
17?>
18

1// ಜಾವಾ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class UnixTimestampConverter {
8    public static String convertUnixTimestamp(long timestamp, boolean use12Hour) {
9        // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಇನ್ಸ್ಟಂಟ್‌ಗೆ ಪರಿವರ್ತಿಸಿ, ನಂತರ ಸ್ಥಳೀಯ ದಿನಾಂಕಕ್ಕೆ
10        Instant instant = Instant.ofEpochSecond(timestamp);
11        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12        
13        // ಅಗತ್ಯವಿರುವ ರೂಪವನ್ನು ಆಧರಿಸಿ ರೂಪಾಂತರಕವನ್ನು ರಚಿಸಿ
14        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
15            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
16        );
17        
18        // ದಿನಾಂಕವನ್ನು ರೂಪಿಸಿ
19        return dateTime.format(formatter);
20    }
21    
22    public static void main(String[] args) {
23        long timestamp = 1609459200; // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
24        System.out.println(convertUnixTimestamp(timestamp, false)); // 24-ಗಂಟೆ ರೂಪ
25        System.out.println(convertUnixTimestamp(timestamp, true));  // 12-ಗಂಟೆ ರೂಪ
26    }
27}
28

1// C# ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2using System;
3
4class UnixTimestampConverter
5{
6    public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7    {
8        // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ದಿನಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
9        // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 1970-01-01 ರಿಂದ ದಿನಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ
10        DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11        
12        // 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಾಂತರ ಸ್ಟ್ರಿಂಗ್
13        string formatString = use12Hour 
14            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
15            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-ಗಂಟೆ ರೂಪ
16        
17        // ರೂಪಾಂತರಿತ ದಿನಾಂಕವನ್ನು ಹಿಂತಿರುಗಿಸಿ
18        return dateTime.ToString(formatString);
19    }
20    
21    static void Main()
22    {
23        long timestamp = 1609459200; // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
24        Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-ಗಂಟೆ ರೂಪ
25        Console.WriteLine(ConvertUnixTimestamp(timestamp, true));  // 12-ಗಂಟೆ ರೂಪ
26    }
27}
28

1# ರೂಬಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5  # ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಟೈಮ್ ವಸ್ತುವಾಗಿಗೆ ಪರಿವರ್ತಿಸಿ
6  time = Time.at(timestamp)
7  
8  # 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಿಸಿ
9  if use_12hour
10    time.strftime("%A, %B %d, %Y %I:%M:%S %p")  # 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
11  else
12    time.strftime("%A, %B %d, %Y %H:%M:%S")     # 24-ಗಂಟೆ ರೂಪ
13  end
14end
15
16# ಉದಾಹರಣೆಯ ಬಳಕೆ
17timestamp = 1609459200  # 2021ರ ಜನವರಿ 1, 00:00:00 UTC
18puts convert_unix_timestamp(timestamp, false)  # 24-ಗಂಟೆ ರೂಪ
19puts convert_unix_timestamp(timestamp, true)   # 12-ಗಂಟೆ ರೂಪ
20

1// ಗೋ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2package main
3
4import (
5    "fmt"
6    "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10    // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಟೈಮ್ ಗೆ ಪರಿವರ್ತಿಸಿ
11    t := time.Unix(timestamp, 0)
12    
13    // 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಾಂತರ ಸ್ಟ್ರಿಂಗ್
14    formatString := "Monday, January 2, 2006 "
15    if use12Hour {
16        formatString += "3:04:05 PM"  // 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
17    } else {
18        formatString += "15:04:05"    // 24-ಗಂಟೆ ರೂಪ
19    }
20    
21    // ರೂಪಿತ ಸಮಯವನ್ನು ಹಿಂತಿರುಗಿಸಿ
22    return t.Format(formatString)
23}
24
25func main() {
26    timestamp := int64(1609459200) // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
27    fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-ಗಂಟೆ ರೂಪ
28    fmt.Println(convertUnixTimestamp(timestamp, true))  // 12-ಗಂಟೆ ರೂಪ
29}
30

1// ಸ್ವಿಫ್ಟ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5    // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ದಿನಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
6    let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7    
8    // ದಿನಾಂಕ ರೂಪಾಂತರಕವನ್ನು ರಚಿಸಿ
9    let formatter = DateFormatter()
10    formatter.dateStyle = .full
11    
12    // 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ಸಮಯ ಶೈಲಿಯನ್ನು ಹೊಂದಿಸಿ
13    if use12Hour {
14        formatter.timeStyle = .medium
15        formatter.amSymbol = "AM"
16        formatter.pmSymbol = "PM"
17    } else {
18        formatter.timeStyle = .medium
19        formatter.dateFormat = formatter.dateFormat?.replacingOccurrences(of: "h:mm:ss a", with: "HH:mm:ss")
20    }
21    
22    // ರೂಪಿತ ದಿನಾಂಕವನ್ನು ಹಿಂತಿರುಗಿಸಿ
23    return formatter.string(from: date)
24}
25
26// ಉದಾಹರಣೆಯ ಬಳಕೆ
27let timestamp = 1609459200 // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-ಗಂಟೆ ರೂಪ
29print(convertUnixTimestamp(timestamp, use12Hour: true))  // 12-ಗಂಟೆ ರೂಪ
30

1# ಆರ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3  # ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು POSIXct ದಿನಾಂಕ/ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
4  date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5  
6  # 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಿಸಿ
7  if (use_12hour) {
8    format_string <- "%A, %B %d, %Y %I:%M:%S %p"  # 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
9  } else {
10    format_string <- "%A, %B %d, %Y %H:%M:%S"     # 24-ಗಂಟೆ ರೂಪ
11  }
12  
13  # ರೂಪಿತ ದಿನಾಂಕವನ್ನು ಹಿಂತಿರುಗಿಸಿ
14  format(date_time, format_string)
15}
16
17# ಉದಾಹರಣೆಯ ಬಳಕೆ
18timestamp <- 1609459200  # 2021ರ ಜನವರಿ 1, 00:00:00 UTC
19cat(convert_unix_timestamp(timestamp, FALSE), "\n")  # 24-ಗಂಟೆ ರೂಪ
20cat(convert_unix_timestamp(timestamp, TRUE), "\n")   # 12-ಗಂಟೆ ರೂಪ
21

1% MATLAB ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3    % ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು MATLAB ದಿನಾಂಕ/ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
4    % MATLAB ದಿನಾಂಕಗಳು 1900-01-01 ರಿಂದ ದಿನಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ, 1 = 1900-01-01
5    % ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 1970-01-01 ರಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ
6    
7    % ಮೊದಲು Excel ದಿನಾಂಕ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
8    % 25569 1900-01-01 ಮತ್ತು 1970-01-01 ನಡುವಿನ ದಿನಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ
9    Dim excelDate As Double
10    excelDate = (timestamp / 86400) + 25569;
11    
12    % 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಾಂತರ ಸ್ಟ್ರಿಂಗ್
13    If use12Hour Then
14        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy h:mm:ss AM/PM');
15    Else
16        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy hh:mm:ss');
17    End If
18end
19
20% ಕಾರ್ಯಕ್ಷೇತ್ರದಲ್ಲಿ ಬಳಕೆ:
21% =ConvertUnixTimestamp(1609459200, TRUE)  ' 12-ಗಂಟೆ ರೂಪ
22% =ConvertUnixTimestamp(1609459200, FALSE) ' 24-ಗಂಟೆ ರೂಪ
23

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

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

1// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಡ್ಜ್ ಕೇಸ್ ನಿರ್ವಹಣೆ
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಮಾನ್ಯವಾದುದೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
4  if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5    return "ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್";
6  }
7  
8  // ನಕಾರಾತ್ಮಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ (1970ರ ಮುಂಚಿನ ದಿನಾಂಕಗಳು)
9  if (timestamp < 0) {
10    // ಕೆಲವು ಬ್ರೌಸರ್‌ಗಳು ನಕಾರಾತ್ಮಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ
11    // 1970ರ ಮುಂಚಿನ ದಿನಾಂಕಗಳಿಗಾಗಿ ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ವಿಧಾನವನ್ನು ಬಳಸಿರಿ
12    const date = new Date(timestamp * 1000);
13    if (isNaN(date.getTime())) {
14      return "ಅಮಾನ್ಯ ದಿನಾಂಕ (1970ರ ಮುಂಚೆ)";
15    }
16  }
17  
18  // Y2K38 ಸಮಸ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ (32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳಿಗಾಗಿ)
19  const maxInt32 = 2147483647; // 32-ಬಿಟ್ ಸಹಿ ಸಂಪೂರ್ಣ ಸಂಖ್ಯೆಯ ಗರಿಷ್ಠ ಮೌಲ್ಯ
20  if (timestamp > maxInt32) {
21    // ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬಹಳ ದೊಡ್ಡ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ಗಳಿಗಾಗಿ BigInt ಅನ್ನು ಬಳಸಲು ಪರಿಗಣಿಸಿ
22    console.warn("ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 32-ಬಿಟ್ ಪೂರ್ಣಾಂಕ ಮಿತಿಯನ್ನು ಮೀರಿಸುತ್ತದೆ (Y2K38 ಸಮಸ್ಯೆ)");
23  }
24  
25  // ಸಾಮಾನ್ಯ ಪರಿವರ್ತನೆಯೊಂದಿಗೆ ಮುಂದುವರಿಯಿರಿ
26  try {
27    const date = new Date(timestamp * 1000);
28    const options = {
29      year: 'numeric',
30      month: 'long',
31      day: 'numeric',
32      weekday: 'long',
33      hour: use12Hour ? 'numeric' : '2-digit',
34      minute: '2-digit',
35      second: '2-digit',
36      hour12: use12Hour
37    };
38    return date.toLocaleString(undefined, options);
39  } catch (error) {
40    return "ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಿಸುವಾಗ ದೋಷ: " + error.message;
41  }
42}
43

ಉಲ್ಲೇಖಗಳು

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.