Unix Timestamp ಸೆಕೆಂಡು vs ಮಿಲಿಸೆಕೆಂಡು: ದಿನಾಂಕ ಏಕೆ 1970 ತೋರಿಸುತ್ತದೆ

timestamp ಅನ್ನು ದಿನಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಿ ಜನವರಿ 1970ಕ್ಕೆ ಬಂದಿರಿ. ಗಡಿಯಾರ ವಿರಳವಾಗಿ ಹಾಳಾಗುತ್ತದೆ. ಸಂಖ್ಯೆ ಸೆಕೆಂಡಾಗಿ ಇಟ್ಟಿದ್ದಾಗ ಮಿಲಿಸೆಕೆಂಡಾಗಿ ಓದಿದರು—ಅಥವಾ ತಿರುಗುಮುರುಗು.

Unix timestamp ಎಂದರೇನು?

Unix timestamp ಸಮಯವನ್ನು Unix epochಿನಿಂದ ಅಳೆಯುತ್ತದೆ: 1970-01-01 00:00:00 UTC. ಸಾಮಾನ್ಯವಾಗಿ ಪೂರ್ಣ ಸೆಕೆಂಡು. ಅದೇ ಕ್ಷಣವನ್ನು ಮಿಲಿಸೆಕೆಂಡಾಗಿಯೂ ಇಡಬಹುದು (ಸೆಕೆಂಡು × 1,000). ಸಂಖ್ಯೆಯೇ ಘಟಕ ಹೇಳುವುದಿಲ್ಲ.

ಸೆಕೆಂಡು vs ಮಿಲಿಸೆಕೆಂಡು: 1,000 ಪಟ್ಟು ವ್ಯತ್ಯಾಸ

ಒಂದು ಸೆಕೆಂಡು 1,000 ಮಿಲಿಸೆಕೆಂಡು. 1720000000ನ್ನು 1720000000000 ಜೊತೆ ಹೋಲಿಸಿ. ಮೊದಲನೆಯದು ಸೆಕೆಂಡು, ಎರಡನೆಯದು ಮಿಲಿಸೆಕೆಂಡು ಆದರೆ ಅದೇ ಕ್ಷಣ. ಮೊದಲನೆಯದನ್ನು ಮಿಲಿಸೆಕೆಂಡಾಗಿ ಓದಿದರೆ ದಿನಾಂಕ 1970 ಕಡೆ ಜಿಗಿಯುತ್ತದೆ.

ಈ UTC ಫಲಿತಾಂಶಗಳು ಮೇಲಿನ ಸಂಖ್ಯೆಗಳಿಂದ ಲೆಕ್ಕಿಸಿದವು, ಊಹೆ ಅಲ್ಲ.

ಮೌಲ್ಯ	ಸಂಭಾವ್ಯ ಘಟಕ	ವ್ಯಾಖ್ಯಾನ (UTC)
1720000000	ಸೆಕೆಂಡು	ಸೆಕೆಂಡಾಗಿ ಓದಿದರೆ ಆಧುನಿಕ ದಿನಾಂಕ: 2024-07-03 09:46:40 UTC
1720000000000	ಮಿಲಿಸೆಕೆಂಡು	ಮಿಲಿಸೆಕೆಂಡಾಗಿ ಓದಿದರೆ ಅದೇ ಕ್ಷಣ: 2024-07-03 09:46:40 UTC
1720000000 ಮಿಲಿಸೆಕೆಂಡಾಗಿ	ತಪ್ಪು ಘಟಕ	1970 ಹತ್ತಿರದ ದಿನಾಂಕ: 1970-01-20 21:46:40 UTC

ನನ್ನ timestamp ಏಕೆ 1970 ತೋರಿಸುತ್ತದೆ?

ಸೆಕೆಂಡು ಮೌಲ್ಯವನ್ನು ಮಿಲಿಸೆಕೆಂಡಾಗಿ ತೆಗೆದುಕೊಂಡರೆ ಸಂಖ್ಯೆ ಬೇಕಾದುದಕ್ಕಿಂತ 1,000 ಪಟ್ಟು ಚಿಕ್ಕದು. JavaScript ಆಗ Unix epoch ನಂತರ ಸಣ್ಣ ಅವಧಿಯನ್ನು ಮಾತ್ರ ಎಣಿಸುತ್ತದೆ, ದಿನಾಂಕ 1970ರಲ್ಲೇ ಉಳಿಯುತ್ತದೆ:

