ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਕਨਵਰਟਰ

ਪਰੀਚਯ

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ (ਜਿਸਨੂੰ ਪੋਸਿਕਸ ਸਮਾਂ ਜਾਂ ਐਪੋਕ ਸਮਾਂ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਸਮੇਂ ਦੇ ਇੱਕ ਪੌਇੰਟ ਨੂੰ ਵਰਣਨ ਕਰਨ ਲਈ ਇੱਕ ਪ੍ਰਣਾਲੀ ਹੈ। ਇਹ 1 ਜਨਵਰੀ 1970 (ਮੱਧ ਰਾਤ UTC/GMT) ਤੋਂ ਲੰਬੇ ਸਮੇਂ ਦੇ ਗਿਣਤੀ ਵਿੱਚ ਗਿਣਤੀ ਕੀਤੇ ਗਏ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਛਾਲ ਦੇ ਸਕਿੰਟ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ। ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਕੰਪਿਊਟਰ ਸਿਸਟਮਾਂ ਅਤੇ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਇਹ ਕਿਸੇ ਖਾਸ ਸਮੇਂ ਦੇ ਪਲ ਦਾ ਸੰਕੁਚਿਤ, ਭਾਸ਼ਾ-ਗੈਰ-ਨਿਰਭਰ ਪ੍ਰਤੀਨਿਧਾਨ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।

ਇਹ ਕਨਵਰਟਰ ਤੁਹਾਨੂੰ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗ ਤਾਰੀਖ ਅਤੇ ਸਮਾਂ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇਹ 12-ਘੰਟੇ (AM/PM) ਅਤੇ 24-ਘੰਟੇ ਸਮਾਂ ਫਾਰਮੈਟ ਦੋਹਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਵੱਖ-ਵੱਖ ਖੇਤਰਾਂ ਅਤੇ ਨਿੱਜੀ ਪਸੰਦਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਸਕੇ।

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਯੂਨਿਕ ਐਪੋਕ (1 ਜਨਵਰੀ 1970, 00:00:00 UTC) ਤੋਂ ਲੰਬੇ ਸਮੇਂ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਰੂਪ ਵਿੱਚ ਗਿਣਤੀ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇਸ ਨਾਲ ਸਮੇਂ ਦੇ ਫਰਕ ਦੀ ਗਿਣਤੀ ਕਰਨ ਅਤੇ ਤਾਰੀਖਾਂ ਨੂੰ ਸੰਕੁਚਿਤ ਫਾਰਮੈਟ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਲਈ ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਬਣਾਉਂਦਾ ਹੈ।

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਤੋਂ ਕੈਲੰਡਰ ਦੀ ਤਾਰੀਖ ਵਿੱਚ ਬਦਲਣ ਲਈ ਗਣਿਤੀਕ ਬਦਲਾਅ ਵਿੱਚ ਕਈ ਕਦਮ ਸ਼ਾਮਲ ਹਨ:

1. ਯੂਨਿਕ ਐਪੋਕ (1 ਜਨਵਰੀ 1970, 00:00:00 UTC) ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ
2. ਟਾਈਮਸਟੈਂਪ ਵਿੱਚ ਦਿੱਤੀ ਗਈ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਜੋੜੋ
3. ਛਾਲ ਦੇ ਸਾਲਾਂ, ਵੱਖ-ਵੱਖ ਮਹੀਨਿਆਂ ਦੀ ਲੰਬਾਈ, ਅਤੇ ਹੋਰ ਕੈਲੰਡਰ ਦੀਆਂ ਜਟਿਲਤਾਵਾਂ ਦਾ ਖਿਆਲ ਰੱਖੋ
4. ਜੇ ਜ਼ਰੂਰੀ ਹੋਵੇ ਤਾਂ ਸਮਾਂ ਖੇਤਰ ਦੇ ਅਨੁਸਾਰ ਸੁਧਾਰ ਕਰੋ

ਉਦਾਹਰਨ ਵਜੋਂ, ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ 1609459200 ਸ਼ੁੱਕਰਵਾਰ, 1 ਜਨਵਰੀ 2021, 00:00:00 UTC ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

ਬਦਲਾਅ ਦਾ ਫਾਰਮੂਲਾ ਇਸ ਤਰ੍ਹਾਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

$\text{Date} = \text{Unix Epoch} + \text{Timestamp (in seconds)}$

ਜ਼ਿਆਦਾਤਰ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ ਇਸ ਬਦਲਾਅ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਬਣੀ-ਬਣਾਈ ਫੰਕਸ਼ਨ ਹਨ, ਜੋ ਕਿ ਜਟਿਲ ਕੈਲੰਡਰ ਦੀਆਂ ਗਣਨਾਵਾਂ ਨੂੰ ਛੁਪਾਉਂਦੇ ਹਨ।

ਸਮਾਂ ਫਾਰਮੈਟ ਵਿਕਲਪ

ਇਹ ਕਨਵਰਟਰ ਦੋ ਸਮਾਂ ਫਾਰਮੈਟ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ:

1. 24-ਘੰਟੇ ਫਾਰਮੈਟ (ਕਈ ਵਾਰ "ਸੈਨਿਕ ਸਮਾਂ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ): ਘੰਟੇ 0 ਤੋਂ 23 ਤੱਕ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਕੋਈ AM/PM ਨਿਰਧਾਰਨ ਨਹੀਂ ਹੁੰਦਾ। ਉਦਾਹਰਨ ਵਜੋਂ, 3:00 PM ਨੂੰ 15:00 ਦੇ ਤੌਰ 'ਤੇ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ।

2. 12-ਘੰਟੇ ਫਾਰਮੈਟ: ਘੰਟੇ 1 ਤੋਂ 12 ਤੱਕ ਹੁੰਦੇ ਹਨ, ਜਿਸ ਵਿੱਚ ਰਾਤ ਦੇ ਸਮੇਂ ਤੋਂ ਦੁਪਹਿਰ ਤੱਕ AM (ਐਂਟੀ ਮੇਰਿਡੀਮ) ਅਤੇ ਦੁਪਹਿਰ ਤੋਂ ਰਾਤ ਦੇ ਸਮੇਂ ਤੱਕ PM (ਪੋਸਟ ਮੇਰਿਡੀਮ) ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, 24-ਘੰਟੇ ਫਾਰਮੈਟ ਵਿੱਚ 15:00 ਨੂੰ 3:00 PM ਦੇ ਤੌਰ 'ਤੇ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ।

ਇਹ ਫਾਰਮੈਟਾਂ ਵਿੱਚੋਂ ਚੋਣ ਕਰਨਾ ਮੁੱਖ ਤੌਰ 'ਤੇ ਖੇਤਰਕ ਪਰੰਪਰਾਵਾਂ ਅਤੇ ਨਿੱਜੀ ਪਸੰਦਾਂ ਦਾ ਮਾਮਲਾ ਹੈ:

• 24-ਘੰਟੇ ਫਾਰਮੈਟ ਜ਼ਿਆਦਾਤਰ ਯੂਰਪ, ਲਾਤੀਨ ਅਮਰੀਕਾ ਅਤੇ ਏਸ਼ੀਆ ਦੇ ਬਹੁਤ ਸਾਰੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਵਿਸ਼ਵ ਭਰ ਵਿੱਚ ਵਿਗਿਆਨਕ, ਸੈਨਿਕ ਅਤੇ ਮੈਡੀਕਲ ਸੰਦਰਭਾਂ ਵਿੱਚ ਵੀ।
• 12-ਘੰਟੇ ਫਾਰਮੈਟ ਸੰਯੁਕਤ ਰਾਜ, ਕੈਨੇਡਾ, ਆਸਟ੍ਰੇਲੀਆ ਅਤੇ ਕੁਝ ਹੋਰ ਅੰਗਰੇਜ਼ੀ-ਬੋਲਣ ਵਾਲੇ ਦੇਸ਼ਾਂ ਵਿੱਚ ਦਿਨਚਾਰ ਵਿੱਚ ਪ੍ਰਚਲਿਤ ਹੈ।

ਕਿਨਾਰਾ ਕੇਸ ਅਤੇ ਸੀਮਾਵਾਂ

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਸਮੇਂ, ਕਈ ਕਿਨਾਰਾ ਕੇਸਾਂ ਅਤੇ ਸੀਮਾਵਾਂ ਦੇ ਬਾਰੇ ਜਾਣਕਾਰੀ ਹੋਣਾ ਜਰੂਰੀ ਹੈ:

1. ਨਕਾਰਾਤਮਕ ਟਾਈਮਸਟੈਂਪ: ਇਹ ਯੂਨਿਕ ਐਪੋਕ (1 ਜਨਵਰੀ 1970) ਤੋਂ ਪਹਿਲਾਂ ਦੀਆਂ ਤਾਰੀਖਾਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ। ਹਾਲਾਂਕਿ ਗਣਿਤੀਕ ਤੌਰ 'ਤੇ ਇਹ ਸਹੀ ਹਨ, ਕੁਝ ਸਿਸਟਮ ਨਕਾਰਾਤਮਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲ ਨਹੀਂ ਕਰ ਸਕਦੇ।

2. ਸਾਲ 2038 ਦੀ ਸਮੱਸਿਆ: ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਆਮ ਤੌਰ 'ਤੇ 32-ਬਿਟ ਸਾਈਨਡ ਇੰਟੀਜਰ ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਜੋ 19 ਜਨਵਰੀ 2038 ਨੂੰ ਓਵਰਫਲੋ ਹੋ ਜਾਣਗੇ। ਇਸ ਮਿਤੀ ਤੋਂ ਬਾਅਦ, 32-ਬਿਟ ਸਿਸਟਮਾਂ ਸਮਿਆਂ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਦਰਸਾਉਣ ਵਿੱਚ ਅਸਮਰਥ ਹੋ ਜਾਣਗੇ ਜਦ ਤੱਕ ਕਿ ਉਨ੍ਹਾਂ ਨੂੰ ਵੱਡੇ ਇੰਟੀਜਰ ਕਿਸਮਾਂ ਵਿੱਚ ਬਦਲਿਆ ਨਾ ਜਾਵੇ।

3. ਬਹੁਤ ਵੱਡੇ ਟਾਈਮਸਟੈਂਪ: ਬਹੁਤ ਦੂਰ ਦੇ ਭਵਿੱਖ ਦੀਆਂ ਤਾਰੀਖਾਂ ਕੁਝ ਸਿਸਟਮਾਂ ਵਿੱਚ ਦਰਸਾਈ ਨਹੀਂ ਜਾ ਸਕਦੀਆਂ, ਜਾਂ ਇਹ ਅਸਮਾਨਤਾ ਨਾਲ ਸੰਭਾਲੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ।

4. ਛਾਲ ਦੇ ਸਕਿੰਟ: ਯੂਨਿਕ ਸਮਾਂ ਛਾਲ ਦੇ ਸਕਿੰਟਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਨਹੀਂ ਰੱਖਦਾ, ਜੋ ਕਿ ਆਕਾਸ਼ੀ ਸਮੇਂ ਦੇ ਅਸਮਾਨਤਾ ਨੂੰ ਸਮਰਥਨ ਕਰਨ ਲਈ ਸਮੇਂ-ਸਮੇਂ ਤੇ UTC ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਯੂਨਿਕ ਸਮਾਂ ਆਕਾਸ਼ੀ ਸਮੇਂ ਨਾਲ ਸਹੀ ਤੌਰ 'ਤੇ ਸਮਕਾਲੀਕ੍ਰਿਤ ਨਹੀਂ ਹੈ।

5. ਸਮਾਂ ਖੇਤਰ ਦੇ ਵਿਚਾਰ: ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਮੋਮੈਂਟਾਂ ਨੂੰ UTC ਵਿੱਚ ਦਰਸਾਉਂਦੇ ਹਨ। ਸਥਾਨਕ ਸਮੇਂ ਵਿੱਚ ਬਦਲਣ ਲਈ ਵਾਧੂ ਸਮਾਂ ਖੇਤਰ ਦੀ ਜਾਣਕਾਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

6. ਦਿਨ ਦੀ ਬਚਤ ਦਾ ਸਮਾਂ: ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਸਥਾਨਕ ਸਮੇਂ ਵਿੱਚ ਬਦਲਣ ਵੇਲੇ, ਦਿਨ ਦੀ ਬਚਤ ਦੇ ਸਮੇਂ ਦੇ ਬਦਲਾਵਾਂ ਦੀਆਂ ਜਟਿਲਤਾਵਾਂ ਦਾ ਧਿਆਨ ਰੱਖਣਾ ਜਰੂਰੀ ਹੈ।

ਵਰਤੋਂ ਦੇ ਕੇਸ

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਕੰਪਿਊਟਿੰਗ ਅਤੇ ਡਾਟਾ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਕਈ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ:

1. ਡਾਟਾਬੇਸ ਰਿਕਾਰਡ: ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਦਰਜਿਆਂ ਦੇ ਬਣਨ ਜਾਂ ਸੋਧੇ ਜਾਣ ਦੀ ਮਿਤੀ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

2. ਵੈਬ ਵਿਕਾਸ: HTTP ਹੈਡਰ, ਕੁਕੀਜ਼, ਅਤੇ ਕੈਸ਼ਿੰਗ ਮਕੈਨਿਜ਼ਮ ਆਮ ਤੌਰ 'ਤੇ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।

3. ਲੌਗ ਫਾਈਲਾਂ: ਸਿਸਟਮ ਲੌਗ ਆਮ ਤੌਰ 'ਤੇ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਨਾਲ ਘਟਨਾਵਾਂ ਨੂੰ ਸਹੀ ਕ੍ਰਮ ਵਿੱਚ ਦਰਸਾਉਂਦੇ ਹਨ।

4. ਵਰਜਨ ਕੰਟਰੋਲ ਸਿਸਟਮ: ਗਿਟ ਅਤੇ ਹੋਰ VCS ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਤਾਂ ਜੋ ਦਰਜਿਆਂ ਦੇ ਬਣਨ ਦੀ ਮਿਤੀ ਦਰਸਾਈ ਜਾ ਸਕੇ।

5. API ਜਵਾਬ: ਬਹੁਤ ਸਾਰੇ ਵੈਬ APIs ਆਪਣੇ ਜਵਾਬਾਂ ਵਿੱਚ ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ ਤਾਂ ਜੋ ਇਹ ਦਰਸਾਇਆ ਜਾ ਸਕੇ ਕਿ ਡਾਟਾ ਕਦੋਂ ਬਣਾਇਆ ਗਿਆ ਜਾਂ ਸਰੋਤਾਂ ਨੂੰ ਕਦੋਂ ਆਖਰੀ ਵਾਰ ਸੋਧਿਆ ਗਿਆ।

6. ਫਾਈਲ ਸਿਸਟਮ: ਫਾਈਲਾਂ ਦੀ ਬਣਨ ਅਤੇ ਸੋਧਣ ਦੇ ਸਮੇਂ ਆਮ ਤੌਰ 'ਤੇ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

7. ਸੈਸ਼ਨ ਪ੍ਰਬੰਧਨ: ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਯੂਜ਼ਰ ਸੈਸ਼ਨਾਂ ਦੇ ਸਮੇਂ ਦੀ ਮਿਆਦ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਨ ਲਈ ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।

8. ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ: ਟਾਈਮਸਟੈਂਪਾਂ ਵਿਸ਼ਲੇਸ਼ਣ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਅਸਮਾਨਿਤ ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਮਿਆਰੀ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।

ਬਦਲਾਅ

ਜਦੋਂ ਕਿ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਦਾ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਕੁਝ ਹੋਰ ਸਮਾਂ ਪ੍ਰਤੀਨਿਧਾਨ ਫਾਰਮੈਟ ਹਨ ਜੋ ਕੁਝ ਸੰਦਰਭਾਂ ਵਿੱਚ ਹੋਰ ਉਚਿਤ ਹੋ ਸਕਦੇ ਹਨ:

1. ISO 8601: ਇੱਕ ਮਿਆਰੀਕ੍ਰਿਤ ਸਤਰ ਫਾਰਮੈਟ (ਜਿਵੇਂ "2021-01-01T00:00:00Z") ਜੋ ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗ ਹੈ ਜਦੋਂ ਕਿ ਇਹ ਸੋਰਟੇਬਿਲਟੀ ਨੂੰ ਬਣਾਈ ਰੱਖਦਾ ਹੈ। ਇਹ ਡਾਟਾ ਅਦਾਨ-ਪ੍ਰਦਾਨ ਅਤੇ ਉਪਭੋਗਤਾ-ਮੁਖੀ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਆਮ ਤੌਰ 'ਤੇ ਪਸੰਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

2. RFC 3339: ISO 8601 ਦਾ ਇੱਕ ਪ੍ਰੋਫਾਈਲ ਜੋ ਇੰਟਰਨੈੱਟ ਪ੍ਰੋਟੋਕੋਲਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਕਠੋਰ ਫਾਰਮੈਟਿੰਗ ਦੀਆਂ ਲੋੜਾਂ ਹਨ।

3. ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗ ਫਾਰਮੈਟ: ਸਥਾਨਕ ਤਾਰੀਖ਼ਾਂ ਦੇ ਸਤਰ (ਜਿਵੇਂ "1 ਜਨਵਰੀ 2021") ਸਿੱਧੇ ਉਪਭੋਗਤਾ ਸੰਪਰਕ ਲਈ ਹੋਰ ਉਚਿਤ ਹਨ ਪਰ ਗਣਨਾ ਲਈ ਇਹ ਘੱਟ ਉਚਿਤ ਹਨ।

4. ਮਾਈਕ੍ਰੋਸੌਫਟ ਫਾਈਲਟਾਈਮ: ਇੱਕ 64-ਬਿਟ ਮੁੱਲ ਜੋ 1601-01-01 ਤੋਂ ਲੈ ਕੇ 100-ਨਾਨੋਸਕਿੰਟਾਂ ਦੇ ਅੰਤਰਾਲਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਜੋ ਕਿ ਵਿੰਡੋਜ਼ ਸਿਸਟਮਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

5. ਜੂਲੀਅਨ ਦਿਨ ਦੀ ਗਿਣਤੀ: ਜੋ ਕਿ ਖਗੋਲ ਵਿਗਿਆਨ ਅਤੇ ਕੁਝ ਵਿਗਿਆਨਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ BCE 4713-01-01 ਤੋਂ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਦੀ ਹੈ।

ਸਮਾਂ ਫਾਰਮੈਟ ਦੀ ਚੋਣ ਬਹੁਤ ਸਾਰੇ ਕਾਰਕਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ:

• ਲੋੜੀਂਦੀ ਸਹੀਤਾ
• ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗਤਾ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ
• ਸਟੋਰੇਜ ਦੀਆਂ ਸੀਮਾਵਾਂ
• ਮੌਜੂਦਾ ਸਿਸਟਮਾਂ ਨਾਲ ਸਹਿਯੋਗ
• ਦਰਸਾਈ ਜਾਣ ਵਾਲੀਆਂ ਤਾਰੀਖਾਂ ਦੀ ਰੇਂਜ

ਇਤਿਹਾਸ

ਯੂਨਿਕ ਸਮਾਂ ਦਾ ਧਾਰਨਾ ਯੂਨਿਕ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਵਿਕਾਸ ਨਾਲ ਜੁੜੀ ਹੋਈ ਹੈ ਜੋ ਕਿ ਬੇਲ ਲੈਬਜ਼ ਵਿੱਚ 1960 ਦੇ ਅਖੀਰ ਅਤੇ 1970 ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਵਿਕਸਿਤ ਕੀਤਾ ਗਿਆ ਸੀ। ਐਪੋਕ ਦੇ ਤੌਰ 'ਤੇ 1 ਜਨਵਰੀ 1970 ਨੂੰ ਚੁਣਨ ਦਾ ਫੈਸਲਾ ਕੁਝ ਹੱਦ ਤੱਕ ਮਨਮਾਨਾ ਸੀ ਪਰ ਸਮੇਂ ਦੇ ਲਈ ਪ੍ਰਯੋਗਸ਼ੀਲ ਸੀ—ਇਹ ਰੁਕਾਵਟਾਂ ਤੋਂ ਬਚਣ ਲਈ ਕਾਫੀ ਨਜ਼ਦੀਕ ਸੀ ਜੋ ਕਿ ਦਿਲਚਸਪ ਤਾਰੀਖਾਂ ਦੀਆਂ ਗਿਣਤੀਆਂ ਲਈ ਸਟੋਰੇਜ ਦੀਆਂ ਲੋੜਾਂ ਨੂੰ ਘੱਟ ਕਰਦਾ ਸੀ ਪਰ ਇਤਿਹਾਸਕ ਡਾਟਾ ਲਈ ਲਾਭਦਾਇਕ ਸੀ।

ਮੂਲ ਕਾਰਜਕ੍ਰਮ ਵਿੱਚ 32-ਬਿਟ ਸਾਈਨਡ ਇੰਟੀਜਰ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਸੀ ਜੋ ਕਿ 1970 ਦੇ ਸਮੇਂ ਦੇ ਦੌਰਾਨ ਲਾਗੂ ਹੋਣ ਵਾਲੀਆਂ ਤਾਰੀਖਾਂ ਦੀਆਂ ਗਿਣਤੀਆਂ ਲਈ ਯੋਗ ਸੀ। ਹਾਲਾਂਕਿ, ਇਸ ਫੈਸਲੇ ਨੇ ਸਾਲ 2038 ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਜਨਮ ਦਿੱਤਾ (ਕਈ ਵਾਰੀ "Y2K38" ਜਾਂ "ਯੂਨਿਕ ਮਿਲੇਨਿਯਮ ਬੱਗ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ), ਕਿਉਂਕਿ 32-ਬਿਟ ਸਾਈਨਡ ਇੰਟੀਜਰ ਸਿਰਫ 19 ਜਨਵਰੀ 2038 ਤੱਕ ਦੀਆਂ ਤਾਰੀਖਾਂ ਨੂੰ ਦਰਸਾਉਣ ਦੇ ਯੋਗ ਹਨ (03:14:07 UTC)।

ਜਦੋਂ ਯੂਨਿਕ ਅਤੇ ਯੂਨਿਕ-ਜਿਹੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਦੀ ਪ੍ਰਸਿੱਧੀ ਵਧੀ, ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਕੰਪਿਊਟਿੰਗ ਵਿੱਚ ਇੱਕ ਦੇ ਫੈਕਟੋ ਮਿਆਰ ਬਣ ਗਿਆ। ਇਹ ਬਹੁਤ ਸਾਰੀਆਂ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ, ਡਾਟਾਬੇਸਾਂ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੁਆਰਾ ਅਪਨਾਇਆ ਗਿਆ, ਜੋ ਕਿ ਆਪਣੇ ਅਸਲੀ ਯੂਨਿਕ ਵਾਤਾਵਰਨ ਤੋਂ ਬਾਹਰ ਵੀ।

ਆਧੁਨਿਕ ਸਿਸਟਮਾਂ ਵਿੱਚ ਵਧੇਰੇ ਵੱਡੇ ਇੰਟੀਜਰਾਂ ਲਈ 64-ਬਿਟ ਇੰਟੀਜਰਾਂ ਦੀ ਵਰਤੋਂ ਵਧ ਰਹੀ ਹੈ, ਜਿਸ ਨਾਲ ਪ੍ਰਤੀਨਿਧਿਤਾ ਦੀ ਰੇਂਜ ਨੂੰ ਐਪੋਕ ਤੋਂ ਲਗਭਗ 292 ਬਿਲੀਅਨ ਸਾਲਾਂ ਤੱਕ ਵਧਾਇਆ ਗਿਆ ਹੈ, ਜਿਸ ਨਾਲ ਸਾਲ 2038 ਦੀ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਹੋ ਗਿਆ ਹੈ। ਹਾਲਾਂਕਿ, ਵਿਰਾਸਤ ਸਿਸਟਮ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਅਜੇ ਵੀ ਸੰਵੇਦਨਸ਼ੀਲ ਹੋ ਸਕਦੀਆਂ ਹਨ।

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਦੀ ਸਾਦਗੀ ਅਤੇ ਲਾਭਦਾਇਕਤਾ ਨੇ ਇਸਦੀ ਜਾਰੀ ਪ੍ਰਸਿੱਧੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾਇਆ ਹੈ, ਜਿਸ ਦੇ ਬਾਵਜੂਦ ਹੋਰ ਸੁਧਰੇ ਹੋਏ ਸਮਾਂ ਪ੍ਰਤੀਨਿਧਾਨ ਫਾਰਮੈਟਾਂ ਦੇ ਵਿਕਾਸ। ਇਹ ਕੰਪਿਊਟਿੰਗ ਵਿੱਚ ਇੱਕ ਮੂਲ ਧਾਰਨਾ ਹੈ, ਜੋ ਕਿ ਸਾਡੇ ਡਿਜੀਟਲ ਢਾਂਚੇ ਦੇ ਬਹੁਤ ਸਾਰੇ ਹਿੱਸਿਆਂ ਨੂੰ ਸਮਰਥਨ ਕਰਦੀ ਹੈ।

ਕੋਡ ਉਦਾਹਰਨਾਂ

ਇੱਥੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗ ਤਾਰੀਖਾਂ ਵਿੱਚ ਬਦਲਣ ਦੇ ਉਦਾਹਰਨ ਹਨ:

1// ਜਾਵਾਸਕ੍ਰਿਪਟ ਟਾਈਮਸਟੈਂਪ ਬਦਲਾਅ
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3  // ਇੱਕ ਨਵਾਂ Date ਵਸਤੂ ਬਣਾਓ (ਜਾਵਾਸਕ੍ਰਿਪਟ ਮਿਲੀਸੈਕਿੰਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ)
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; // 1 ਜਨਵਰੀ 2021 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    # ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ datetime ਵਸਤੂ ਵਿੱਚ ਬਦਲੋ
6    date = datetime.datetime.fromtimestamp(timestamp)
7    
8    # ਤਾਰੀਖ਼ ਸਤਰ ਦਾ ਫਾਰਮੈਟ
9    if use_12hour:
10        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-ਘੰਟੇ ਫਾਰਮੈਟ AM/PM ਨਾਲ
11    else:
12        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-ਘੰਟੇ ਫਾਰਮੈਟ
13    
14    return date.strftime(format_string)
15
16# ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ
17timestamp = 1609459200  # 1 ਜਨਵਰੀ 2021 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-ਘੰਟੇ ਫਾਰਮੈਟ AM/PM ਨਾਲ
7        : 'l, F j, Y H:i:s';   // 24-ਘੰਟੇ ਫਾਰਮੈਟ
8    
9    // ਬਦਲੋ ਅਤੇ ਫਾਰਮੈਟ ਕਰੋ
10    return date($formatString, $timestamp);
11}
12
13// ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ
14$timestamp = 1609459200; // 1 ਜਨਵਰੀ 2021 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        // ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ Instant ਵਿੱਚ ਬਦਲੋ, ਫਿਰ LocalDateTime ਵਿੱਚ
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; // 1 ਜਨਵਰੀ 2021 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        // ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ DateTime ਵਿੱਚ ਬਦਲੋ
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-ਘੰਟੇ ਫਾਰਮੈਟ AM/PM ਨਾਲ
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; // 1 ਜਨਵਰੀ 2021 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  # ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ Time ਵਸਤੂ ਵਿੱਚ ਬਦਲੋ
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-ਘੰਟੇ ਫਾਰਮੈਟ AM/PM ਨਾਲ
11  else
12    time.strftime("%A, %B %d, %Y %H:%M:%S")     # 24-ਘੰਟੇ ਫਾਰਮੈਟ
13  end
14end
15
16# ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ
17timestamp = 1609459200  # 1 ਜਨਵਰੀ 2021 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    // ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ Time ਵਿੱਚ ਬਦਲੋ
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-ਘੰਟੇ ਫਾਰਮੈਟ AM/PM ਨਾਲ
17    } else {
18        formatString += "15:04:05"    // 24-ਘੰਟੇ ਫਾਰਮੈਟ
19    }
20    
21    // ਫਾਰਮੈਟ ਕੀਤਾ ਹੋਇਆ ਸਮਾਂ ਵਾਪਸ ਕਰੋ
22    return t.Format(formatString)
23}
24
25func main() {
26    timestamp := int64(1609459200) // 1 ਜਨਵਰੀ 2021 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    // ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਤੋਂ Date ਬਣਾਓ
6    let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7    
8    // DateFormatter ਬਣਾਓ
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 // 1 ਜਨਵਰੀ 2021 00:00:00 UTC
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-ਘੰਟੇ ਫਾਰਮੈਟ
29print(convertUnixTimestamp(timestamp, use12Hour: true))  // 12-ਘੰਟੇ ਫਾਰਮੈਟ
30

1# R ਟਾਈਮਸਟੈਂਪ ਬਦਲਾਅ
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3  # ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ POSIXct datetime ਵਿੱਚ ਬਦਲੋ
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-ਘੰਟੇ ਫਾਰਮੈਟ AM/PM ਨਾਲ
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  # 1 ਜਨਵਰੀ 2021 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 datetime ਵਿੱਚ ਬਦਲੋ
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    excelDate = (timestamp / 86400) + 25569;
10    
11    % 12-ਘੰਟੇ ਜਾਂ 24-ਘੰਟੇ ਪਸੰਦ ਦੇ ਆਧਾਰ 'ਤੇ ਫਾਰਮੈਟ
12    if use12Hour
13        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy h:mm:ss AM/PM');
14    else
15        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy hh:mm:ss');
16    end
17end
18
19% ਵਰਤੋਂ ਵਿੱਚ
20% =ConvertUnixTimestamp(1609459200, TRUE)  ' 12-ਘੰਟੇ ਫਾਰਮੈਟ
21% =ConvertUnixTimestamp(1609459200, FALSE) ' 24-ਘੰਟੇ ਫਾਰਮੈਟ
22

ਕਿਨਾਰਾ ਕੇਸਾਂ ਨੂੰ ਸੰਭਾਲਣਾ

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਸਮੇਂ, ਕਿਨਾਰਾ ਕੇਸਾਂ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਣਾ ਜਰੂਰੀ ਹੈ। ਇੱਥੇ ਕੁਝ ਆਮ ਕਿਨਾਰਾ ਕੇਸਾਂ ਨੂੰ ਸੰਭਾਲਣ ਦੇ ਉਦਾਹਰਨ ਹਨ:

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. "ISO 8601।" ਵਿਕੀਪੀਡੀਆ, ਵਿਕੀਮੀਡੀਆ ਫਾਊਂਡੇਸ਼ਨ, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: ਇੰਟਰਨੈੱਟ 'ਤੇ ਤਾਰੀਖ ਅਤੇ ਸਮਾਂ: ਟਾਈਮਸਟੈਂਪ।" ਇੰਟਰਨੈੱਟ ਇੰਜੀਨੀਅਰਿੰਗ ਟਾਸਕ ਫੋਰਸ (IETF), https://tools.ietf.org/html/rfc3339

6. ਕੇਰਨਿਗਨ, ਬ੍ਰਾਇਨ ਡਬਲਯੂ., ਅਤੇ ਡੇਨਿਸ ਐਮ. ਰਿਚੀ। "ਸੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ।" ਪ੍ਰੈਂਟਿਸ ਹਾਲ, 1988।