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

ਪਰਿਚਯ

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

ਇਹ ਟਾਈਮਸਟੈਂਪ ਤੋਂ ਤਾਰੀਖ ਕਨਵਰਟਰ ਵੱਖ-ਵੱਖ ਲੰਬਾਈਆਂ ਦੇ ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਆਟੋਮੈਟਿਕ ਪਛਾਣ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ (16 ਅੰਕ), ਮਿਲੀਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ (13 ਅੰਕ), ਅਤੇ ਮਿਆਰੀ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ (10 ਅੰਕ) ਸ਼ਾਮਲ ਹਨ। ਇਹ ਟੂਲ ਇਨਪੁਟ ਦੀ ਲੰਬਾਈ ਦੇ ਆਧਾਰ 'ਤੇ ਟਾਈਮਸਟੈਂਪ ਫਾਰਮੈਟ ਦੀ ਪਛਾਣ ਕਰਦਾ ਹੈ, ਇਸਨੂੰ ਮਨੁੱਖ-ਪੜ੍ਹਨਯੋਗ ਤਾਰੀਖ ਅਤੇ ਸਮਾਂ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਅਤੇ ਨਤੀਜੇ ਨੂੰ ਦਿਖਾਉਂਦਾ ਹੈ ਬਿਨਾਂ ਇਸਦੇ ਕਿ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਟਾਈਮਸਟੈਂਪ ਦੀ ਕਿਸਮ ਦਰਜ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ 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)}$

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

ਟਾਈਮਸਟੈਂਪ ਫਾਰਮੈਟ ਅਤੇ ਆਟੋਮੈਟਿਕ ਪਛਾਣ

ਸਾਡਾ ਕਨਵਰਟਰ ਤਿੰਨ ਆਮ ਟਾਈਮਸਟੈਂਪ ਫਾਰਮੈਟਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਆਧਾਰ 'ਤੇ ਆਟੋਮੈਟਿਕ ਪਛਾਣ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:

1. ਮਿਆਰੀ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ (10 ਅੰਕ): ਯੂਨਿਕ ਏਪੋਕ ਤੋਂ ਸਕਿੰਡਾਂ ਦੀ ਗਿਣਤੀ ਦਰਸਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ: 1609459200 (1 ਜਨਵਰੀ 2021, 00:00:00 UTC)

2. ਮਿਲੀਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ (13 ਅੰਕ): ਯੂਨਿਕ ਏਪੋਕ ਤੋਂ ਮਿਲੀਸੈਕੰਡਾਂ ਦੀ ਗਿਣਤੀ ਦਰਸਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ: 1609459200000 (1 ਜਨਵਰੀ 2021, 00:00:00 UTC)

3. ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ (16 ਅੰਕ): ਯੂਨਿਕ ਏਪੋਕ ਤੋਂ ਮਾਈਕ੍ਰੋਸੈਕੰਡਾਂ ਦੀ ਗਿਣਤੀ ਦਰਸਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ: 1609459200000000 (1 ਜਨਵਰੀ 2021, 00:00:00 UTC)

ਆਟੋਮੈਟਿਕ ਪਛਾਣ ਇਨਪੁਟ ਦੀ ਲੰਬਾਈ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਕੇ ਕੰਮ ਕਰਦੀ ਹੈ:

• ਜੇ ਇਨਪੁਟ ਵਿੱਚ 10 ਅੰਕ ਹਨ, ਤਾਂ ਇਸਨੂੰ ਮਿਆਰੀ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ (ਸਕਿੰਡ) ਦੇ ਤੌਰ 'ਤੇ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ
• ਜੇ ਇਨਪੁਟ ਵਿੱਚ 13 ਅੰਕ ਹਨ, ਤਾਂ ਇਸਨੂੰ ਮਿਲੀਸੈਕੰਡ ਟਾਈਮਸਟੈਂਪ ਦੇ ਤੌਰ 'ਤੇ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ
• ਜੇ ਇਨਪੁਟ ਵਿੱਚ 16 ਅੰਕ ਹਨ, ਤਾਂ ਇਸਨੂੰ ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਟਾਈਮਸਟੈਂਪ ਦੇ ਤੌਰ 'ਤੇ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ

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

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

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

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 ਦੀ ਸਮੱਸਿਆ: ਮਿਆਰੀ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ (10 ਅੰਕ) ਅਕਸਰ 32-ਬਿੱਟ ਸਾਈਨਡ ਇੰਟੀਜਰ ਦੇ ਤੌਰ 'ਤੇ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਜੋ ਕਿ 19 ਜਨਵਰੀ 2038 'ਤੇ ਓਵਰਫਲੋ ਹੋ ਜਾਣਗੇ। ਇਸ ਮਿਤੀ ਤੋਂ ਬਾਅਦ, 32-ਬਿੱਟ ਸਿਸਟਮਾਂ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸਮਿਆਂ ਨੂੰ ਦਰਸਾਉਣ ਵਿੱਚ ਅਸਮਰਥ ਹੋ ਜਾਣਗੇ ਜੇਕਰ ਵੱਡੇ ਇੰਟੀਜਰ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਨਾ ਕੀਤੀ ਜਾਵੇ।