const seconds = 1720000000;

new Date(seconds);
// 1970-01-20 21:46:40 UTC

new Date(seconds * 1000);
// 2024-07-03 09:46:40 UTC

ಆ 1970 ದಿನಾಂಕ epoch ಜೊತೆ ಸುಮಾರು ಎರಡು ವಾರ. Dateಗೆ ಕೊಡುವ ಮೊದಲು ಸೆಕೆಂಡನ್ನು 1,000ರಿಂದ ಗುಣಿಸಿ.

• ಸೆಕೆಂಡು
• 1720000000
• × 1000
• ↓
• ಮಿಲಿಸೆಕೆಂಡು
• 1720000000000

• ಸೆಕೆಂಡು ಮೌಲ್ಯ
• ↓
• ತಪ್ಪಾಗಿ ಮಿಲಿಸೆಕೆಂಡಾಗಿ ತೆಗೆದುಕೊಂಡರು
• ↓
• 1970 ಹತ್ತಿರದ ದಿನಾಂಕ

10 ಅಂಕಿ ಸೆಕೆಂಡೋ, 13 ಮಿಲಿಸೆಕೆಂಡೋ?

ಆಧುನಿಕ ದಿನಾಂಕಗಳಿಗೆ 10 ಅಂಕಿ ಹೆಚ್ಚಾಗಿ ಸೆಕೆಂಡು, 13 ಹೆಚ್ಚಾಗಿ ಮಿಲಿಸೆಕೆಂಡು. ಇದು ತ್ವರಿತ ಸುಳಿವು, ಪರಿಶೀಲನಾ ನಿಯಮವಲ್ಲ. ಅಂಕಿಗಳ ಸಂಖ್ಯೆ ಕಾಲಾವಧಿಯೊಂದಿಗೆ ಬದಲಾಗುತ್ತದೆ; ಕೆಲವು API ಮೈಕ್ರೋಸೆಕೆಂಡು ಅಥವಾ ನ್ಯಾನೋಸೆಕೆಂಡು ಇಡುತ್ತವೆ. ಘಟಕವನ್ನು ದಾಖಲೆ ಅಥವಾ ಅರ್ಥಪೂರ್ಣ ದಿನಾಂಕದಿಂದ ದೃಢಪಡಿಸಿ.

ಇದು JavaScriptನಲ್ಲಿ ಏಕೆ ಇಷ್ಟು ಬಾರಿ ಆಗುತ್ತದೆ

JavaScriptನಲ್ಲಿ ಸಂಖ್ಯಾ Date epochಿನಿಂದ ಮಿಲಿಸೆಕೆಂಡು. ಹಲವು ಬ್ಯಾಕೆಂಡ್, ಡೇಟಾಬೇಸ್, Unix ಸಾಧನಗಳು ಇನ್ನೂ ಸೆಕೆಂಡು ಇಡುತ್ತವೆ. ಸೆಕೆಂಡನ್ನು ನೇರ Dateಗೆ ಕೊಡುವುದು ಸಾಮಾನ್ಯ ತಪ್ಪು:

const unixSeconds = 1720000000;

const wrong = new Date(unixSeconds);
const correct = new Date(unixSeconds * 1000);

wrong 1970 ಹತ್ತಿರ (1970-01-20 21:46:40 UTC). correct ಆಧುನಿಕ ಕ್ಷಣ (2024-07-03 09:46:40 UTC).

ಇತರ ವ್ಯವಸ್ಥೆಗಳು ಬೇರೆ ಘಟಕ ಬಳಸುತ್ತವೆ

