Unix Timestamp ਸਕਿੰਟ ਬਨਾਮ ਮਿਲੀਸਕਿੰਟ: ਤਾਰੀਖ 1970 ਕਿਉਂ ਵਿਖਾਉਂਦੀ ਹੈ

ਤੁਸੀਂ timestamp ਤਾਰੀਖ ਵਿੱਚ ਬਦਲਿਆ ਅਤੇ ਜਨਵਰੀ 1970 ਤੇ ਪਹੁੰਚ ਗਏ। ਘੜੀ ਬਹੁਤ ਘੱਟ ਖ਼ਰਾਬ ਹੁੰਦੀ ਹੈ। ਅੰਕ ਸਕਿੰਟ ਵਜੋਂ ਸੰਭਾਲਿਆ ਸੀ ਪਰ ਮਿਲੀਸਕਿੰਟ ਪੜ੍ਹਿਆ ਗਿਆ—ਜਾਂ ਉਲਟ।

Unix timestamp ਕੀ ਹੈ?

Unix timestamp ਸਮਾਂ Unix epoch ਤੋਂ ਮਾਪਦਾ ਹੈ: 1970-01-01 00:00:00 UTC। ਆਮ ਤੌਰ ਤੇ ਪੂਰੇ ਸਕਿੰਟ ਹੁੰਦੇ ਹਨ। ਉਹੀ ਪਲ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਵੀ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਸਕਿੰਟ × 1,000)। ਅੰਕ ਆਪ ਇਕਾਈ ਨਹੀਂ ਦੱਸਦਾ।

ਸਕਿੰਟ ਬਨਾਮ ਮਿਲੀਸਕਿੰਟ: 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 ਹੋਵੇ ਤਾਂ ਪਹਿਲਾਂ ਸਕਿੰਟ ਬਨਾਮ ਮਿਲੀਸਕਿੰਟ ਵੇਖੋ।

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 ਤੋਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ। ਸਮਾਂ ਖੇਤਰ ਦਿਖਾਉਣ ਦਾ ਤਰੀਕਾ ਬਦਲਦੇ ਹਨ, ਅੰਕ ਨਹੀਂ।