3. ਪ੍ਰੀਸਿਜ਼ਨ ਦੇ ਵਿਚਾਰ:

   • ਮਿਆਰੀ ਟਾਈਮਸਟੈਂਪ (10 ਅੰਕ) ਸਕਿੰਡ-ਸਤਰ ਦੀ ਪ੍ਰੀਸਿਜ਼ਨ ਰੱਖਦੇ ਹਨ, ਜੋ ਕਿ ਜ਼ਿਆਦਾਤਰ ਹਰ ਰੋਜ਼ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਯੋਗ ਹੈ।
   • ਮਿਲੀਸੈਕੰਡ ਟਾਈਮਸਟੈਂਪ (13 ਅੰਕ) 1000 ਗੁਣਾ ਵੱਧ ਪ੍ਰੀਸਿਜ਼ਨ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਜੋ ਕਿ ਹੋਰ ਸਹੀ ਸਮੇਂ ਦੀ ਲੋੜ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਲਾਭਕਾਰੀ ਹੈ।
   • ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਟਾਈਮਸਟੈਂਪ (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 APIs ਆਮ ਤੌਰ 'ਤੇ ਮਿਲੀਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ ਟਾਈਮਸਟੈਂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।

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

7. ਸੈਸ਼ਨ ਪ੍ਰਬੰਧਨ: ਵੈਬ ਐਪਲੀਕੇਸ਼ਨ ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਤਾਂ ਜੋ ਇਹ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿ ਉਪਭੋਗਤਾ ਸੈਸ਼ਨ ਕਦੋਂ ਸਮਾਪਤ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।

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

9. ਉੱਚ-ਫ੍ਰੀਕਵੈਂਸੀ ਵਪਾਰ: ਵਿੱਤੀ ਸਿਸਟਮਾਂ ਨੂੰ ਵੱਡੀ ਪ੍ਰੀਸਿਜ਼ਨ (16 ਅੰਕ) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਤਾਂ ਜੋ ਲੈਣ-ਦੇਣਾਂ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਜਾ ਸਕੇ।

10. ਵਿਗਿਆਨਕ ਮਾਪ: ਖੋਜ ਸਾਜ਼ੋ-ਸਮਾਨ ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ ਨਾਲ ਨਿਰੀਖਣਾਂ ਨੂੰ ਦਰਜ ਕਰ ਸਕਦੇ ਹਨ ਤਾਂ ਜੋ ਸਮੇਂ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਸਹੀ ਹੋਵੇ।

ਵਿਕਲਪ

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

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

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

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

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

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

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

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

ਇਤਿਹਾਸ

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

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

ਜਦੋਂਕਿ ਕੰਪਿਊਟਿੰਗ ਦੀਆਂ ਲੋੜਾਂ ਵਿਕਸਤ ਹੋਈਆਂ, ਵੱਡੀ ਪ੍ਰੀਸਿਜ਼ਨ ਵਾਲੇ ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਲੋੜ ਪੈਣ ਲੱਗੀ:

• ਮਿਲੀਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ (13 ਅੰਕ) ਇੰਟਰੈਕਟਿਵ ਕੰਪਿਊਟਿੰਗ ਦੇ ਉੱਪਰ ਆਉਣ ਅਤੇ ਉਪਭੋਗਤਾ ਇੰਟਰਫੇਸ ਦੀ ਜਵਾਬਦਾਰੀ ਨੂੰ ਮਾਪਣ ਦੀ ਲੋੜ ਨਾਲ ਆਮ ਹੋ ਗਿਆ।

• ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ (16 ਅੰਕ) ਉੱਚ-ਕਾਰਗੁਜ਼ਾਰੀ ਕੰਪਿਊਟਿੰਗ ਐਪਲੀਕੇਸ਼ਨਾਂ ਅਤੇ ਬਹੁਤ ਸਹੀ ਸਮੇਂ ਦੀ ਲੋੜ ਵਾਲੀਆਂ ਵਿਗਿਆਨਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨਾਲ ਆਇਆ।

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

ਆਧੁਨਿਕ ਸਿਸਟਮਾਂ ਵੱਡੇ ਇੰਟੀਜਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਿੱਚ ਵਧ ਰਹੇ ਹਨ, ਜੋ ਕਿ ਪ੍ਰਤੀਨਿਧਿਤ ਕਰਨ ਦੀ ਰੇਂਜ ਨੂੰ ਲਗਭਗ 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

ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਕੀ ਹੈ?

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

ਆਟੋਮੈਟਿਕ ਟਾਈਮਸਟੈਂਪ ਫਾਰਮੈਟ ਪਛਾਣ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

ਕਨਵਰਟਰ ਆਟੋਮੈਟਿਕ ਪਛਾਣ ਕਰਦਾ ਹੈ ਕਿ ਟਾਈਮਸਟੈਂਪ ਫਾਰਮੈਟ ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਆਧਾਰ 'ਤੇ:

• 10 ਅੰਕ: ਮਿਆਰੀ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ (ਏਪੋਕ ਤੋਂ ਸਕਿੰਡ)
• 13 ਅੰਕ: ਮਿਲੀਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ ਟਾਈਮਸਟੈਂਪ
• 16 ਅੰਕ: ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ ਟਾਈਮਸਟੈਂਪ

ਮੈਨੂੰ ਮਿਲੀਸੈਕੰਡ ਜਾਂ ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ?

ਮਿਲੀਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ (13 ਅੰਕ) ਉਹ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਲਾਭਕਾਰੀ ਹੈ ਜੋ ਹੋਰ ਸਹੀ ਸਮੇਂ ਦੀ ਲੋੜ ਰੱਖਦੀਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਪ੍ਰਦਰਸ਼ਨ ਨਿਗਰਾਨੀ, ਉਪਭੋਗਤਾ ਇੰਟਰਐਕਸ਼ਨ ਟ੍ਰੈਕਿੰਗ, ਅਤੇ ਕੁਝ ਵਿੱਤੀ ਐਪਲੀਕੇਸ਼ਨਾਂ। ਮਾਈਕ੍ਰੋਸੈਕੰਡ ਪ੍ਰੀਸਿਜ਼ਨ (16 ਅੰਕ) ਉੱਚ-ਕਾਰਗੁਜ਼ਾਰੀ ਕੰਪਿਊਟਿੰਗ, ਵਿਗਿਆਨਕ ਐਪਲੀਕੇਸ਼ਨਾਂ, ਅਤੇ ਉੱਚ-ਫ੍ਰੀਕਵੈਂਸੀ ਵਪਾਰ ਸਿਸਟਮਾਂ ਲਈ ਜਰੂਰੀ ਹੈ ਜਿਥੇ ਬਹੁਤ ਸਹੀ ਸਮੇਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਕੀ ਮੈਂ 1970 ਤੋਂ ਪਹਿਲਾਂ ਦੀਆਂ ਤਾਰੀਖਾਂ ਨੂੰ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਦਲ ਸਕਦਾ ਹਾਂ?

ਹਾਂ, 1 ਜਨਵਰੀ 1970 ਤੋਂ ਪਹਿਲਾਂ ਦੀਆਂ ਤਾਰੀਖਾਂ ਨੂੰ ਨਕਾਰਾਤਮਕ ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਕੁਝ ਸਿਸਟਮ ਨਕਾਰਾਤਮਕ ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਇਸ ਲਈ ਜੇਕਰ ਤੁਹਾਨੂੰ ਇਤਿਹਾਸਕ ਤਾਰੀਖਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਇਸ ਫੰਕਸ਼ਨਲਿਟੀ ਦੀ ਜਾਂਚ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਸਾਲ 2038 ਦੀ ਸਮੱਸਿਆ ਕੀ ਹੈ?

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

ਮੈਂ ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪਾਂ ਨਾਲ ਟਾਈਮਜ਼ੋਨ ਬਦਲਾਵਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲ ਸਕਦਾ ਹਾਂ?

ਯੂਨਿਕ ਟਾਈਮਸਟੈਂਪ ਸਦਾ UTC (ਸੰਯੁਕਤ ਸਮਾਂ) ਵਿੱਚ ਹੁੰਦੇ ਹਨ। ਸਥਾਨਕ ਸਮੇਂ ਵਿੱਚ ਬਦਲਣ ਲਈ, ਤੁਹਾਨੂੰ ਟਾਈਮਜ਼ੋਨ ਦੀ ਸਹੀ ਜਾਣਕਾਰੀ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅਧਿਕਤਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਟਾਈਮਜ਼ੋਨ ਬਦਲਾਵਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਬਣBuilt-in ਫੰਕਸ਼ਨ ਹਨ।

ਯੂਨਿਕ ਸਮਾਂ ਅਤੇ ISO 8601 ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ?

ਯੂਨਿਕ ਸਮਾਂ ਇੱਕ ਗਣਿਤੀ ਪ੍ਰਤੀਨਿਧਾਨ ਹੈ (ਏਪੋਕ ਤੋਂ ਸਕਿੰਡ), ਜਦਕਿ ISO 8601 ਇੱਕ ਸਤਰ ਫਾਰਮੈਟ ਹੈ (ਜਿਵੇਂ "2021-01-01T00:00:00Z")। ਯੂਨਿਕ ਸਮਾਂ ਗਣਨਾਵਾਂ ਲਈ ਹੋਰ ਸੰਕੁਚਿਤ ਅਤੇ ਆਸਾਨ ਹੈ, ਜਦਕਿ ISO 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. "ISO 8601।" ਵਿਕੀਪੀਡੀਆ, ਵਿਕੀਮੀਡੀਆ ਫਾਉਂਡੇਸ਼ਨ, https://en.wikipedia.org/wiki/ISO_8601

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

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

7. "ਉੱਚ-ਕਾਰਗੁਜ਼ਾਰੀ ਕੰਪਿਊਟਿੰਗ ਵਿੱਚ ਸਹੀ ਸਮਾਂ।" ACM Computing Surveys, https://dl.acm.org/doi/10.1145/3232678

8. "ਵਿੱਤੀ ਸਿਸਟਮਾਂ ਵਿੱਚ ਸਮਾਂ ਪ੍ਰਤੀਨਿਧਾਨ।" ਜਰਨਲ ਆਫ ਫਾਇਨੈਂਸ਼ੀਅਲ ਟੈਕਨੋਲੋਜੀ, https://www.fintech-journal.com/time-representation

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