ಇತರ ಭಾಷೆಗಳು, API, ಡೇಟಾಬೇಸ್‌ಗಳು ಸೆಕೆಂಡು ಅಥವಾ ಮಿಲಿಸೆಕೆಂಡು ಬಳಸಬಹುದು. ಕೆಲವು ಮೈಕ್ರೋಸೆಕೆಂಡು ಅಥವಾ ನ್ಯಾನೋಸೆಕೆಂಡು ಇಡುತ್ತವೆ. ಒಂದು ಭಾಷೆ ಯಾವಾಗಲೂ ಒಂದೇ ಘಟಕ ಬಳಸುತ್ತದೆ ಎಂದು ಭಾವಿಸಬೇಡಿ—ದಾಖಲೆ ನೋಡಿ. ಸಂಖ್ಯೆ JSONನಲ್ಲಿದ್ದರೆ JSON ಸರಿಪಡಿಸಿ / Diff ಕ್ಷೇತ್ರ ಓದಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ; ಘಟಕ ಹೇಳುವುದಿಲ್ಲ.

ನನ್ನ timestamp ಯಾವ ಘಟಕ ಎಂದು ಹೇಗೆ ತಿಳಿಯುವುದು?

ಈ ಪರಿಶೀಲನೆಗಳನ್ನು ಕ್ರಮದಲ್ಲಿ ಮಾಡಿ. ಅಂಕಿಗಳ ಸಂಖ್ಯೆ ಮಾತ್ರ ಸಾಲದು.

1. API ಅಥವಾ ಡೇಟಾಬೇಸ್ ದಾಖಲೆ ನೋಡಿ.
2. ಸುಮಾರು ಅಂಕಿಗಳ ಸಂಖ್ಯೆ ನೋಡಿ.
3. ಮೌಲ್ಯವನ್ನು ನಂಬಬಹುದಾದ ಆಧುನಿಕ timestamp ಜೊತೆ ಹೋಲಿಸಿ.
4. ಮೌಲ್ಯವನ್ನು ಸೆಕೆಂಡಾಗಿ ಮತ್ತು ಮಿಲಿಸೆಕೆಂಡಾಗಿ ಪರೀಕ್ಷಿಸಿ.
5. ಬಂದ ದಿನಾಂಕ ಅರ್ಥಪೂರ್ಣವೇ ನೋಡಿ.

ಒಂದು ವ್ಯಾಖ್ಯಾನ 1970ಕ್ಕೆ ಬಿದ್ದು ಇನ್ನೊಂದು ನಿಮಗೆ ತಿಳಿದ ದಿನಾಂಕಕ್ಕೆ ಬಿದ್ದರೆ, ಕಾರಣ ಘಟಕ ಹೊಂದಿಕೆಯಾಗದಿರುವುದು.

Unix timestamp ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• ಸೆಕೆಂಡನ್ನು ಮಿಲಿಸೆಕೆಂಡಾಗಿ ಅರ್ಥೈಸುವುದು. ದಿನಾಂಕ 1970 ಕಡೆ ಕುಸಿಯುತ್ತದೆ, ಮೇಲಿನ ಉದಾಹರಣೆಯಂತೆ.
• ಮಿಲಿಸೆಕೆಂಡನ್ನು ಸೆಕೆಂಡಾಗಿ ಅರ್ಥೈಸುವುದು. ದಿನಾಂಕ ದೂರದ ಭವಿಷ್ಯಕ್ಕೆ ಜಿಗಿಯುತ್ತದೆ, ಅಥವಾ ಪರಿವರ್ತನೆ ವಿಫಲವಾಗುತ್ತದೆ.
• 1,000ರಿಂದ ಎರಡು ಬಾರಿ ಗುಣಿಸುವುದು. ಈಗಾಗಲೇ ಮಿಲಿಸೆಕೆಂಡಾಗಿದ್ದ ಮೌಲ್ಯ ದೊಡ್ಡದಾಗಿ ದಿನಾಂಕ ಶತಮಾನಗಳು ಮುಂದೆ ಹೋಗುತ್ತದೆ.
• 1,000ರಿಂದ ಎರಡು ಬಾರಿ ಭಾಗಿಸುವುದು. ಸೆಕೆಂಡು ಮೌಲ್ಯ ಮತ್ತೆ ಕುಗ್ಗುತ್ತದೆ, ಮತ್ತೆ 1970 ಹತ್ತಿರ.
• ಸಮಯ ವಲಯವನ್ನು ದೂಷಿಸುವುದು. ವಲಯ ಗಂಟೆ ಅಥವಾ ಕ್ಯಾಲೆಂಡರ್ ದಿನ ಸರಿಸಬಹುದು. ಆಧುನಿಕ timestamp ಅನ್ನು 1970 ಮಾಡುವುದಿಲ್ಲ.
• ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ದಿನಾಂಕವನ್ನು Unix timestamp ಎಂದು ತೆಗೆದುಕೊಳ್ಳುವುದು. 2024-07-03T09:46:40Z ರೀತಿಯ ಮೌಲ್ಯ epoch ಸಂಖ್ಯೆಯಲ್ಲ. ಸೆಕೆಂಡಾಗಿ ಅಲ್ಲ, ದಿನಾಂಕವಾಗಿ ಪಾರ್ಸ್ ಮಾಡಿ.

