JavaScript ਵਿੱਚ ਲਿਖੀ ਲਗਭਗ ਕਿਸੇ ਵੀ ਕਿਸਮ ਦੀ ਐਪਲੀਕੇਸ਼ਨ ਕੁਝ ਸਮਰੱਥਾ ਵਿੱਚ ਸਮੇਂ ਜਾਂ ਮਿਤੀਆਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੀ ਹੈ। ਸ਼ੁਰੂ ਵਿੱਚ, ਇਹ ਬਿਲਟ-ਇਨ ਮਿਤੀ API ਤੱਕ ਸੀਮਿਤ ਸੀ। ਇਸ API ਵਿੱਚ ਬੁਨਿਆਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਸ਼ਾਮਲ ਹੈ, ਪਰ ਇਹ ਕੀ ਕਰ ਸਕਦਾ ਹੈ ਵਿੱਚ ਕਾਫ਼ੀ ਸੀਮਤ ਹੈ। ਤੀਜੀ-ਧਿਰ ਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਜਿਵੇਂ Moment.js, ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਬਿਲਟ-ਇਨ APIs ਜਿਵੇਂ ਕਿ Intl API ਅਤੇ ਨਵੀਂ ਟੈਂਪੋਰਲ API, ਸਮੇਂ ਅਤੇ ਮਿਤੀਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਬਹੁਤ ਜ਼ਿਆਦਾ ਲਚਕਤਾ ਜੋੜਦੀਆਂ ਹਨ। Moment.js ਦਾ ਉਭਾਰ ਅਤੇ ਪਤਨ Moment.js ਇੱਕ JavaScript ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜਿਸ ਵਿੱਚ ਸਮੇਂ ਅਤੇ ਤਾਰੀਖਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸ਼ਕਤੀਸ਼ਾਲੀ ਉਪਯੋਗਤਾਵਾਂ ਹਨ। ਇਸ ਵਿੱਚ ਮੂਲ ਮਿਤੀ API ਤੋਂ ਗੁੰਮ ਹੋਈਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ, ਜਿਵੇਂ ਕਿ ਸਮਾਂ ਖੇਤਰ ਹੇਰਾਫੇਰੀ, ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਆਮ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। ਮੋਮੈਂਟ ਵਿੱਚ ਮਿਤੀਆਂ ਅਤੇ ਸਮੇਂ ਨੂੰ ਫਾਰਮੈਟ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਵੀ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਇਹ ਬਹੁਤ ਸਾਰੀਆਂ ਵੱਖ-ਵੱਖ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤੀ ਜਾਂਦੀ ਲਾਇਬ੍ਰੇਰੀ ਬਣ ਗਈ। ਹਾਲਾਂਕਿ, ਮੋਮੈਂਟ ਦੇ ਵੀ ਮੁੱਦੇ ਸਨ। ਇਹ ਇੱਕ ਵੱਡੀ ਲਾਇਬ੍ਰੇਰੀ ਹੈ, ਅਤੇ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਬੰਡਲ ਆਕਾਰ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਸ਼ਾਮਲ ਕਰ ਸਕਦੀ ਹੈ। ਕਿਉਂਕਿ ਲਾਇਬ੍ਰੇਰੀ ਟ੍ਰੀ ਹਿੱਲਣ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦੀ (ਆਧੁਨਿਕ ਬੰਡਲਰਾਂ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਜੋ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਅਣਵਰਤੇ ਹਿੱਸਿਆਂ ਨੂੰ ਹਟਾ ਸਕਦੀ ਹੈ), ਪੂਰੀ ਮੋਮੈਂਟ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਭਾਵੇਂ ਤੁਸੀਂ ਇਸਦੇ ਸਿਰਫ ਇੱਕ ਜਾਂ ਦੋ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ। ਮੋਮੈਂਟ ਦੇ ਨਾਲ ਇੱਕ ਹੋਰ ਮੁੱਦਾ ਇਹ ਤੱਥ ਹੈ ਕਿ ਇਸ ਦੁਆਰਾ ਬਣਾਈਆਂ ਗਈਆਂ ਵਸਤੂਆਂ ਪਰਿਵਰਤਨਸ਼ੀਲ ਹਨ। ਕਿਸੇ ਮੋਮੈਂਟ ਆਬਜੈਕਟ 'ਤੇ ਕੁਝ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਾਲ ਕਰਨ ਦੇ ਮਾੜੇ ਪ੍ਰਭਾਵ ਹੁੰਦੇ ਹਨ ਅਤੇ ਉਸ ਵਸਤੂ ਦੇ ਮੁੱਲ ਨੂੰ ਬਦਲਦਾ ਹੈ। ਇਸ ਨਾਲ ਅਚਾਨਕ ਵਿਵਹਾਰ ਜਾਂ ਬੱਗ ਹੋ ਸਕਦੇ ਹਨ। 2020 ਵਿੱਚ, ਮੋਮੈਂਟ ਦੇ ਰੱਖਿਅਕਾਂ ਨੇ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਮੇਨਟੇਨੈਂਸ ਮੋਡ ਵਿੱਚ ਰੱਖਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ। ਕੋਈ ਨਵੀਂ ਵਿਸ਼ੇਸ਼ਤਾ ਵਿਕਾਸ ਨਹੀਂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਅਤੇ ਰੱਖ-ਰਖਾਵ ਕਰਨ ਵਾਲੇ ਨਵੇਂ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਵਿਰੁੱਧ ਸਿਫਾਰਸ਼ ਕਰਦੇ ਹਨ। ਇੱਥੇ ਹੋਰ JavaScript ਮਿਤੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ date-fns, ਪਰ ਕਸਬੇ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਪਲੇਅਰ ਹੈ, ਇੱਕ API ਸਿੱਧਾ JavaScript ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ: ਟੈਂਪੋਰਲ। ਇਹ ਇੱਕ ਨਵਾਂ ਸਟੈਂਡਰਡ ਹੈ ਜੋ ਅਸਲ ਮਿਤੀ API ਦੇ ਛੇਕ ਨੂੰ ਭਰਦਾ ਹੈ ਅਤੇ ਨਾਲ ਹੀ ਮੋਮੈਂਟ ਅਤੇ ਹੋਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਿੱਚ ਪਾਈਆਂ ਗਈਆਂ ਕੁਝ ਸੀਮਾਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ। ਟੈਂਪੋਰਲ ਕੀ ਹੈ? ਟੈਂਪੋਰਲ ਇੱਕ ਨਵਾਂ ਸਮਾਂ ਅਤੇ ਮਿਤੀ API ਹੈ ਜੋ ECMAScript ਮਿਆਰ ਵਿੱਚ ਜੋੜਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਜੋ ਆਧੁਨਿਕ JavaScript ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਮਾਰਚ 20266 ਤੱਕ, ਇਹ TC39 ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੜਾਅ 4 'ਤੇ ਪਹੁੰਚ ਗਿਆ ਹੈ (ਉਹ ਕਮੇਟੀ ਜੋ JavaScript ਭਾਸ਼ਾ ਵਿੱਚ ਪ੍ਰਸਤਾਵਾਂ ਅਤੇ ਜੋੜਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦੀ ਹੈ), ਅਤੇ ECMAScript ਨਿਰਧਾਰਨ ਦੇ ਅਗਲੇ ਸੰਸਕਰਣ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀ ਜਾਵੇਗੀ। ਇਹ ਪਹਿਲਾਂ ਹੀ ਕਈ ਬ੍ਰਾਊਜ਼ਰਾਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਜਾ ਚੁੱਕਾ ਹੈ: ਕ੍ਰੋਮ 144+ ਅਤੇ ਫਾਇਰਫਾਕਸ 139+, ਸਫਾਰੀ ਦੇ ਨਾਲ ਜਲਦੀ ਹੀ ਇਸ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਉਮੀਦ ਹੈ। ਇੱਕ ਪੌਲੀਫਿਲ ਅਸਮਰਥਿਤ ਬ੍ਰਾਊਜ਼ਰਾਂ ਅਤੇ Node.js ਲਈ ਵੀ ਉਪਲਬਧ ਹੈ। ਟੈਂਪੋਰਲ API ਵਸਤੂਆਂ ਬਣਾਉਂਦਾ ਹੈ ਜੋ, ਆਮ ਤੌਰ 'ਤੇ, ਸਮੇਂ ਦੇ ਪਲਾਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ। ਇਹ ਦਿੱਤੇ ਗਏ ਸਮਾਂ ਖੇਤਰ ਵਿੱਚ ਫੁੱਲ-ਟਾਈਮ ਅਤੇ ਮਿਤੀ ਸਟੈਂਪ ਹੋ ਸਕਦੇ ਹਨ, ਜਾਂ ਇਹ ਬਿਨਾਂ ਕਿਸੇ ਸਮਾਂ ਖੇਤਰ ਜਾਂ ਮਿਤੀ ਦੀ ਜਾਣਕਾਰੀ ਦੇ "ਕੰਧ ਘੜੀ" ਸਮੇਂ ਦੀ ਇੱਕ ਆਮ ਉਦਾਹਰਣ ਹੋ ਸਕਦੀ ਹੈ। ਟੈਂਪੋਰਲ ਦੀਆਂ ਕੁਝ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:
ਮਿਤੀਆਂ ਦੇ ਨਾਲ ਜਾਂ ਬਿਨਾਂ ਸਮਾਂ। ਇੱਕ ਅਸਥਾਈ ਵਸਤੂ ਕਿਸੇ ਖਾਸ ਮਿਤੀ 'ਤੇ ਇੱਕ ਖਾਸ ਸਮੇਂ ਨੂੰ, ਜਾਂ ਕਿਸੇ ਮਿਤੀ ਦੀ ਜਾਣਕਾਰੀ ਤੋਂ ਬਿਨਾਂ ਸਮਾਂ ਦਰਸਾਉਂਦੀ ਹੈ। ਇੱਕ ਖਾਸ ਮਿਤੀ, ਬਿਨਾਂ ਸਮੇਂ ਦੇ, ਨੂੰ ਵੀ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਟਾਈਮ ਜ਼ੋਨ ਸਪੋਰਟ। ਟੈਂਪੋਰਲ ਆਬਜੈਕਟ ਪੂਰੀ ਤਰ੍ਹਾਂ ਟਾਈਮ ਜ਼ੋਨ ਜਾਣੂ ਹੁੰਦੇ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਸਮਾਂ ਖੇਤਰਾਂ ਵਿੱਚ ਬਦਲੇ ਜਾ ਸਕਦੇ ਹਨ। ਮੋਮੈਂਟ ਟਾਈਮ ਜ਼ੋਨ ਦਾ ਵੀ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਪਰ ਇਸ ਲਈ ਵਾਧੂ ਪਲ-ਟਾਈਮ ਜ਼ੋਨ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਅਟੱਲਤਾ. ਇੱਕ ਵਾਰ ਇੱਕ ਅਸਥਾਈ ਵਸਤੂ ਬਣ ਜਾਂਦੀ ਹੈ, ਇਸਨੂੰ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ। ਸਮਾਂ ਗਣਿਤ ਜਾਂ ਸਮਾਂ ਖੇਤਰ ਪਰਿਵਰਤਨ ਅੰਡਰਲਾਈੰਗ ਆਬਜੈਕਟ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਨਹੀਂ ਕਰਦੇ ਹਨ। ਇਸ ਦੀ ਬਜਾਏ, ਉਹ ਇੱਕ ਨਵਾਂ ਟੈਂਪੋਰਲ ਆਬਜੈਕਟ ਤਿਆਰ ਕਰਦੇ ਹਨ। 1-ਅਧਾਰਿਤ ਇੰਡੈਕਸਿੰਗ। ਮਿਤੀ API (ਨਾਲ ਹੀ ਮੋਮੈਂਟ ਦੇ ਨਾਲ) ਨਾਲ ਬੱਗਾਂ ਦਾ ਇੱਕ ਆਮ ਸਰੋਤ ਇਹ ਹੈ ਕਿ ਮਹੀਨੇ ਜ਼ੀਰੋ-ਇੰਡੈਕਸ ਕੀਤੇ ਗਏ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਜਨਵਰੀ 0 ਮਹੀਨਾ ਹੈ, ਨਾ ਕਿ ਮਹੀਨਾ 1 ਦੀ ਬਜਾਏ ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਸਾਰੇ ਅਸਲ ਜੀਵਨ ਵਿੱਚ ਸਮਝਦੇ ਹਾਂ। ਟੈਂਪੋਰਲ 1-ਅਧਾਰਿਤ ਇੰਡੈਕਸਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਠੀਕ ਕਰਦਾ ਹੈ — ਜਨਵਰੀ 1 ਮਹੀਨਾ ਹੈ। ਇਹ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਕਿਉਂਕਿ ਟੈਂਪੋਰਲ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੀ ਇੱਕ API ਹੈ, ਇਹ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਬੰਡਲ ਆਕਾਰ ਵਿੱਚ ਕੁਝ ਨਹੀਂ ਜੋੜਦਾ ਹੈ।
ਇਹ ਨੋਟ ਕਰਨਾ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਮਿਤੀ API ਖਤਮ ਨਹੀਂ ਹੋ ਰਿਹਾ ਹੈ। ਜਦੋਂ ਕਿ ਟੈਂਪੋਰਲ ਇਸ API ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ, ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾਂ ਬਰਤਰਫ਼ ਨਹੀਂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ। ਜੇਕਰ ਬ੍ਰਾਊਜ਼ਰ ਨੇ ਅਚਾਨਕ ਮਿਤੀ API ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਤਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਟੁੱਟ ਜਾਣਗੀਆਂ। ਹਾਲਾਂਕਿ, ਇਹ ਵੀ ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ ਕਿ ਮੋਮੈਂਟ ਨੂੰ ਹੁਣ ਰੱਖ-ਰਖਾਅ ਮੋਡ ਵਿੱਚ ਇੱਕ ਵਿਰਾਸਤੀ ਪ੍ਰੋਜੈਕਟ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਬਾਕੀ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਮੋਮੈਂਟ-ਅਧਾਰਿਤ ਕੋਡ ਨੂੰ ਨਵੇਂ ਟੈਂਪੋਰਲ API ਵਿੱਚ ਮਾਈਗਰੇਟ ਕਰਨ ਲਈ ਕੁਝ "ਪਕਵਾਨਾਂ" ਨੂੰ ਦੇਖਾਂਗੇ। ਆਉ ਰੀਫੈਕਟਰਿੰਗ ਸ਼ੁਰੂ ਕਰੀਏ! ਮਿਤੀ ਅਤੇ ਸਮਾਂ ਆਬਜੈਕਟ ਬਣਾਉਣਾ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਤਾਰੀਖਾਂ ਅਤੇ ਸਮਿਆਂ ਵਿੱਚ ਹੇਰਾਫੇਰੀ ਕਰ ਸਕੀਏ, ਸਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਵਸਤੂਆਂ ਬਣਾਉਣੀਆਂ ਪੈਣਗੀਆਂ। ਮੌਜੂਦਾ ਮਿਤੀ ਅਤੇ ਸਮੇਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਇੱਕ ਮੋਮੈਂਟ ਵਸਤੂ ਬਣਾਉਣ ਲਈ, ਮੋਮੈਂਟ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ। const now = ਪਲ(); console.log(ਹੁਣ); // ਪਲ<2026-02-18T21:26:29-05:00>
ਇਸ ਵਸਤੂ ਨੂੰ ਹੁਣ ਲੋੜ ਅਨੁਸਾਰ ਫਾਰਮੈਟ ਜਾਂ ਹੇਰਾਫੇਰੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
// UTC ਵਿੱਚ ਬਦਲੋ //ਚੇਤਾਵਨੀ: ਇਹ ਮੋਮੈਂਟ ਆਬਜੈਕਟ ਨੂੰ ਬਦਲਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ UTC ਮੋਡ ਵਿੱਚ ਰੱਖਦਾ ਹੈ! console.log(now.utc()); // ਪਲ<2026-02-19T02:26:29Z>
// ਇੱਕ ਫਾਰਮੈਟ ਕੀਤੀ ਸਤਰ ਨੂੰ ਛਾਪੋ - ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਹੁਣ UTC ਸਮਾਂ ਵਰਤ ਰਿਹਾ ਹੈ console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // 02/19/2026 02:27:07 ਵਜੇ
ਮੋਮੈਂਟ ਬਾਰੇ ਯਾਦ ਰੱਖਣ ਵਾਲੀ ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਇੱਕ ਮੋਮੈਂਟ ਆਬਜੈਕਟ ਵਿੱਚ ਹਮੇਸ਼ਾਂ ਸਮੇਂ ਅਤੇ ਮਿਤੀ ਬਾਰੇ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਸਮੇਂ ਦੀ ਜਾਣਕਾਰੀ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਠੀਕ ਹੈ, ਪਰ ਇਹ ਡੇਲਾਈਟ ਸੇਵਿੰਗ ਟਾਈਮ ਜਾਂ ਲੀਪ ਸਾਲਾਂ ਵਰਗੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਅਚਾਨਕ ਵਿਵਹਾਰ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਮਿਤੀ ਸਮੇਂ ਦੀ ਗਣਨਾ 'ਤੇ ਪ੍ਰਭਾਵ ਪਾ ਸਕਦੀ ਹੈ। ਟੈਂਪੋਰਲ ਵਧੇਰੇ ਲਚਕਦਾਰ ਹੈ। ਤੁਸੀਂ ਇੱਕ Temporal.Instant ਆਬਜੈਕਟ ਬਣਾ ਕੇ ਮੌਜੂਦਾ ਮਿਤੀ ਅਤੇ ਸਮੇਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਇੱਕ ਵਸਤੂ ਬਣਾ ਸਕਦੇ ਹੋ। ਇਹ "ਯੁਗ" (1 ਜਨਵਰੀ, 1970 ਨੂੰ ਅੱਧੀ ਰਾਤ UTC) ਤੋਂ ਬਾਅਦ ਦੇ ਸਮੇਂ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਸਮੇਂ ਦੇ ਇੱਕ ਬਿੰਦੂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਟੈਂਪੋਰਲ ਨੈਨੋਸਕਿੰਡ-ਪੱਧਰ ਦੀ ਸ਼ੁੱਧਤਾ ਦੇ ਨਾਲ ਸਮੇਂ ਵਿੱਚ ਇਸ ਤਤਕਾਲ ਦਾ ਹਵਾਲਾ ਦੇ ਸਕਦਾ ਹੈ। const now = Temporal.Now.instant();
// ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਕੱਚੇ ਨੈਨੋਸਕਿੰਡ ਵੇਖੋ console.log(now.epochNanoseconds); // 1771466342612000000ਐਨ
// UTC ਲਈ ਫਾਰਮੈਟ console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// ਕਿਸੇ ਖਾਸ ਸਮਾਂ ਖੇਤਰ ਲਈ ਫਾਰਮੈਟ console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
ਟੈਂਪੋਰਲ. ਫੌਰਮ ਸਟੈਟਿਕ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਖਾਸ ਸਮੇਂ ਅਤੇ ਮਿਤੀ ਲਈ ਤਤਕਾਲ ਵਸਤੂਆਂ ਵੀ ਬਣਾਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ।
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// ਸਥਾਨਕ ਸਮਾਂ ਜ਼ੋਨ ਵਿੱਚ ਤੁਰੰਤ ਫਾਰਮੈਟ ਕਰੋ। ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਸਿਰਫ਼ ਕੰਟਰੋਲ ਕਰਦਾ ਹੈ // ਫਾਰਮੈਟਿੰਗ - ਇਹ ਆਬਜੈਕਟ ਨੂੰ ਬਦਲਦਾ ਨਹੀਂ ਹੈ ਜਿਵੇਂ moment.utc ਕਰਦਾ ਹੈ। console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
ਤੁਸੀਂ ਹੋਰ ਕਿਸਮ ਦੀਆਂ ਅਸਥਾਈ ਵਸਤੂਆਂ ਵੀ ਬਣਾ ਸਕਦੇ ਹੋ, ਜਿਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:
Temporal.PlainDate: ਇੱਕ ਮਿਤੀ ਜਿਸ ਵਿੱਚ ਸਮੇਂ ਦੀ ਕੋਈ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੈ। Temporal.PlainTime: ਕੋਈ ਮਿਤੀ ਜਾਣਕਾਰੀ ਵਾਲਾ ਸਮਾਂ। Temporal.ZonedDateTime: ਇੱਕ ਖਾਸ ਸਮਾਂ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਮਿਤੀ ਅਤੇ ਸਮਾਂ।
ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਵਿੱਚ ਇੱਕ ਤੋਂ ਵਿਧੀ ਹੈ ਜਿਸਨੂੰ ਮਿਤੀ ਅਤੇ/ਜਾਂ ਸਮਾਂ, ਜਾਂ ਪਾਰਸ ਕਰਨ ਲਈ ਇੱਕ ਮਿਤੀ ਸਤਰ ਨੂੰ ਦਰਸਾਉਂਦੀ ਇੱਕ ਵਸਤੂ ਨਾਲ ਬੁਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। // ਸਿਰਫ਼ ਇੱਕ ਤਾਰੀਖ const today = Temporal.PlainDate.from({ ਸਾਲ: 2026, ਮਹੀਨਾ: 2, // ਨੋਟ ਕਰੋ ਕਿ ਅਸੀਂ ਫਰਵਰੀ ਲਈ 2 ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ ਦਿਨ: 18 }); console.log(today.toString()); // 2026-02-18
// ਬਸ ਇੱਕ ਵਾਰ const lunchTime = Temporal.PlainTime.from({ ਘੰਟਾ: 12 }); console.log(lunchTime.toString()); // 12:00:00
// ਅਮਰੀਕਾ ਦੇ ਪੂਰਬੀ ਸਮਾਂ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਮਿਤੀ ਅਤੇ ਸਮਾਂ const dueAt = Temporal.ZonedDateTime.from({ ਟਾਈਮ ਜ਼ੋਨ: 'ਅਮਰੀਕਾ/ਨਿਊਯਾਰਕ', ਸਾਲ: 2026, ਮਹੀਨਾ: 3, ਦਿਨ: 1, ਘੰਟਾ: 12, ਮਿੰਟ: 0, ਦੂਜਾ: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[ਅਮਰੀਕਾ/ਨਿਊਯਾਰਕ]
ਪਾਰਸਿੰਗ ਅਸੀਂ ਮਿਤੀ ਅਤੇ ਸਮੇਂ ਦੀ ਜਾਣਕਾਰੀ ਦੇ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਰਚਨਾ ਨੂੰ ਕਵਰ ਕੀਤਾ ਹੈ। ਆਓ ਹੁਣ ਪਾਰਸਿੰਗ ਨੂੰ ਵੇਖੀਏ. ਪਾਰਸਿੰਗ ਇੱਕ ਅਜਿਹਾ ਖੇਤਰ ਹੈ ਜਿੱਥੇ ਮੋਮੈਂਟ ਬਿਲਟ-ਇਨ ਟੈਂਪੋਰਲ API ਨਾਲੋਂ ਵਧੇਰੇ ਲਚਕਦਾਰ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਮਿਤੀ ਸਤਰ ਨੂੰ ਪਲ ਫੰਕਸ਼ਨ ਵਿੱਚ ਪਾਸ ਕਰਕੇ ਪਾਰਸ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਕ ਇੱਕਲੇ ਆਰਗੂਮੈਂਟ ਦੇ ਨਾਲ, ਮੋਮੈਂਟ ਇੱਕ ISO ਮਿਤੀ ਸਤਰ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਵਿਕਲਪਿਕ ਫਾਰਮੈਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜੇਕਰ ਤੁਸੀਂ ਵਰਤੇ ਜਾ ਰਹੇ ਮਿਤੀ ਫਾਰਮੈਟ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹੋਏ ਇੱਕ ਦੂਜੀ ਦਲੀਲ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋ।
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // ਪਲ<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // ਪਲ<2026-02-21T09:00:00-05:00>
ਪੁਰਾਣੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ, ਮੋਮੈਂਟ ਕਿਸੇ ਵੀ ਮਨਮਰਜ਼ੀ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤੀ ਮਿਤੀ ਸਤਰ ਨੂੰ ਪਾਰਸ ਕਰਨ ਲਈ ਇੱਕ ਵਧੀਆ ਅੰਦਾਜ਼ਾ ਲਗਾਏਗਾ। ਇਸ ਨਾਲ ਅਣਪਛਾਤੇ ਨਤੀਜੇ ਨਿਕਲ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, 02-03-2026 ਫਰਵਰੀ 2 ਜਾਂ 3 ਮਾਰਚ ਹੈ? ਇਸ ਕਾਰਨ ਕਰਕੇ, ਮੋਮੈਂਟ ਦੇ ਨਵੇਂ ਸੰਸਕਰਣ ਇੱਕ ਪ੍ਰਮੁੱਖ ਬਰਤਰਫ਼ ਚੇਤਾਵਨੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਹਨ ਜੇਕਰ ਇਸਨੂੰ ISO ਫਾਰਮੈਟਡ ਮਿਤੀ ਸਤਰ ਤੋਂ ਬਿਨਾਂ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ (ਜਦੋਂ ਤੱਕ ਕਿ ਲੋੜੀਂਦੇ ਫਾਰਮੈਟ ਨਾਲ ਦੂਜੀ ਦਲੀਲ ਵੀ ਨਹੀਂ ਦਿੱਤੀ ਜਾਂਦੀ)। ਟੈਂਪੋਰਲ ਸਿਰਫ਼ ਖਾਸ ਤੌਰ 'ਤੇ ਫਾਰਮੈਟ ਕੀਤੀ ਮਿਤੀ ਸਤਰ ਨੂੰ ਪਾਰਸ ਕਰੇਗਾ। ਸਤਰ ISO 8601 ਫਾਰਮੈਟ ਜਾਂ ਇਸਦੇ ਐਕਸਟੈਂਸ਼ਨ, RFC 9557 ਦੇ ਅਨੁਕੂਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਜੇਕਰ ਇੱਕ ਗੈਰ-ਅਨੁਕੂਲ ਮਿਤੀ ਸਤਰ ਨੂੰ ਇੱਕ ਤੋਂ ਵਿਧੀ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਟੈਂਪੋਰਲ ਇੱਕ RangeError ਸੁੱਟ ਦੇਵੇਗਾ।
// ਇੱਕ RFC 9557 ਮਿਤੀ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[ਅਮਰੀਕਾ/ਨਿਊ_ਯਾਰਕ]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// ਇੱਕ ਅਣਜਾਣ ਮਿਤੀ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: ਅਸਥਾਈ ਗਲਤੀ: ਸਾਲ ਦੇ ਮੁੱਲ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੌਰਾਨ ਅਵੈਧ ਅੱਖਰ।
ਮਿਤੀ ਸਤਰ ਦੀਆਂ ਸਹੀ ਲੋੜਾਂ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ ਕਿ ਤੁਸੀਂ ਕਿਸ ਕਿਸਮ ਦੀ ਟੈਂਪੋਰਲ ਵਸਤੂ ਬਣਾ ਰਹੇ ਹੋ। ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, Temporal.Instant ਨੂੰ ਇੱਕ ਪੂਰੇ ISO ਦੀ ਲੋੜ ਹੈ8601 ਜਾਂ RFC 9557 ਮਿਤੀ ਸਤਰ ਜੋ ਸਮਾਂ ਜ਼ੋਨ ਆਫਸੈੱਟ ਦੇ ਨਾਲ ਮਿਤੀ ਅਤੇ ਸਮਾਂ ਦਰਸਾਉਂਦੀ ਹੈ, ਪਰ ਤੁਸੀਂ ਮਿਤੀ ਫਾਰਮੈਟ ਦੇ ਸਿਰਫ਼ ਇੱਕ ਸਬਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਲੇਨਡੇਟ ਜਾਂ ਪਲੇਨਟਾਈਮ ਆਬਜੈਕਟ ਵੀ ਬਣਾ ਸਕਦੇ ਹੋ। const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
ਨੋਟ ਕਰੋ ਕਿ ਇਹਨਾਂ ਸਤਰਾਂ ਨੂੰ ਅਜੇ ਵੀ ਸੰਭਾਵਿਤ ਫਾਰਮੈਟ ਦੀ ਪਾਲਣਾ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਨਹੀਂ ਤਾਂ ਇੱਕ ਤਰੁੱਟੀ ਸੁੱਟ ਦਿੱਤੀ ਜਾਵੇਗੀ।
// ਇੱਕ ਗੈਰ-ਅਨੁਕੂਲ ਸਮਾਂ ਸਤਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ. ਇਹ ਸਭ ਇੱਕ RangeError ਸੁੱਟ ਦੇਣਗੇ। Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
ਪ੍ਰੋ ਟਿਪ: ਗੈਰ-ISO ਸਟ੍ਰਿੰਗਸ ਨੂੰ ਸੰਭਾਲਣਾ ਕਿਉਂਕਿ ਟੈਂਪੋਰਲ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ, ਇਹ 02-01-2026 ਵਰਗੇ ਸਟ੍ਰਿੰਗ ਦੇ ਫਾਰਮੈਟ ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰੇਗਾ। ਜੇਕਰ ਤੁਹਾਡਾ ਡਾਟਾ ਸ੍ਰੋਤ ਅਜਿਹੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਟੈਂਪੋਰਲ ਨਾਲ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ 2026-02-01 ਵਰਗੇ ISO ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਮੁੜ ਵਿਵਸਥਿਤ ਕਰਨ ਲਈ ਕੁਝ ਸਟ੍ਰਿੰਗ ਹੇਰਾਫੇਰੀ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ।
ਫਾਰਮੈਟਿੰਗ ਇੱਕ ਵਾਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਮੋਮੈਂਟ ਜਾਂ ਟੈਂਪੋਰਲ ਆਬਜੈਕਟ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਸ਼ਾਇਦ ਕਿਸੇ ਸਮੇਂ ਇਸਨੂੰ ਇੱਕ ਫਾਰਮੈਟ ਕੀਤੀ ਸਤਰ ਵਿੱਚ ਬਦਲਣਾ ਚਾਹੋਗੇ। ਇਹ ਇੱਕ ਅਜਿਹਾ ਉਦਾਹਰਨ ਹੈ ਜਿੱਥੇ ਮੋਮੈਂਟ ਥੋੜਾ ਹੋਰ ਤਿੱਖਾ ਹੁੰਦਾ ਹੈ। ਤੁਸੀਂ ਆਬਜੈਕਟ ਦੇ ਫਾਰਮੈਟ ਵਿਧੀ ਨੂੰ ਟੋਕਨਾਂ ਦੀ ਇੱਕ ਸਤਰ ਨਾਲ ਕਾਲ ਕਰਦੇ ਹੋ ਜੋ ਲੋੜੀਂਦੀ ਮਿਤੀ ਫਾਰਮੈਟ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ। const date = moment();
console.log(date.format('MM/DD/YYYY')); // 02/22/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 22 ਫਰਵਰੀ 2026, ਰਾਤ 8:18:30 ਵਜੇ
ਦੂਜੇ ਪਾਸੇ, ਟੈਂਪੋਰਲ ਲਈ ਤੁਹਾਨੂੰ ਥੋੜਾ ਹੋਰ ਵਰਬੋਸ ਹੋਣ ਦੀ ਲੋੜ ਹੈ। ਅਸਥਾਈ ਵਸਤੂਆਂ, ਜਿਵੇਂ ਕਿ ਤਤਕਾਲ, ਕੋਲ ਇੱਕ toLocaleString ਵਿਧੀ ਹੈ ਜੋ ਕਿਸੇ ਵਸਤੂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਜੋਂ ਦਰਸਾਏ ਗਏ ਵੱਖ-ਵੱਖ ਫਾਰਮੈਟਿੰਗ ਵਿਕਲਪਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੀ ਹੈ।
const date = Temporal.Now.instant();
// ਬਿਨਾਂ ਕਿਸੇ ਆਰਗੂਮੈਂਟ ਦੇ, ਅਸੀਂ ਮੌਜੂਦਾ ਲੋਕੇਲ ਲਈ ਡਿਫੌਲਟ ਫਾਰਮੈਟ ਪ੍ਰਾਪਤ ਕਰਾਂਗੇ console.log(date.toLocaleString()); // 2/22/2026, 8:23:36 PM (en-US ਦਾ ਲੋਕੇਲ ਮੰਨ ਕੇ)
// ਇੱਕ ਕਸਟਮ ਫਾਰਮੈਟ ਸਤਰ ਬਣਾਉਣ ਲਈ ਫਾਰਮੈਟਿੰਗ ਵਿਕਲਪ ਪਾਸ ਕਰੋ console.log(date.toLocaleString('en-US', { ਮਹੀਨਾ: 'ਲੰਬਾ', ਦਿਨ: 'ਸੰਖਿਆਤਮਕ', ਸਾਲ: 'ਸੰਖਿਆਤਮਕ', ਘੰਟਾ: '2-ਅੰਕ', ਮਿੰਟ: '2-ਅੰਕ' })); // 22 ਫਰਵਰੀ, 2026 ਨੂੰ ਰਾਤ 8:23 ਵਜੇ
// ਸਿਰਫ ਉਹਨਾਂ ਖੇਤਰਾਂ ਨੂੰ ਪਾਸ ਕਰੋ ਜੋ ਤੁਸੀਂ ਫਾਰਮੈਟ ਸਤਰ ਵਿੱਚ ਚਾਹੁੰਦੇ ਹੋ console.log(date.toLocaleString('en-US', { ਮਹੀਨਾ: 'ਛੋਟਾ', ਦਿਨ: 'ਸੰਖਿਆਤਮਕ' })); // 22 ਫਰਵਰੀ
ਅਸਥਾਈ ਮਿਤੀ ਫਾਰਮੈਟਿੰਗ ਅਸਲ ਵਿੱਚ ਹੁੱਡ ਦੇ ਹੇਠਾਂ Intl.DateTimeFormat API (ਜੋ ਕਿ ਆਧੁਨਿਕ ਬ੍ਰਾਉਜ਼ਰਾਂ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਆਸਾਨੀ ਨਾਲ ਉਪਲਬਧ ਹੈ) ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਕਸਟਮ ਫਾਰਮੈਟਿੰਗ ਵਿਕਲਪਾਂ ਨਾਲ ਇੱਕ ਮੁੜ ਵਰਤੋਂ ਯੋਗ DateTimeFormat ਆਬਜੈਕਟ ਬਣਾ ਸਕਦੇ ਹੋ, ਫਿਰ ਟੈਂਪੋਰਲ ਆਬਜੈਕਟ ਨੂੰ ਇਸਦੇ ਫਾਰਮੈਟ ਵਿਧੀ ਵਿੱਚ ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ। ਇਸਦੇ ਕਾਰਨ, ਇਹ ਕਸਟਮ ਮਿਤੀ ਫਾਰਮੈਟਾਂ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਜਿਵੇਂ ਮੋਮੈਂਟ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ 'Q1 2026' ਜਾਂ ਹੋਰ ਵਿਸ਼ੇਸ਼ ਫਾਰਮੈਟਿੰਗ ਵਰਗੀ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਕੁਝ ਕਸਟਮ ਮਿਤੀ ਫਾਰਮੈਟਿੰਗ ਕੋਡ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ ਜਾਂ ਕਿਸੇ ਤੀਜੀ-ਧਿਰ ਲਾਇਬ੍ਰੇਰੀ ਤੱਕ ਪਹੁੰਚੋ। const formatter = ਨਵਾਂ Intl.DateTimeFormat('en-US', { ਮਹੀਨਾ: '2-ਅੰਕ', ਦਿਨ: '2-ਅੰਕ', ਸਾਲ: 'ਸੰਖਿਆਤਮਕ' });
const date = Temporal.Now.instant(); console.log(formatter.format(date)); // 02/22/2026
ਮੋਮੈਂਟ ਦੇ ਫਾਰਮੈਟਿੰਗ ਟੋਕਨ ਲਿਖਣ ਲਈ ਸਰਲ ਹਨ, ਪਰ ਉਹ ਲੋਕੇਲ-ਅਨੁਕੂਲ ਨਹੀਂ ਹਨ। ਫਾਰਮੈਟ ਸਤਰ "ਹਾਰਡ ਕੋਡ" ਚੀਜ਼ਾਂ ਜਿਵੇਂ ਮਹੀਨਾ/ਦਿਨ ਕ੍ਰਮ। ਇੱਕ ਕੌਂਫਿਗਰੇਸ਼ਨ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫਾਇਦਾ, ਜਿਵੇਂ ਕਿ ਟੈਂਪੋਰਲ ਕਰਦਾ ਹੈ, ਇਹ ਹੈ ਕਿ ਇਹ ਆਪਣੇ ਆਪ ਹੀ ਕਿਸੇ ਵੀ ਲੋਕੇਲ ਲਈ ਅਨੁਕੂਲ ਹੋ ਜਾਵੇਗਾ ਅਤੇ ਸਹੀ ਫਾਰਮੈਟ ਦੀ ਵਰਤੋਂ ਕਰੇਗਾ। const date = Temporal.Now.instant();
const formatOptions = { ਮਹੀਨਾ: 'ਸੰਖਿਆਤਮਕ', ਦਿਨ: 'ਸੰਖਿਆਤਮਕ', ਸਾਲ: 'ਸੰਖਿਆਤਮਕ' };
console.log(date.toLocaleString('en-US', formatOptions)); // 2/22/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
ਮਿਤੀ ਗਣਨਾ ਬਹੁਤ ਸਾਰੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਇੱਕ ਮਿਤੀ 'ਤੇ ਕੁਝ ਗਣਨਾਵਾਂ ਕਰਨ ਦੀ ਲੋੜ ਪਵੇਗੀ। ਤੁਸੀਂ ਸਮੇਂ ਦੀਆਂ ਇਕਾਈਆਂ (ਦਿਨ, ਘੰਟੇ, ਸਕਿੰਟ, ਆਦਿ) ਨੂੰ ਜੋੜਨਾ ਜਾਂ ਘਟਾਉਣਾ ਚਾਹ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਮੌਜੂਦਾ ਮਿਤੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਉਪਭੋਗਤਾ ਨੂੰ ਹੁਣ ਤੋਂ 1 ਹਫ਼ਤੇ ਦੀ ਮਿਤੀ ਦਿਖਾਉਣਾ ਚਾਹ ਸਕਦੇ ਹੋ। ਮੋਮੈਂਟ ਆਬਜੈਕਟ ਵਿੱਚ ਜੋੜ ਅਤੇ ਘਟਾਓ ਵਰਗੀਆਂ ਵਿਧੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਇਹ ਕਾਰਵਾਈਆਂ ਕਰਦੀਆਂ ਹਨ। ਇਹ ਫੰਕਸ਼ਨ ਇੱਕ ਮੁੱਲ ਅਤੇ ਇੱਕ ਯੂਨਿਟ ਲੈਂਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ: add(7, 'days')। ਮੋਮੈਂਟ ਅਤੇ ਟੈਂਪੋਰਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਮਹੱਤਵਪੂਰਨ ਅੰਤਰ, ਹਾਲਾਂਕਿ, ਇਹ ਹੈ ਕਿ ਜਦੋਂ ਇਹਨਾਂ ਤਾਰੀਖਾਂ ਦੀ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਅੰਡਰਲਾਈੰਗ ਵਸਤੂ ਨੂੰ ਸੋਧਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸਦਾ ਅਸਲ ਮੁੱਲ ਗੁਆਚ ਜਾਂਦਾ ਹੈ। const now = ਪਲ();
console.log(ਹੁਣ); // ਪਲ<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'ਦਿਨ'); console.log(ਅਗਲੇ ਹਫਤੇ); // ਪਲ<2026-03-03T20:08:36-05:00>
// ਗੋਚਾ - ਅਸਲੀ ਵਸਤੂ ਨੂੰ ਪਰਿਵਰਤਿਤ ਕੀਤਾ ਗਿਆ ਸੀ console.log(ਹੁਣ); // ਪਲ<2026-03-03T20:08:36-05:00>
ਅਸਲੀ ਤਾਰੀਖ ਨੂੰ ਗੁਆਉਣ ਤੋਂ ਬਚਣ ਲਈ, ਤੁਸੀਂ ਇੱਕ ਕਾਪੀ ਬਣਾਉਣ ਲਈ ਮੋਮੈਂਟ ਆਬਜੈਕਟ 'ਤੇ ਕਲੋਨ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ। const ਹੁਣ= ਪਲ(); const nextWeek = now.clone().add(7, 'days');
console.log(ਹੁਣ); // ਪਲ<2026-02-24T20:12:55-05:00>
console.log(ਅਗਲੇ ਹਫਤੇ); // ਪਲ<2026-03-03T20:12:55-05:00>
ਦੂਜੇ ਪਾਸੇ, ਅਸਥਾਈ ਵਸਤੂਆਂ ਅਟੱਲ ਹਨ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਤਤਕਾਲ, ਪਲੇਨਡੇਟ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਇੱਕ ਵਸਤੂ ਬਣਾ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਉਸ ਵਸਤੂ ਦਾ ਮੁੱਲ ਕਦੇ ਨਹੀਂ ਬਦਲੇਗਾ। ਅਸਥਾਈ ਵਸਤੂਆਂ ਵਿੱਚ ਜੋੜ ਅਤੇ ਘਟਾਓ ਦੇ ਢੰਗ ਵੀ ਹੁੰਦੇ ਹਨ। ਟੈਂਪੋਰਲ ਥੋੜਾ ਜਿਹਾ ਚੁਸਤ ਹੈ ਕਿ ਕਿਹੜੀਆਂ ਸਮਾਂ ਇਕਾਈਆਂ ਕਿਹੜੀਆਂ ਵਸਤੂਆਂ ਦੀਆਂ ਕਿਸਮਾਂ ਵਿੱਚ ਜੋੜੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇੱਕ ਤਤਕਾਲ ਵਿੱਚ ਦਿਨ ਨਹੀਂ ਜੋੜ ਸਕਦੇ ਹੋ:
const now = Temporal.Now.instant(); const nextWeek = now.add({ ਦਿਨ: 7 }); // RangeError: ਅਸਥਾਈ ਗਲਤੀ: ਸਭ ਤੋਂ ਵੱਡੀ ਇਕਾਈ ਤਾਰੀਖ ਦੀ ਇਕਾਈ ਨਹੀਂ ਹੋ ਸਕਦੀ
ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਤਤਕਾਲ ਵਸਤੂਆਂ UTC ਵਿੱਚ ਸਮੇਂ ਦੇ ਇੱਕ ਖਾਸ ਬਿੰਦੂ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਅਤੇ ਕੈਲੰਡਰ-ਅਗਨੋਸਟਿਕ ਹੁੰਦੀਆਂ ਹਨ। ਕਿਉਂਕਿ ਇੱਕ ਦਿਨ ਦੀ ਲੰਬਾਈ ਟਾਈਮ ਜ਼ੋਨ ਨਿਯਮਾਂ ਜਿਵੇਂ ਕਿ ਡੇਲਾਈਟ ਸੇਵਿੰਗ ਟਾਈਮ ਦੇ ਆਧਾਰ 'ਤੇ ਬਦਲ ਸਕਦੀ ਹੈ, ਇਹ ਗਣਨਾ ਇੱਕ ਤਤਕਾਲ 'ਤੇ ਉਪਲਬਧ ਨਹੀਂ ਹੈ। ਹਾਲਾਂਕਿ, ਤੁਸੀਂ ਇਹ ਕਾਰਵਾਈ ਹੋਰ ਕਿਸਮ ਦੀਆਂ ਵਸਤੂਆਂ 'ਤੇ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਪਲੇਨਡੇਟ ਟਾਈਮ: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({ ਦਿਨ: 7 });
// ਨੋਟ ਕਰੋ ਕਿ ਅਸਲੀ ਪਲੇਨਡੇਟ ਟਾਈਮ ਕੋਈ ਬਦਲਿਆ ਨਹੀਂ ਹੈ console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
console.log(nextWeek.toLocaleString()); // 3/3/2026, 8:23:59 PM
ਤੁਸੀਂ ਇਹ ਵੀ ਗਣਨਾ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਦੋ ਪਲਾਂ ਜਾਂ ਅਸਥਾਈ ਵਸਤੂਆਂ ਵਿਚਕਾਰ ਕਿੰਨਾ ਸਮਾਂ ਹੈ। ਮੋਮੈਂਟ ਦੇ ਡਿਫ ਫੰਕਸ਼ਨ ਦੇ ਨਾਲ, ਤੁਹਾਨੂੰ ਗ੍ਰੈਨਿਊਲਿਟੀ ਲਈ ਇੱਕ ਯੂਨਿਟ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਨਹੀਂ ਤਾਂ ਇਹ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਅੰਤਰ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾ। const date1 = ਪਲ('2026-02-21T09:00:00'); const date2 = ਪਲ('2026-02-22T10:30:00');
console.log(date2.diff(date1)); // 91800000
console.log(date2.diff(date1, 'days')); // 1
ਇੱਕ ਟੈਂਪੋਰਲ ਆਬਜੈਕਟ ਨਾਲ ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਟੈਂਪੋਰਲ ਆਬਜੈਕਟ ਨੂੰ ਇਸਦੇ ਤੱਕ ਜਾਂ ਇਸ ਤੋਂ ਬਾਅਦ ਦੇ ਤਰੀਕਿਆਂ ਵਿੱਚ ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਸਮੇਂ ਦੇ ਅੰਤਰ ਬਾਰੇ ਜਾਣਕਾਰੀ ਰੱਖਣ ਵਾਲੀ ਇੱਕ Temporal.Duration ਵਸਤੂ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਮਿਆਦ ਆਬਜੈਕਟ ਵਿੱਚ ਅੰਤਰ ਦੇ ਹਰੇਕ ਹਿੱਸੇ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ, ਅਤੇ ਇਹ ਸਮੇਂ ਦੇ ਅੰਤਰ ਨੂੰ ਦਰਸਾਉਂਦੀ ਇੱਕ ISO 8601 ਮਿਆਦ ਸਤਰ ਵੀ ਤਿਆਰ ਕਰ ਸਕਦੀ ਹੈ।
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// ਸਭ ਤੋਂ ਵੱਡੀ ਯੂਨਿਟ ਦਰਸਾਉਣ ਲਈ ਸਮੇਂ ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਇਕਾਈ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ // ਮਿਆਦ ਦੀ ਗਣਨਾ ਵਿੱਚ const diff = date2.since(date1, { ਸਭ ਤੋਂ ਵੱਡੀ ਇਕਾਈ: 'ਦਿਨ' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 ਮਿਆਦ ਸਤਰ: 1 ਦਿਨ, 1 ਘੰਟਾ, 30 ਮਿੰਟ)
ਤਾਰੀਖਾਂ ਅਤੇ ਸਮੇਂ ਦੀ ਤੁਲਨਾ ਕਰਨਾ ਪਲ ਅਤੇ ਟੈਂਪੋਰਲ ਦੋਵੇਂ ਤੁਹਾਨੂੰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਤਾਰੀਖਾਂ ਅਤੇ ਸਮੇਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਦਿੰਦੇ ਹਨ ਕਿ ਕਿਹੜਾ ਦੂਜੇ ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ, ਪਰ API ਦੇ ਨਾਲ ਵੱਖੋ-ਵੱਖਰੇ ਤਰੀਕੇ ਅਪਣਾਓ। ਮੋਮੈਂਟ ਦੋ ਮੋਮੈਂਟ ਆਬਜੈਕਟ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ isBefore, isAfter, ਅਤੇ isSame ਵਰਗੀਆਂ ਵਿਧੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। const date1 = ਪਲ('2026-02-21T09:00:00'); const date2 = ਪਲ('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // ਸੱਚ
ਟੈਂਪੋਰਲ ਇੱਕੋ ਕਿਸਮ ਦੀਆਂ ਦੋ ਵਸਤੂਆਂ ਵਿਚਕਾਰ ਤੁਲਨਾ ਕਰਨ ਲਈ ਇੱਕ ਸਥਿਰ ਤੁਲਨਾ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ -1 ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਪਹਿਲੀ ਮਿਤੀ ਦੂਜੀ ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦੀ ਹੈ, 0 ਜੇਕਰ ਉਹ ਬਰਾਬਰ ਹਨ, ਜਾਂ 1 ਜੇਕਰ ਪਹਿਲੀ ਮਿਤੀ ਦੂਜੀ ਤੋਂ ਬਾਅਦ ਆਉਂਦੀ ਹੈ। ਨਿਮਨਲਿਖਤ ਉਦਾਹਰਨ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਦੋ ਪਲੇਨਡੇਟ ਆਬਜੈਕਟ ਦੀ ਤੁਲਨਾ ਕਿਵੇਂ ਕਰਨੀ ਹੈ। Temporal.PlainDate.compare ਲਈ ਦੋਵੇਂ ਆਰਗੂਮੈਂਟ ਪਲੇਨਡੇਟ ਆਬਜੈਕਟ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।
const date1 = Temporal.PlainDate.from({ ਸਾਲ: 2026, ਮਹੀਨਾ: 2, ਦਿਨ: 24}); const date2 = Temporal.PlainDate.from({ ਸਾਲ: 2026, ਮਹੀਨਾ: 3, ਦਿਨ: 24});
// date1 date2 ਤੋਂ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ, ਇਸ ਲਈ -1 console.log(Temporal.PlainDate.compare(date1, date2));
// ਗਲਤੀ ਜੇ ਅਸੀਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੀਆਂ ਦੋ ਵਸਤੂਆਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: ਅਸਥਾਈ ਗਲਤੀ: ਅਵੈਧ ਪਲੇਨਡੇਟ ਖੇਤਰ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ।
ਖਾਸ ਤੌਰ 'ਤੇ, ਇਹ ਸਮੇਂ-ਸਮੇਂ ਦੀਆਂ ਵਸਤੂਆਂ ਦੀ ਲੜੀ ਨੂੰ ਕਾਲਕ੍ਰਮ ਅਨੁਸਾਰ ਕ੍ਰਮਬੱਧ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। // Temporal.PlainDate ਵਸਤੂਆਂ ਦੀ ਇੱਕ ਐਰੇ const ਮਿਤੀਆਂ = [... ];
// ਤੁਲਨਾਕਾਰ ਫੰਕਸ਼ਨ ਦੇ ਤੌਰ 'ਤੇ Temporal.PlainDate.compare ਦੀ ਵਰਤੋਂ ਕਰੋ dates.sort(Temporal.PlainDate.compare);
ਸਮਾਂ ਖੇਤਰ ਪਰਿਵਰਤਨ ਕੋਰ ਮੋਮੈਂਟ ਲਾਇਬ੍ਰੇਰੀ ਟਾਈਮ ਜ਼ੋਨ ਪਰਿਵਰਤਨ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਇਸ ਕਾਰਜਸ਼ੀਲਤਾ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਪਲ-ਟਾਈਮ ਜ਼ੋਨ ਪੈਕੇਜ ਨੂੰ ਵੀ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਪੈਕੇਜ ਰੁੱਖ ਨੂੰ ਹਿਲਾਉਣ ਯੋਗ ਨਹੀਂ ਹੈ, ਅਤੇ ਇਸਲਈ ਤੁਹਾਡੇ ਬੰਡਲ ਦੇ ਆਕਾਰ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਵਾਧਾ ਕਰ ਸਕਦਾ ਹੈ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਪਲ-ਟਾਈਮ ਜ਼ੋਨ ਸਥਾਪਤ ਕਰ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ tz ਵਿਧੀ ਨਾਲ ਮੋਮੈਂਟ ਆਬਜੈਕਟ ਨੂੰ ਵੱਖ-ਵੱਖ ਸਮਾਂ ਖੇਤਰਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ। ਹੋਰ ਮੋਮੈਂਟ ਓਪਰੇਸ਼ਨਾਂ ਵਾਂਗ, ਇਹ ਅੰਡਰਲਾਈੰਗ ਨੂੰ ਬਦਲਦਾ ਹੈਵਸਤੂ। // ਅਮਰੀਕਾ ਦੇ ਪੂਰਬੀ ਸਮੇਂ ਨੂੰ ਮੰਨਣਾ const now = ਪਲ(); console.log(ਹੁਣ); // ਪਲ<2026-02-28T20:08:20-05:00>
// ਪ੍ਰਸ਼ਾਂਤ ਸਮੇਂ ਵਿੱਚ ਬਦਲੋ। // ਮੂਲ ਪੂਰਬੀ ਸਮਾਂ ਖਤਮ ਹੋ ਗਿਆ ਹੈ। now.tz('America/Los_Angeles'); console.log(ਹੁਣ); // ਪਲ<2026-02-28T17:08:20-08:00>
ਇੱਕ Temporal.ZonedDateTime ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਟਾਈਮ ਜ਼ੋਨ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਟੈਂਪੋਰਲ API ਵਿੱਚ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹਨਾਂ ਵਸਤੂਆਂ ਵਿੱਚ ਇੱਕ withTimeZone ਵਿਧੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ ਜੋ ਇੱਕ ਨਵਾਂ ZonedDateTime ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਸਮੇਂ ਵਿੱਚ ਉਸੇ ਪਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਪਰ ਨਿਰਧਾਰਤ ਸਮਾਂ ਖੇਤਰ ਵਿੱਚ। // ਦੁਬਾਰਾ, ਅਮਰੀਕਾ ਦੇ ਪੂਰਬੀ ਸਮੇਂ ਨੂੰ ਮੰਨਦੇ ਹੋਏ const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
// ਪ੍ਰਸ਼ਾਂਤ ਸਮੇਂ ਵਿੱਚ ਬਦਲੋ const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 2/28/2026, 5:12:02 PM PST
// ਮੂਲ ਵਸਤੂ ਅਟੱਲ ਰਹਿੰਦੀ ਹੈ console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
ਨੋਟ: toLocaleString ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਗਏ ਫਾਰਮੈਟ ਕੀਤੇ ਮੁੱਲ, ਜਿਵੇਂ ਕਿ ਨਾਮ ਤੋਂ ਭਾਵ ਹੈ, ਲੋਕੇਲ-ਨਿਰਭਰ ਹਨ। ਨਮੂਨਾ ਕੋਡ en-US ਲੋਕੇਲ ਵਿੱਚ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਇਸਲਈ ਫਾਰਮੈਟ ਇਸ ਤਰ੍ਹਾਂ ਹੈ: 2/28/2026, 5:12:02 PM PST। ਕਿਸੇ ਹੋਰ ਲੋਕੇਲ ਵਿੱਚ, ਇਹ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, en-GB ਲੋਕੇਲ ਵਿੱਚ, ਤੁਹਾਨੂੰ 28/2/2026, 17:12:02 GMT-8 ਵਰਗਾ ਕੁਝ ਮਿਲੇਗਾ। ਇੱਕ ਰੀਅਲ-ਵਰਲਡ ਰੀਫੈਕਟਰਿੰਗ ਮੰਨ ਲਓ ਕਿ ਅਸੀਂ ਸਮਾਂ ਜ਼ੋਨਾਂ ਵਿੱਚ ਇਵੈਂਟਾਂ ਨੂੰ ਤਹਿ ਕਰਨ ਲਈ ਇੱਕ ਐਪ ਬਣਾ ਰਹੇ ਹਾਂ। ਇਸ ਐਪ ਦਾ ਹਿੱਸਾ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ, getEventTimes, ਜੋ ਇੱਕ ISO 8601 ਸਟ੍ਰਿੰਗ ਲੈਂਦਾ ਹੈ ਜੋ ਇਵੈਂਟ ਦੇ ਸਮੇਂ ਅਤੇ ਮਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਇੱਕ ਸਥਾਨਕ ਸਮਾਂ ਖੇਤਰ, ਅਤੇ ਇੱਕ ਟੀਚਾ ਸਮਾਂ ਜ਼ੋਨ। ਫੰਕਸ਼ਨ ਦੋਵਾਂ ਟਾਈਮ ਜ਼ੋਨਾਂ ਵਿੱਚ ਇਵੈਂਟ ਲਈ ਫਾਰਮੈਟ ਕੀਤੇ ਸਮਾਂ ਅਤੇ ਮਿਤੀ ਸਤਰ ਬਣਾਉਂਦਾ ਹੈ। ਜੇਕਰ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਇੰਪੁੱਟ ਸਟ੍ਰਿੰਗ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਇੱਕ ਵੈਧ ਸਮਾਂ/ਤਾਰੀਖ ਸਤਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਗਲਤੀ ਸੁੱਟ ਦੇਵੇਗਾ। ਮੋਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇੱਥੇ ਅਸਲ ਲਾਗੂਕਰਨ ਹੈ (ਮੋਮੈਂਟ-ਟਾਈਮ ਜ਼ੋਨ ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਦੀ ਵੀ ਲੋੜ ਹੈ)।
'ਮੋਮੈਂਟ-ਟਾਈਮ ਜ਼ੋਨ' ਤੋਂ ਪਲ ਆਯਾਤ ਕਰੋ;
ਫੰਕਸ਼ਨ getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. ਉਪਭੋਗਤਾ ਦੇ ਸਮਾਂ ਖੇਤਰ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਪਲ ਬਣਾਓ const eventTime = moment.tz( inputString, moment.ISO_8601, // ਇੱਕ ISO 8601 ਸਤਰ ਦੀ ਉਮੀਦ ਕਰੋ ਸਹੀ, // ਸਖਤ ਪਾਰਸਿੰਗ userTimeZone );
// ਇੱਕ ਗਲਤੀ ਸੁੱਟੋ ਜੇਕਰ ਇਨਪੁਟਸਟ੍ਰਿੰਗ ਇੱਕ ਵੈਧ ਮਿਤੀ ਨੂੰ ਨਹੀਂ ਦਰਸਾਉਂਦੀ ਹੈ ਜੇਕਰ (!eventTime.isValid()) { ਨਵੀਂ ਗਲਤੀ ਸੁੱਟੋ ('ਅਵੈਧ ਮਿਤੀ/ਸਮਾਂ ਇਨਪੁਟ'); }
// 2. ਟੀਚੇ ਦੇ ਸਮੇਂ ਦੀ ਗਣਨਾ ਕਰੋ // ਕ੍ਰਿਟੀਕਲ: ਸਾਨੂੰ ਕਲੋਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਜਾਂ 'ਇਵੈਂਟ ਟਾਈਮ' ਹਮੇਸ਼ਾ ਲਈ ਬਦਲਦਾ ਹੈ! const targetTime = eventTime.clone().tz(targetTimeZone);
ਵਾਪਸੀ { ਸਥਾਨਕ: eventTime.format(timeFormat), ਟੀਚਾ: targetTime.format(timeFormat), }; }
const ਅਨੁਸੂਚੀ = getEventTimes ( '2026-03-05T15:00-05:00', 'ਅਮਰੀਕਾ/ਨਿਊਯਾਰਕ', 'ਯੂਰਪ/ਲੰਡਨ', );
console.log(schedule.local); // ਮਾਰਚ 5, 2026, ਸ਼ਾਮ 3:00:00 ਈ.ਐਸ.ਟੀ
console.log(schedule.target); // ਮਾਰਚ 5, 2026, 8:00:00 pm GMT
ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ISO 8601 ਦੇ ਇੱਕ ਸੰਭਾਵਿਤ ਮਿਤੀ ਫਾਰਮੈਟ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਜੋ ਮਦਦ ਨਾਲ ਮੋਮੈਂਟ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਅਸੀਂ ਸਖਤ ਪਾਰਸਿੰਗ ਦੀ ਵੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮੋਮੈਂਟ ਇੱਕ ਮਿਤੀ ਸਤਰ ਨਾਲ ਅਨੁਮਾਨ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰੇਗਾ ਜੋ ਫਾਰਮੈਟ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ। ਜੇਕਰ ਇੱਕ ਗੈਰ-ISO ਮਿਤੀ ਸਤਰ ਪਾਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਸਦਾ ਨਤੀਜਾ ਇੱਕ ਅਵੈਧ ਮਿਤੀ ਵਸਤੂ ਬਣ ਜਾਵੇਗਾ, ਅਤੇ ਅਸੀਂ ਇੱਕ ਗਲਤੀ ਸੁੱਟ ਦਿੰਦੇ ਹਾਂ। ਟੈਂਪੋਰਲ ਲਾਗੂਕਰਨ ਸਮਾਨ ਦਿਖਦਾ ਹੈ, ਪਰ ਕੁਝ ਮੁੱਖ ਅੰਤਰ ਹਨ।
ਫੰਕਸ਼ਨ getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. ਇੰਪੁੱਟ ਨੂੰ ਸਿੱਧੇ ਇੱਕ ਤਤਕਾਲ ਵਿੱਚ ਪਾਰਸ ਕਰੋ, ਫਿਰ ਬਣਾਓ // ਉਪਭੋਗਤਾ ਦੇ ਜ਼ੋਨ ਵਿੱਚ ਇੱਕ ZonedDateTime. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. ਟੀਚਾ ਜ਼ੋਨ ਵਿੱਚ ਬਦਲੋ // ਇਹ ਆਪਣੇ ਆਪ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਵਾਪਸ ਕਰਦਾ ਹੈ; 'eventTime' ਸੁਰੱਖਿਅਤ ਹੈ। const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Intl (ਬਿਲਟ-ਇਨ) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਫਾਰਮੈਟ const ਵਿਕਲਪ = { ਸਾਲ: 'ਸੰਖਿਆਤਮਕ', ਮਹੀਨਾ: 'ਛੋਟਾ', ਦਿਨ: 'ਸੰਖਿਆਤਮਕ', ਘੰਟਾ: 'ਸੰਖਿਆਤਮਕ', ਮਿੰਟ: '2-ਅੰਕ', ਦੂਜਾ: '2-ਅੰਕ', timeZoneName: 'ਛੋਟਾ' };
ਵਾਪਸੀ { ਸਥਾਨਕ: eventTime.toLocaleString(navigator.language, ਵਿਕਲਪ), ਟੀਚਾ: targetTime.toLocaleString(navigator.language, ਵਿਕਲਪ) }; }
const ਅਨੁਸੂਚੀ = getEventTimes ( '2026-03-05T15:00-05:00', 'ਅਮਰੀਕਾ/ਨਿਊਯਾਰਕ', 'ਯੂਰਪ/ਲੰਡਨ', );
console.log(schedule.local); // ਮਾਰਚ 5, 2026, 3:00:00 PM EST
console.log(schedule.target); // ਮਾਰਚ 5, 2026, 8:00:00 PM GMT
ਮੋਮੈਂਟ ਦੇ ਨਾਲ, ਸਾਨੂੰ ਨਤੀਜੇ ਵਜੋਂ ਮਿਤੀ ਦੀਆਂ ਸਤਰਾਂ ਲਈ ਇੱਕ ਫਾਰਮੈਟ ਸਟ੍ਰਿੰਗ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਨਿਸ਼ਚਿਤ ਕਰਨਾ ਹੋਵੇਗਾ। ਉਪਭੋਗਤਾ ਦੇ ਸਥਾਨ ਜਾਂ ਸਥਾਨ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਇਵੈਂਟ ਦੇ ਸਮੇਂ ਨੂੰ ਹਮੇਸ਼ਾਂ 5 ਮਾਰਚ, 2026, 3:00:00 ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕੀਤਾ ਜਾਵੇਗਾpm EST ਨਾਲ ਹੀ, ਸਾਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਅਪਵਾਦ ਸੁੱਟਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਜੇਕਰ ਕੋਈ ਅਵੈਧ ਸਤਰ Temporal.Instant.from ਨੂੰ ਪਾਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਟੈਂਪੋਰਲ ਸਾਡੇ ਲਈ ਅਪਵਾਦ ਦੇਵੇਗਾ। ਨੋਟ ਕਰਨ ਵਾਲੀ ਇੱਕ ਗੱਲ ਇਹ ਹੈ ਕਿ ਸਖਤ ਪਾਰਸਿੰਗ ਦੇ ਨਾਲ ਵੀ, ਮੋਮੈਂਟ ਸੰਸਕਰਣ ਅਜੇ ਵੀ ਵਧੇਰੇ ਨਰਮ ਹੈ. ਟੈਂਪੋਰਲ ਨੂੰ ਸਤਰ ਦੇ ਅੰਤ ਵਿੱਚ ਸਮਾਂ ਜ਼ੋਨ ਔਫਸੈੱਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਤੁਹਾਨੂੰ ਇਹ ਵੀ ਨੋਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਿਉਂਕਿ ਅਸੀਂ navigator.language ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਇਹ ਕੋਡ ਸਿਰਫ਼ ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਵਾਤਾਵਰਨ ਵਿੱਚ ਚੱਲੇਗਾ, ਕਿਉਂਕਿ ਨੈਵੀਗੇਟਰ ਨੂੰ Node.js ਵਾਤਾਵਰਨ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ। ਟੈਂਪੋਰਲ ਸਥਾਪਨ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਮੌਜੂਦਾ ਲੋਕੇਲ (navigator.language) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਉਪਭੋਗਤਾ ਆਪਣੇ ਸਥਾਨਕ ਸਮੇਂ ਦੇ ਫਾਰਮੈਟ ਵਿੱਚ ਆਪਣੇ ਆਪ ਈਵੈਂਟ ਟਾਈਮ ਫਾਰਮੈਟ ਪ੍ਰਾਪਤ ਕਰੇਗਾ। en-US ਲੋਕੇਲ ਵਿੱਚ, ਇਹ ਮਾਰਚ 5, 2026, 3:00:00 pm EST ਹੈ। ਹਾਲਾਂਕਿ, ਜੇਕਰ ਉਪਭੋਗਤਾ ਲੰਡਨ ਵਿੱਚ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਇਵੈਂਟ ਦੇ ਸਮੇਂ ਨੂੰ 5 ਮਾਰਚ 2026, 15:00:00 GMT-5 ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕੀਤਾ ਜਾਵੇਗਾ। ਸੰਖੇਪ
ਕਾਰਵਾਈ Moment.js ਅਸਥਾਈ ਮੌਜੂਦਾ ਸਮਾਂ ਪਲ() Temporal.Now.zonedDateTimeISO() ਪਾਰਸਿੰਗ ISO ਪਲ(str) Temporal.Instant.from(str) ਸਮਾਂ ਜੋੜੋ .add(7, 'ਦਿਨ') (ਮਿਊਟੇਟ) .add({ ਦਿਨ: 7 }) (ਨਵੀਂ ਵਸਤੂ) ਅੰਤਰ .diff (ਹੋਰ, 'ਘੰਟੇ') (ਹੋਰ) ਘੰਟੇ ਸਮਾਂ ਖੇਤਰ .tz('ਜ਼ੋਨ/ਨਾਮ') .withTimeZone('ਜ਼ੋਨ/ਨਾਮ')
ਪਹਿਲੀ ਨਜ਼ਰ ਵਿੱਚ, ਫਰਕ ਥੋੜ੍ਹਾ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ (ਅਤੇ ਟੈਂਪੋਰਲ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਕਈ ਵਾਰ ਵਧੇਰੇ ਵਰਬੋਜ਼ ਅਤੇ ਵਧੇਰੇ ਸਖਤ) ਸੰਟੈਕਸ, ਪਰ Moment.js ਉੱਤੇ ਟੈਂਪੋਰਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਕਈ ਮੁੱਖ ਫਾਇਦੇ ਹਨ:
ਵਧੇਰੇ ਸਪੱਸ਼ਟ ਹੋਣ ਦਾ ਮਤਲਬ ਹੈ ਘੱਟ ਹੈਰਾਨੀ ਅਤੇ ਅਣਇੱਛਤ ਬੱਗ। ਪਲ ਵਧੇਰੇ ਨਰਮ ਜਾਪਦਾ ਹੈ, ਪਰ ਇਸ ਵਿੱਚ "ਅਨੁਮਾਨ" ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ, ਜਿਸਦਾ ਨਤੀਜਾ ਕਈ ਵਾਰ ਗਲਤ ਤਾਰੀਖਾਂ ਵਿੱਚ ਹੋ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਟੈਂਪੋਰਲ ਨੂੰ ਕੁਝ ਅਵੈਧ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਇਹ ਇੱਕ ਗਲਤੀ ਸੁੱਟਦਾ ਹੈ। ਜੇਕਰ ਕੋਡ ਚੱਲਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕ ਵੈਧ ਮਿਤੀ ਮਿਲੀ ਹੈ। ਪਲ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਬੰਡਲ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਆਕਾਰ ਜੋੜ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜੇਕਰ ਤੁਸੀਂ ਪਲ-ਟਾਈਮ ਜ਼ੋਨ ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ। ਟੈਂਪੋਰਲ ਕੁਝ ਨਹੀਂ ਜੋੜਦਾ (ਇੱਕ ਵਾਰ ਇਹ ਤੁਹਾਡੇ ਨਿਸ਼ਾਨਾ ਬ੍ਰਾਊਜ਼ਰਾਂ ਵਿੱਚ ਭੇਜ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ)। ਅਟੱਲਤਾ ਤੁਹਾਨੂੰ ਵਿਸ਼ਵਾਸ ਦਿਵਾਉਂਦੀ ਹੈ ਕਿ ਮਿਤੀ ਪਰਿਵਰਤਨ ਅਤੇ ਕਾਰਵਾਈਆਂ ਕਰਦੇ ਸਮੇਂ ਤੁਸੀਂ ਕਦੇ ਵੀ ਡੇਟਾ ਨੂੰ ਨਹੀਂ ਗੁਆਓਗੇ ਜਾਂ ਓਵਰਰਾਈਟ ਨਹੀਂ ਕਰੋਗੇ। ਤੁਹਾਡੀਆਂ ਲੋੜਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਸਮੇਂ ਦੀਆਂ ਵੱਖ-ਵੱਖ ਪ੍ਰਸਤੁਤੀਆਂ (ਤਤਕਾਲ, ਪਲੇਨਡੇਟ ਟਾਈਮ, ਜ਼ੋਨਡ ਡੇਟਟਾਈਮ), ਜਿੱਥੇ ਮੋਮੈਂਟ ਹਮੇਸ਼ਾ UTC ਟਾਈਮਸਟੈਂਪ ਦੇ ਦੁਆਲੇ ਇੱਕ ਰੈਪਰ ਹੁੰਦਾ ਹੈ। ਟੈਂਪੋਰਲ ਮਿਤੀ ਫਾਰਮੈਟਿੰਗ ਲਈ Intl APIs ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਟੋਕਨਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੇ ਬਿਨਾਂ ਲੋਕੇਲ-ਜਾਗਰੂਕ ਫਾਰਮੈਟਿੰਗ ਕਰ ਸਕਦੇ ਹੋ।
ਪੌਲੀਫਿਲ 'ਤੇ ਨੋਟਸ ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਇੱਥੇ ਇੱਕ ਟੈਂਪੋਰਲ ਪੌਲੀਫਿਲ ਉਪਲਬਧ ਹੈ, ਜੋ @js-temporal/polyfill ਨਾਮਕ ਇੱਕ npm ਪੈਕੇਜ ਵਜੋਂ ਵੰਡਿਆ ਗਿਆ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਅੱਜ ਟੈਂਪੋਰਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ Safari ਵਰਗੇ ਬ੍ਰਾਊਜ਼ਰਾਂ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ ਇਸ ਪੌਲੀਫਿਲ ਦੀ ਲੋੜ ਪਵੇਗੀ ਜਿਨ੍ਹਾਂ ਨੇ ਅਜੇ ਤੱਕ API ਨੂੰ ਨਹੀਂ ਭੇਜਿਆ ਹੈ। ਇਸਦੇ ਨਾਲ ਬੁਰੀ ਖ਼ਬਰ ਇਹ ਹੈ ਕਿ ਇਹ ਤੁਹਾਡੇ ਬੰਡਲ ਦੇ ਆਕਾਰ ਵਿੱਚ ਵਾਧਾ ਕਰੇਗਾ. ਚੰਗੀ ਖ਼ਬਰ ਇਹ ਹੈ ਕਿ ਇਹ ਅਜੇ ਵੀ ਪਲ ਜਾਂ ਪਲ-ਟਾਈਮ ਜ਼ੋਨ ਨਾਲੋਂ ਕਾਫ਼ੀ ਘੱਟ ਜੋੜਦਾ ਹੈ। Bundlephobia.com ਦੁਆਰਾ ਰਿਪੋਰਟ ਕੀਤੇ ਗਏ ਬੰਡਲ ਦੇ ਆਕਾਰਾਂ ਦੀ ਤੁਲਨਾ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ, ਇੱਕ ਵੈਬਸਾਈਟ ਜੋ npm ਪੈਕੇਜ ਆਕਾਰਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪੇਸ਼ ਕਰਦੀ ਹੈ (ਬੰਡਲਫੋਬੀਆ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇਖਣ ਲਈ ਹਰੇਕ ਪੈਕੇਜ ਦੇ ਨਾਮ 'ਤੇ ਕਲਿੱਕ ਕਰੋ):
ਪੈਕੇਜ ਮਿੰਨੀਫਾਈਡ ਛੋਟਾ ਅਤੇ gzipped @js-temporal/polyfill 154.1 kB 44.1 kB ਪਲ 294.4 kB 75.4 kB ਪਲ-ਸਮਾਂ ਜ਼ੋਨ 1 MB 114.2 kB
ਪੌਲੀਫਿਲ ਵਿੱਚ ਇਤਿਹਾਸਕ ਤੌਰ 'ਤੇ ਮੈਮੋਰੀ ਵਰਤੋਂ ਦੇ ਆਲੇ ਦੁਆਲੇ ਕੁਝ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਮੁੱਦੇ ਵੀ ਸਨ, ਅਤੇ ਲਿਖਣ ਦੇ ਸਮੇਂ, ਇਸ ਨੂੰ ਅਲਫ਼ਾ ਅਵਸਥਾ ਵਿੱਚ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਇਸਦੇ ਕਾਰਨ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਉਦੋਂ ਤੱਕ ਨਹੀਂ ਵਰਤਣਾ ਚਾਹੋਗੇ ਜਦੋਂ ਤੱਕ ਇਹ ਇੱਕ ਹੋਰ ਪਰਿਪੱਕ ਅਵਸਥਾ ਵਿੱਚ ਨਹੀਂ ਪਹੁੰਚ ਜਾਂਦਾ। ਦੂਸਰੀ ਚੰਗੀ ਖ਼ਬਰ ਇਹ ਹੈ ਕਿ ਉਮੀਦ ਹੈ ਕਿ ਪੌਲੀਫਿਲ ਦੀ ਜ਼ਿਆਦਾ ਦੇਰ ਤੱਕ ਲੋੜ ਨਹੀਂ ਪਵੇਗੀ (ਜਦੋਂ ਤੱਕ ਕਿ ਤੁਹਾਨੂੰ ਪੁਰਾਣੇ ਬ੍ਰਾਉਜ਼ਰਾਂ ਦਾ ਸਮਰਥਨ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਬੇਸ਼ਕ)। ਲਿਖਣ ਦੇ ਸਮੇਂ, ਟੈਂਪੋਰਲ ਨੇ ਕ੍ਰੋਮ, ਐਜ ਅਤੇ ਫਾਇਰਫਾਕਸ ਵਿੱਚ ਭੇਜਿਆ ਹੈ. ਇਹ ਅਜੇ ਸਫਾਰੀ ਵਿੱਚ ਬਿਲਕੁਲ ਤਿਆਰ ਨਹੀਂ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਨਵੀਨਤਮ ਤਕਨਾਲੋਜੀ ਪ੍ਰੀਵਿਊ 'ਤੇ ਰਨਟਾਈਮ ਫਲੈਗ ਦੇ ਨਾਲ ਉਪਲਬਧ ਜਾਪਦਾ ਹੈ।