ಸಮಯ ವಲಯ 1970 ಸಮಸ್ಯೆ ಉಂಟುಮಾಡುತ್ತದೆಯೇ?

ಸಾಮಾನ್ಯವಾಗಿ ಇಲ್ಲ. ಸಮಯ ವಲಯ ತೋರಿಸುವ ಗಡಿಯಾರ ಬದಲಿಸಬಹುದು, ಮಧ್ಯರಾತ್ರಿ ಹತ್ತಿರ ಕ್ಯಾಲೆಂಡರ್ ದಿನಾಂಕವನ್ನೂ. ಆಧುನಿಕ Unix timestamp ಅನ್ನು 1970 ಮಾಡುವುದಿಲ್ಲ. ಫಲಿತಾಂಶ 1970 ಆದರೆ ಮೊದಲು ಸೆಕೆಂಡು vs ಮಿಲಿಸೆಕೆಂಡು ನೋಡಿ.

Unix timestamp ಪರಿವರ್ತಿಸಿ ಪರಿಶೀಲಿಸಿ

NEXNARA ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ಪರಿವರ್ತಕ ಬ್ರೌಸರ್‌ನಲ್ಲಿ Unix timestamp ಪರಿವರ್ತಿಸಬಹುದು.

Unix ಸೆಕೆಂಡು ಅಥವಾ ಮಿಲಿಸೆಕೆಂಡು ಅಂಟಿಸಿ, ಪ್ರಸ್ತುತ timestamp ಬಳಸಿ, UTC ಮತ್ತು ಸ್ಥಳೀಯ ಸಮಯ ನೋಡಿ, ವಲಯ ಪರಿವರ್ತಿಸಿ, ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿ. ಸ್ವಯಂ ಪತ್ತೆ ಹೆಚ್ಚಾಗಿ 10 ಅಂಕಿಯನ್ನು ಸೆಕೆಂಡು, 13ನ್ನು ಮಿಲಿಸೆಕೆಂಡು ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ; ಘಟಕವನ್ನು ನೀವು ಇನ್ನೂ ಆಯ್ಕೆ ಮಾಡಬಹುದು.

ಪರಿವರ್ತನೆ ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನಡೆಯುತ್ತದೆ. ಈ ಸಾಧನ ದಿನಾಂಕಗಳು ಅಥವಾ timestamps ಅನ್ನು NEXNARA ಸರ್ವರ್‌ಗೆ ಕಳುಹಿಸುವುದಿಲ್ಲ. ಜಾಹೀರಾತುಗಳು ಮತ್ತು ಇತರ ಸೈಟ್ ವೈಶಿಷ್ಟ್ಯಗಳು ಇನ್ನೂ ನೆಟ್‌ವರ್ಕ್ ಬಳಸುತ್ತವೆ; ಅದು ಪರಿವರ್ತನೆಯಿಂದ ಬೇರೆ.

Unix timestamp ಪರಿಶೀಲಿಸಬೇಕೇ? ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ಪರಿವರ್ತಕ ತೆರೆದು ಸೆಕೆಂಡನ್ನು ಮಿಲಿಸೆಕೆಂಡಿನೊಂದಿಗೆ ಹೋಲಿಸಿ.

FAQ

ನನ್ನ Unix timestamp ಏಕೆ 1970 ತೋರಿಸುತ್ತದೆ?

ಹೆಚ್ಚಾಗಿ ಮಿಲಿಸೆಕೆಂಡಾಗಿ ಓದಿದ ಸೆಕೆಂಡು. JavaScript ಬಹಳ ಚಿಕ್ಕ ಸಂಖ್ಯೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ದಿನಾಂಕ 1970-01-01 00:00:00 UTC ನಂತರ ಕುಳಿತುಕೊಳ್ಳುತ್ತದೆ. ಸೆಕೆಂಡನ್ನು 1,000ರಿಂದ ಗುಣಿಸಿ ಮತ್ತೆ ಪರಿವರ್ತಿಸಿ.

Unix timestamps ಸೆಕೆಂಡೋ ಮಿಲಿಸೆಕೆಂಡೋ?

ಸಾಮಾನ್ಯವಾಗಿ ಸೆಕೆಂಡು. ಹಲವು ವೆಬ್ API ಮತ್ತು JavaScript Date ಮಿಲಿಸೆಕೆಂಡು ಬಳಸುತ್ತವೆ. ಆ ವ್ಯವಸ್ಥೆ ಏನು ದಾಖಲಿಸುತ್ತದೆ ಎಂದು ಯಾವಾಗಲೂ ನೋಡಿ. ಕೆಲವು ಮೈಕ್ರೋಸೆಕೆಂಡು ಅಥವಾ ನ್ಯಾನೋಸೆಕೆಂಡು ಬಳಸುತ್ತವೆ.

ಸೆಕೆಂಡನ್ನು ಮಿಲಿಸೆಕೆಂಡಾಗಿ ಹೇಗೆ ಪರಿವರ್ತಿಸುವುದು?

1,000ರಿಂದ ಗುಣಿಸಿ. 1720000000 ಸೆಕೆಂಡು 1720000000000 ಮಿಲಿಸೆಕೆಂಡು. ಎದುರು ದಿಕ್ಕಿನಲ್ಲಿ 1,000ರಿಂದ ಭಾಗಿಸಿ.

JavaScript Date ಏಕೆ ಮಿಲಿಸೆಕೆಂಡು ಬಳಸುತ್ತದೆ?

JavaScriptನಲ್ಲಿ Date ಸಂಖ್ಯಾ timestamp Unix epochಿನಿಂದ ಮಿಲಿಸೆಕೆಂಡು ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಆದ್ದರಿಂದ unixSeconds Unix ಸೆಕೆಂಡು ಆದಾಗ new Date(unixSeconds) ತಪ್ಪು.

10 ಅಂಕಿಯ timestamp ಯಾವಾಗಲೂ ಸೆಕೆಂಡೋ?

ಇಲ್ಲ. ಆಧುನಿಕ ದಿನಾಂಕಗಳಿಗೆ ಹೆಚ್ಚಾಗಿ ಸೆಕೆಂಡು, 13 ಅಂಕಿ ಹೆಚ್ಚಾಗಿ ಮಿಲಿಸೆಕೆಂಡು. ಅಂಕಿಗಳ ಸಂಖ್ಯೆ ಸುಳಿವು, ನಿಯಮವಲ್ಲ. ದಾಖಲೆ ಅಥವಾ ಅರ್ಥಪೂರ್ಣ ದಿನಾಂಕದಿಂದ ದೃಢಪಡಿಸಿ.

Unix timestampನಲ್ಲಿ ಸಮಯ ವಲಯವಿದೆಯೇ?

ಇಲ್ಲ. Unix timestamp 1970-01-01 00:00:00 UTCಯಿಂದ ಎಣಿಸಿದ ಕ್ಷಣ. ವಲಯಗಳು ಪ್ರದರ್ಶನ ಬದಲಿಸುತ್ತವೆ, ಸಂಖ್ಯೆಯನ್ನು ಅಲ್ಲ.