ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಬರೆಯಲಾದ ಯಾವುದೇ ರೀತಿಯ ಅಪ್ಲಿಕೇಶನ್ ಕೆಲವು ಸಾಮರ್ಥ್ಯದಲ್ಲಿ ಸಮಯ ಅಥವಾ ದಿನಾಂಕಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಆರಂಭದಲ್ಲಿ, ಇದು ಅಂತರ್ನಿರ್ಮಿತ ದಿನಾಂಕ API ಗೆ ಸೀಮಿತವಾಗಿತ್ತು. ಈ API ಮೂಲಭೂತ ಕಾರ್ಯವನ್ನು ಒಳಗೊಂಡಿದೆ, ಆದರೆ ಅದು ಏನು ಮಾಡಬಹುದು ಎಂಬುದರಲ್ಲಿ ಸಾಕಷ್ಟು ಸೀಮಿತವಾಗಿದೆ. Moment.js ನಂತಹ ಥರ್ಡ್-ಪಾರ್ಟಿ ಲೈಬ್ರರಿಗಳು ಮತ್ತು ನಂತರ ಅಂತರ್ನಿರ್ಮಿತ APIಗಳಾದ Intl API ಗಳು ಮತ್ತು ಹೊಸ ಟೆಂಪೊರಲ್ API, ಸಮಯ ಮತ್ತು ದಿನಾಂಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹೆಚ್ಚಿನ ನಮ್ಯತೆಯನ್ನು ಸೇರಿಸುತ್ತವೆ. Moment.js ನ ಉದಯ ಮತ್ತು ಪತನ Moment.js ಸಮಯ ಮತ್ತು ದಿನಾಂಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಪ್ರಬಲ ಉಪಯುಕ್ತತೆಗಳನ್ನು ಹೊಂದಿರುವ JavaScript ಲೈಬ್ರರಿಯಾಗಿದೆ. ಇದು ಸಮಯ ವಲಯದ ಕುಶಲತೆಯಂತಹ ಮೂಲ ದಿನಾಂಕ API ನಿಂದ ಕಾಣೆಯಾದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಮತ್ತು ಅನೇಕ ಸಾಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಕ್ಷಣವು ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವ ಕಾರ್ಯಗಳನ್ನು ಸಹ ಒಳಗೊಂಡಿದೆ. ಇದು ವಿವಿಧ ಅನ್ವಯಿಕೆಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುವ ಗ್ರಂಥಾಲಯವಾಯಿತು. ಆದಾಗ್ಯೂ, ಮೊಮೆಂಟ್ ತನ್ನ ಸಮಸ್ಯೆಗಳ ಪಾಲನ್ನು ಸಹ ಹೊಂದಿತ್ತು. ಇದು ದೊಡ್ಡ ಗ್ರಂಥಾಲಯವಾಗಿದೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ನ ಬಂಡಲ್ ಗಾತ್ರಕ್ಕೆ ಗಮನಾರ್ಹವಾಗಿ ಸೇರಿಸಬಹುದು. ಲೈಬ್ರರಿಯು ಮರದ ಅಲುಗಾಟವನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ (ಲೈಬ್ರರಿಗಳ ಬಳಕೆಯಾಗದ ಭಾಗಗಳನ್ನು ತೆಗೆದುಹಾಕಬಹುದಾದ ಆಧುನಿಕ ಬಂಡ್ಲರ್ಗಳ ವೈಶಿಷ್ಟ್ಯ), ನೀವು ಅದರ ಒಂದು ಅಥವಾ ಎರಡು ಕಾರ್ಯಗಳನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತಿದ್ದರೂ ಸಹ ಸಂಪೂರ್ಣ ಕ್ಷಣ ಲೈಬ್ರರಿಯನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ. ಕ್ಷಣದೊಂದಿಗಿನ ಮತ್ತೊಂದು ಸಮಸ್ಯೆಯೆಂದರೆ ಅದು ರಚಿಸುವ ವಸ್ತುಗಳು ಬದಲಾಗಬಲ್ಲವು. ಕ್ಷಣ ವಸ್ತುವಿನ ಮೇಲೆ ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಕರೆಯುವುದು ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಆ ವಸ್ತುವಿನ ಮೌಲ್ಯವನ್ನು ರೂಪಾಂತರಗೊಳಿಸುತ್ತದೆ. ಇದು ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ ಅಥವಾ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. 2020 ರಲ್ಲಿ, ಕ್ಷಣದ ನಿರ್ವಾಹಕರು ಲೈಬ್ರರಿಯನ್ನು ನಿರ್ವಹಣೆ ಮೋಡ್ಗೆ ಹಾಕಲು ನಿರ್ಧರಿಸಿದರು. ಯಾವುದೇ ಹೊಸ ವೈಶಿಷ್ಟ್ಯದ ಅಭಿವೃದ್ಧಿಯನ್ನು ಮಾಡಲಾಗುತ್ತಿಲ್ಲ ಮತ್ತು ಹೊಸ ಯೋಜನೆಗಳಿಗೆ ಅದನ್ನು ಬಳಸದಂತೆ ನಿರ್ವಹಕರು ಶಿಫಾರಸು ಮಾಡುತ್ತಾರೆ. ದಿನಾಂಕ-ಎಫ್ಎನ್ಎಸ್ನಂತಹ ಇತರ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದಿನಾಂಕ ಲೈಬ್ರರಿಗಳಿವೆ, ಆದರೆ ಪಟ್ಟಣದಲ್ಲಿ ಹೊಸ ಪ್ಲೇಯರ್ ಇದೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್: ಟೆಂಪೊರಲ್ಗೆ ನೇರವಾಗಿ ನಿರ್ಮಿಸಲಾದ API. ಇದು ಮೂಲ ದಿನಾಂಕ API ನ ರಂಧ್ರಗಳನ್ನು ತುಂಬುವ ಹೊಸ ಮಾನದಂಡವಾಗಿದೆ ಮತ್ತು ಕ್ಷಣ ಮತ್ತು ಇತರ ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಕಂಡುಬರುವ ಕೆಲವು ಮಿತಿಗಳನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ತಾತ್ಕಾಲಿಕ ಎಂದರೇನು? ಟೆಂಪೊರಲ್ ಎಂಬುದು ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ECMAScript ಮಾನದಂಡಕ್ಕೆ ಹೊಸ ಸಮಯ ಮತ್ತು ದಿನಾಂಕ API ಅನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ. ಮಾರ್ಚ್ 20266 ರಂತೆ, ಇದು TC39 ಪ್ರಕ್ರಿಯೆಯ ಹಂತ 4 ಕ್ಕೆ ತಲುಪಿದೆ (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಗೆ ಪ್ರಸ್ತಾವನೆಗಳು ಮತ್ತು ಸೇರ್ಪಡೆಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಸಮಿತಿ), ಮತ್ತು ECMAScript ವಿವರಣೆಯ ಮುಂದಿನ ಆವೃತ್ತಿಯಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಇದನ್ನು ಈಗಾಗಲೇ ಹಲವಾರು ಬ್ರೌಸರ್ಗಳಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ: Chrome 144+ ಮತ್ತು Firefox 139+, Safari ಶೀಘ್ರದಲ್ಲೇ ಅನುಸರಿಸುವ ನಿರೀಕ್ಷೆಯಿದೆ. ಬೆಂಬಲಿಸದ ಬ್ರೌಸರ್ಗಳು ಮತ್ತು Node.js ಗಾಗಿ ಪಾಲಿಫಿಲ್ ಸಹ ಲಭ್ಯವಿದೆ. ತಾತ್ಕಾಲಿಕ API ಸಾಮಾನ್ಯವಾಗಿ ಕ್ಷಣಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ವಸ್ತುಗಳನ್ನು ರಚಿಸುತ್ತದೆ. ಇವುಗಳು ನಿರ್ದಿಷ್ಟ ಸಮಯ ವಲಯದಲ್ಲಿ ಪೂರ್ಣ ಸಮಯ ಮತ್ತು ದಿನಾಂಕದ ಅಂಚೆಚೀಟಿಗಳಾಗಿರಬಹುದು ಅಥವಾ ಯಾವುದೇ ಸಮಯ ವಲಯ ಅಥವಾ ದಿನಾಂಕದ ಮಾಹಿತಿಯಿಲ್ಲದೆಯೇ "ಗೋಡೆ ಗಡಿಯಾರ" ಸಮಯದ ಸಾಮಾನ್ಯ ನಿದರ್ಶನವಾಗಿರಬಹುದು. ಟೆಂಪೊರಲ್ನ ಕೆಲವು ಮುಖ್ಯ ಲಕ್ಷಣಗಳು:
ದಿನಾಂಕಗಳೊಂದಿಗೆ ಅಥವಾ ಇಲ್ಲದ ಸಮಯಗಳು. ಒಂದು ತಾತ್ಕಾಲಿಕ ವಸ್ತುವು ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕದ ನಿರ್ದಿಷ್ಟ ಸಮಯವನ್ನು ಅಥವಾ ಯಾವುದೇ ದಿನಾಂಕದ ಮಾಹಿತಿಯಿಲ್ಲದ ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸಬಹುದು. ಸಮಯವಿಲ್ಲದೆ ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕವನ್ನು ಸಹ ಪ್ರತಿನಿಧಿಸಬಹುದು. ಸಮಯ ವಲಯ ಬೆಂಬಲ.ತಾತ್ಕಾಲಿಕ ವಸ್ತುಗಳು ಸಂಪೂರ್ಣವಾಗಿ ಸಮಯ ವಲಯವನ್ನು ತಿಳಿದಿರುತ್ತವೆ ಮತ್ತು ವಿವಿಧ ಸಮಯ ವಲಯಗಳಲ್ಲಿ ಪರಿವರ್ತಿಸಬಹುದು. ಕ್ಷಣವು ಸಮಯ ವಲಯಗಳನ್ನು ಸಹ ಬೆಂಬಲಿಸುತ್ತದೆ, ಆದರೆ ಇದಕ್ಕೆ ಹೆಚ್ಚುವರಿ ಕ್ಷಣ-ಸಮಯವಲಯ ಲೈಬ್ರರಿಯ ಅಗತ್ಯವಿದೆ. ಅಸ್ಥಿರತೆ.ಒಮ್ಮೆ ತಾತ್ಕಾಲಿಕ ವಸ್ತುವನ್ನು ರಚಿಸಿದರೆ, ಅದನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ. ಸಮಯ ಅಂಕಗಣಿತ ಅಥವಾ ಸಮಯ ವಲಯ ಪರಿವರ್ತನೆಗಳು ಆಧಾರವಾಗಿರುವ ವಸ್ತುವನ್ನು ಮಾರ್ಪಡಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಅವರು ಹೊಸ ತಾತ್ಕಾಲಿಕ ವಸ್ತುವನ್ನು ರಚಿಸುತ್ತಾರೆ. 1-ಆಧಾರಿತ ಸೂಚ್ಯಂಕ. ದಿನಾಂಕ API ಯೊಂದಿಗೆ (ಹಾಗೆಯೇ ಕ್ಷಣದೊಂದಿಗೆ) ದೋಷಗಳ ಸಾಮಾನ್ಯ ಮೂಲವೆಂದರೆ ತಿಂಗಳುಗಳು ಶೂನ್ಯ ಸೂಚ್ಯಂಕವಾಗಿದೆ. ಅಂದರೆ ನಿಜ ಜೀವನದಲ್ಲಿ ನಾವೆಲ್ಲರೂ ಅರ್ಥಮಾಡಿಕೊಂಡಂತೆ ತಿಂಗಳ 1 ಕ್ಕಿಂತ ಜನವರಿ ತಿಂಗಳು 0 ಆಗಿದೆ. 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 am
ಕ್ಷಣದ ಬಗ್ಗೆ ನೆನಪಿಡುವ ಪ್ರಮುಖ ವಿಷಯವೆಂದರೆ ಕ್ಷಣ ವಸ್ತುವು ಯಾವಾಗಲೂ ಸಮಯ ಮತ್ತು ದಿನಾಂಕದ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ನೀವು ಸಮಯದ ಮಾಹಿತಿಯೊಂದಿಗೆ ಮಾತ್ರ ಕೆಲಸ ಮಾಡಬೇಕಾದರೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಉತ್ತಮವಾಗಿರುತ್ತದೆ, ಆದರೆ ಇದು ಡೇಲೈಟ್ ಸೇವಿಂಗ್ ಟೈಮ್ ಅಥವಾ ಅಧಿಕ ವರ್ಷಗಳಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ಉಂಟುಮಾಡಬಹುದು, ಅಲ್ಲಿ ದಿನಾಂಕವು ಸಮಯದ ಲೆಕ್ಕಾಚಾರದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಟೆಂಪೊರಲ್ ಹೆಚ್ಚು ಮೃದುವಾಗಿರುತ್ತದೆ. Temporal.Instant ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವ ಮೂಲಕ ಪ್ರಸ್ತುತ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ವಸ್ತುವನ್ನು ನೀವು ರಚಿಸಬಹುದು. ಇದು "ಯುಗ" (ಜನವರಿ 1, 1970 ರಂದು ಮಧ್ಯರಾತ್ರಿ UTC) ಸಮಯದಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸಮಯದ ಬಿಂದುವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ನ್ಯಾನೊಸೆಕೆಂಡ್-ಮಟ್ಟದ ನಿಖರತೆಯೊಂದಿಗೆ ತಾತ್ಕಾಲಿಕ ಈ ಕ್ಷಣವನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು. const now = Temporal.Now.instant();
// ಯುಗದಿಂದ ಕಚ್ಚಾ ನ್ಯಾನೋಸೆಕೆಂಡ್ಗಳನ್ನು ನೋಡಿ console.log( now.epochNanoseconds); // 1771466342612000000n
// 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
// US ಪೂರ್ವ ಸಮಯ ವಲಯದಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯ const dueAt = Temporal.ZonedDateTime.from({ ಸಮಯವಲಯ: 'ಅಮೆರಿಕಾ/ನ್ಯೂಯಾರ್ಕ್', ವರ್ಷ: 2026, ತಿಂಗಳು: 3, ದಿನ: 1, ಗಂಟೆ: 12, ನಿಮಿಷ: 0, ಎರಡನೇ: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
ಪಾರ್ಸಿಂಗ್ ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಮಾಹಿತಿಯ ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ರಚನೆಯನ್ನು ನಾವು ಆವರಿಸಿದ್ದೇವೆ. ಈಗ ಪಾರ್ಸಿಂಗ್ ಅನ್ನು ನೋಡೋಣ. ಪಾರ್ಸಿಂಗ್ ಎನ್ನುವುದು ಅಂತರ್ನಿರ್ಮಿತ ಟೆಂಪೊರಲ್ API ಗಿಂತ ಕ್ಷಣ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಒಂದು ಪ್ರದೇಶವಾಗಿದೆ. ಕ್ಷಣದ ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸುವ ಮೂಲಕ ನೀವು ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡಬಹುದು. ಒಂದೇ ಆರ್ಗ್ಯುಮೆಂಟ್ನೊಂದಿಗೆ, Moment ISO ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ, ಆದರೆ ನೀವು ಬಳಸುತ್ತಿರುವ ದಿನಾಂಕ ಸ್ವರೂಪವನ್ನು ಸೂಚಿಸುವ ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಒದಗಿಸಿದರೆ ನೀವು ಪರ್ಯಾಯ ಸ್ವರೂಪಗಳನ್ನು ಬಳಸಬಹುದು.
const isoDate = ಕ್ಷಣ('2026-02-21T09:00:00'); const formattedDate = ಕ್ಷಣ('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. ಅನುಸರಣೆಯಿಲ್ಲದ ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಧಾನದಿಂದ ರವಾನಿಸಿದರೆ, ಟೆಂಪೊರಲ್ ರೇಂಜ್ ಎರರ್ ಅನ್ನು ಎಸೆಯುತ್ತದೆ.
// RFC 9557 ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬಳಸುವುದು const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); 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 ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಸಮಯ ವಲಯ ಆಫ್ಸೆಟ್ನೊಂದಿಗೆ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಆದರೆ ನೀವು ದಿನಾಂಕ ಸ್ವರೂಪದ ಉಪವಿಭಾಗವನ್ನು ಬಳಸಿಕೊಂಡು PlainDate ಅಥವಾ PlainTime ವಸ್ತುಗಳನ್ನು ಸಹ ರಚಿಸಬಹುದು. 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
ಈ ತಂತಿಗಳು ಇನ್ನೂ ನಿರೀಕ್ಷಿತ ಸ್ವರೂಪವನ್ನು ಅನುಸರಿಸಬೇಕು ಅಥವಾ ದೋಷವನ್ನು ಎಸೆಯಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
// ಅನುವರ್ತನೆಯಲ್ಲದ ಸಮಯದ ತಂತಿಗಳನ್ನು ಬಳಸುವುದು. ಇವೆಲ್ಲವೂ ರೇಂಜ್ ಎರರ್ ಅನ್ನು ಎಸೆಯುತ್ತವೆ. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
ಪ್ರೊ ಸಲಹೆ: ISO ಅಲ್ಲದ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಏಕೆಂದರೆ ಟೆಂಪೊರಲ್ ವಿಶ್ವಾಸಾರ್ಹತೆಗೆ ಆದ್ಯತೆ ನೀಡುತ್ತದೆ, ಇದು 02-01-2026 ನಂತಹ ಸ್ಟ್ರಿಂಗ್ನ ಸ್ವರೂಪವನ್ನು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸುವುದಿಲ್ಲ. ನಿಮ್ಮ ಡೇಟಾ ಮೂಲವು ಅಂತಹ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಬಳಸಿದರೆ, ಟೆಂಪೊರಲ್ನೊಂದಿಗೆ ಬಳಸಲು ಪ್ರಯತ್ನಿಸುವ ಮೊದಲು ಮೌಲ್ಯಗಳನ್ನು 2026-02-01 ನಂತಹ ISO ಸ್ಟ್ರಿಂಗ್ಗೆ ಮರುಹೊಂದಿಸಲು ನೀವು ಕೆಲವು ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಅನ್ನು ಮಾಡಬೇಕಾಗುತ್ತದೆ.
ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಒಮ್ಮೆ ನೀವು ಕ್ಷಣ ಅಥವಾ ತಾತ್ಕಾಲಿಕ ವಸ್ತುವನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀವು ಬಹುಶಃ ಅದನ್ನು ಕೆಲವು ಹಂತದಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್ಗೆ ಪರಿವರ್ತಿಸಲು ಬಯಸುತ್ತೀರಿ. ಕ್ಷಣವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಉದ್ವಿಗ್ನವಾಗಿರುವ ಒಂದು ನಿದರ್ಶನವಾಗಿದೆ. ಅಪೇಕ್ಷಿತ ದಿನಾಂಕ ಸ್ವರೂಪವನ್ನು ವಿವರಿಸುವ ಟೋಕನ್ಗಳ ಸ್ಟ್ರಿಂಗ್ನೊಂದಿಗೆ ನೀವು ವಸ್ತುವಿನ ಫಾರ್ಮ್ಯಾಟ್ ವಿಧಾನವನ್ನು ಕರೆಯುತ್ತೀರಿ. ಸ್ಥಿರ ದಿನಾಂಕ = ಕ್ಷಣ ();
console.log(date.format('MM/DD/YYYY')); // 02/22/2026
console.log(date.format('MMMM ಮಾಡಿ YYYY, h:mm:ss a')); // ಫೆಬ್ರವರಿ 22, 2026, 8:18:30 pm
ಮತ್ತೊಂದೆಡೆ, ಟೆಂಪೊರಲ್ಗೆ ನೀವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಮೌಖಿಕವಾಗಿರಬೇಕು. ತತ್ಕ್ಷಣದಂತಹ ತಾತ್ಕಾಲಿಕ ವಸ್ತುಗಳು, ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವಿವಿಧ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಆಯ್ಕೆಗಳನ್ನು ಸ್ವೀಕರಿಸುವ toLocaleString ವಿಧಾನವನ್ನು ಹೊಂದಿವೆ.
ಸ್ಥಿರ ದಿನಾಂಕ = 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 PM ನಲ್ಲಿ
// ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ನಿಮಗೆ ಬೇಕಾದ ಕ್ಷೇತ್ರಗಳನ್ನು ಮಾತ್ರ ರವಾನಿಸಿ console.log(date.toLocaleString('en-US', {) ತಿಂಗಳು: 'ಸಣ್ಣ', ದಿನ: 'ಸಂಖ್ಯಾ' })); // ಫೆಬ್ರವರಿ 22
ತಾತ್ಕಾಲಿಕ ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ವಾಸ್ತವವಾಗಿ Intl.DateTimeFormat API ಅನ್ನು ಬಳಸುತ್ತದೆ (ಇದು ಆಧುನಿಕ ಬ್ರೌಸರ್ಗಳಲ್ಲಿ ಈಗಾಗಲೇ ಸುಲಭವಾಗಿ ಲಭ್ಯವಿದೆ) ಹುಡ್ ಅಡಿಯಲ್ಲಿ. ಅಂದರೆ ನಿಮ್ಮ ಕಸ್ಟಮ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಆಯ್ಕೆಗಳೊಂದಿಗೆ ನೀವು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ DateTimeFormat ವಸ್ತುವನ್ನು ರಚಿಸಬಹುದು, ನಂತರ ತಾತ್ಕಾಲಿಕ ವಸ್ತುಗಳನ್ನು ಅದರ ಫಾರ್ಮ್ಯಾಟ್ ವಿಧಾನಕ್ಕೆ ರವಾನಿಸಬಹುದು. ಈ ಕಾರಣದಿಂದಾಗಿ, ಇದು ಕ್ಷಣದಂತಹ ಕಸ್ಟಮ್ ದಿನಾಂಕ ಸ್ವರೂಪಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ. ನಿಮಗೆ 'Q1 2026' ಅಥವಾ ಇತರ ವಿಶೇಷ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ನಂತಹ ಏನಾದರೂ ಅಗತ್ಯವಿದ್ದರೆ, ನಿಮಗೆ ಕೆಲವು ಕಸ್ಟಮ್ ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಕೋಡ್ ಬೇಕಾಗಬಹುದು ಅಥವಾ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಲೈಬ್ರರಿಗೆ ತಲುಪಬಹುದು. const formatter = ಹೊಸ Intl.DateTimeFormat('en-US', { ತಿಂಗಳು: '2-ಅಂಕಿ', ದಿನ: '2-ಅಂಕಿ', ವರ್ಷ: 'ಸಂಖ್ಯಾ' });
ಸ್ಥಿರ ದಿನಾಂಕ = Temporal.Now.instant(); console.log(formatter.format(date)); // 02/22/2026
ಕ್ಷಣದ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಟೋಕನ್ಗಳು ಬರೆಯಲು ಸರಳವಾಗಿದೆ, ಆದರೆ ಅವು ಲೊಕೇಲ್-ಸ್ನೇಹಿಯಾಗಿರುವುದಿಲ್ಲ. ಫಾರ್ಮ್ಯಾಟ್ ಸ್ಟ್ರಿಂಗ್ಸ್ "ಹಾರ್ಡ್ ಕೋಡ್" ವಿಷಯಗಳು ತಿಂಗಳು/ದಿನದ ಆದೇಶ. ಟೆಂಪೊರಲ್ ಮಾಡುವಂತೆ ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುವ ಪ್ರಯೋಜನವೆಂದರೆ ಅದು ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಲೊಕೇಲ್ಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಸರಿಯಾದ ಸ್ವರೂಪವನ್ನು ಬಳಸುತ್ತದೆ. ಸ್ಥಿರ ದಿನಾಂಕ = 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, 'days'); 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({days: 7 }); // RangeError: ತಾತ್ಕಾಲಿಕ ದೋಷ: ದೊಡ್ಡ ಘಟಕವು ದಿನಾಂಕ ಘಟಕವಾಗಿರಬಾರದು
ಏಕೆಂದರೆ ಇನ್ಸ್ಟಂಟ್ ಆಬ್ಜೆಕ್ಟ್ಗಳು ಯುಟಿಸಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ ಮತ್ತು ಕ್ಯಾಲೆಂಡರ್-ಅಜ್ಞೇಯತಾವಾದಿಗಳಾಗಿವೆ. ಡೇಲೈಟ್ ಸೇವಿಂಗ್ ಸಮಯದಂತಹ ಸಮಯ ವಲಯದ ನಿಯಮಗಳ ಆಧಾರದ ಮೇಲೆ ದಿನದ ಉದ್ದವು ಬದಲಾಗಬಹುದು, ಈ ಲೆಕ್ಕಾಚಾರವು ತತ್ಕ್ಷಣದಲ್ಲಿ ಲಭ್ಯವಿರುವುದಿಲ್ಲ. ಆದಾಗ್ಯೂ, ನೀವು PlainDateTime ನಂತಹ ಇತರ ರೀತಿಯ ವಸ್ತುಗಳ ಮೇಲೆ ಈ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮಾಡಬಹುದು: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({days: 7 });
// ಮೂಲ PlainDateTime ಬದಲಾಗದೆ ಉಳಿದಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ 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
ತಾತ್ಕಾಲಿಕ ವಸ್ತುವಿನೊಂದಿಗೆ ಇದನ್ನು ಮಾಡಲು, ನೀವು ಇನ್ನೊಂದು ತಾತ್ಕಾಲಿಕ ವಸ್ತುವನ್ನು ಅದರ ತನಕ ಅಥವಾ ವಿಧಾನಗಳಿಗೆ ರವಾನಿಸಬಹುದು. ಇದು ಸಮಯದ ವ್ಯತ್ಯಾಸದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರುವ ತಾತ್ಕಾಲಿಕ. ಅವಧಿಯ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅವಧಿಯ ವಸ್ತುವು ವ್ಯತ್ಯಾಸದ ಪ್ರತಿಯೊಂದು ಘಟಕಕ್ಕೆ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಸಮಯದ ವ್ಯತ್ಯಾಸವನ್ನು ಪ್ರತಿನಿಧಿಸುವ 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.ince(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 ಯೊಂದಿಗೆ ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ. Moment ಎರಡು ಕ್ಷಣದ ವಸ್ತುಗಳನ್ನು ಹೋಲಿಸಲು 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 ಗೆ ಎರಡೂ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳು PlainDate ಆಬ್ಜೆಕ್ಟ್ಗಳಾಗಿರಬೇಕು.
const date1 = Temporal.PlainDate.from({ವರ್ಷ: 2026, ತಿಂಗಳು: 2, ದಿನ: 24}); const date2 = Temporal.PlainDate.from({ವರ್ಷ: 2026, ತಿಂಗಳು: 3, ದಿನ: 24});
// ದಿನಾಂಕ1 ದಿನಾಂಕ 2 ಕ್ಕಿಂತ ಮೊದಲು ಬರುತ್ತದೆ, ಆದ್ದರಿಂದ -1 console.log(Temporal.PlainDate.compare(date1, date2));
// ನಾವು ವಿವಿಧ ರೀತಿಯ ಎರಡು ವಸ್ತುಗಳನ್ನು ಹೋಲಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ದೋಷ console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // ಟೈಪ್ ದೋಷ: ತಾತ್ಕಾಲಿಕ ದೋಷ: ಅಮಾನ್ಯವಾದ ಸರಳ ದಿನಾಂಕ ಕ್ಷೇತ್ರಗಳನ್ನು ಒದಗಿಸಲಾಗಿದೆ.
ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಇದು ತಾತ್ಕಾಲಿಕ ವಸ್ತುಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಕಾಲಾನುಕ್ರಮವಾಗಿ ವಿಂಗಡಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. // Temporal.PlainDate ವಸ್ತುಗಳ ಒಂದು ಶ್ರೇಣಿ ಸ್ಥಿರ ದಿನಾಂಕಗಳು = [... ];
// 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 ನಿಂದ ಹಿಂತಿರುಗಿಸಿದ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಮೌಲ್ಯಗಳು, ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಲೊಕೇಲ್-ಅವಲಂಬಿತವಾಗಿದೆ. ಮಾದರಿ ಕೋಡ್ ಅನ್ನು ಎನ್-ಯುಎಸ್ ಲೊಕೇಲ್ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ಫಾರ್ಮ್ಯಾಟ್ ಹೀಗಿದೆ: 2/28/2026, 5:12:02 PM PST. ಇನ್ನೊಂದು ಸ್ಥಳದಲ್ಲಿ, ಇದು ವಿಭಿನ್ನವಾಗಿರಬಹುದು. ಉದಾಹರಣೆಗೆ, en-GB ಲೊಕೇಲ್ನಲ್ಲಿ, ನೀವು 28/2/2026, 17:12:02 GMT-8 ನಂತಹದನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಎ ರಿಯಲ್ ವರ್ಲ್ಡ್ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಸಮಯ ವಲಯಗಳಾದ್ಯಂತ ಈವೆಂಟ್ಗಳನ್ನು ನಿಗದಿಪಡಿಸಲು ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ಭಾವಿಸೋಣ. ಈ ಅಪ್ಲಿಕೇಶನ್ನ ಭಾಗವು ಒಂದು ಕಾರ್ಯವಾಗಿದೆ, getEventTimes, ಇದು ಈವೆಂಟ್ನ ಸಮಯ ಮತ್ತು ದಿನಾಂಕ, ಸ್ಥಳೀಯ ಸಮಯ ವಲಯ ಮತ್ತು ಗುರಿ ಸಮಯ ವಲಯವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ISO 8601 ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಕಾರ್ಯವು ಎರಡೂ ಸಮಯ ವಲಯಗಳಲ್ಲಿ ಈವೆಂಟ್ಗಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಸಮಯ ಮತ್ತು ದಿನಾಂಕದ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ರಚಿಸುತ್ತದೆ. ಕಾರ್ಯವು ಮಾನ್ಯವಾದ ಸಮಯ/ದಿನಾಂಕದ ಸ್ಟ್ರಿಂಗ್ ಅಲ್ಲದ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನೀಡಿದರೆ, ಅದು ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ. ಕ್ಷಣವನ್ನು ಬಳಸಿಕೊಂಡು ಮೂಲ ಅನುಷ್ಠಾನ ಇಲ್ಲಿದೆ (ಮೊಮೆಂಟ್-ಟೈಮ್ಝೋನ್ ಪ್ಯಾಕೇಜ್ನ ಬಳಕೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ).
'ಮೊಮೆಂಟ್-ಟೈಮ್ಝೋನ್' ನಿಂದ ಆಮದು ಕ್ಷಣ;
ಫಂಕ್ಷನ್ getEventTimes (ಇನ್ಪುಟ್ಸ್ಟ್ರಿಂಗ್, ಯೂಸರ್ಟೈಮ್ಝೋನ್, ಟಾರ್ಗೆಟ್ಟೈಮ್ಝೋನ್) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. ಬಳಕೆದಾರರ ಸಮಯ ವಲಯದಲ್ಲಿ ಆರಂಭಿಕ ಕ್ಷಣವನ್ನು ರಚಿಸಿ const eventTime = moment.tz( ಇನ್ಪುಟ್ಸ್ಟ್ರಿಂಗ್, moment.ISO_8601, // ISO 8601 ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸಿ ನಿಜ, // ಕಟ್ಟುನಿಟ್ಟಾದ ಪಾರ್ಸಿಂಗ್ userTimeZone );
// ಇನ್ಪುಟ್ಸ್ಟ್ರಿಂಗ್ ಮಾನ್ಯವಾದ ದಿನಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸದಿದ್ದರೆ ದೋಷವನ್ನು ಎಸೆಯಿರಿ ಒಂದು ವೇಳೆ (!eventTime.isValid()) { ಹೊಸ ದೋಷವನ್ನು ಎಸೆಯಿರಿ ('ಅಮಾನ್ಯ ದಿನಾಂಕ/ಸಮಯದ ಇನ್ಪುಟ್'); }
// 2. ಗುರಿ ಸಮಯವನ್ನು ಲೆಕ್ಕಹಾಕಿ // ವಿಮರ್ಶಾತ್ಮಕ: ನಾವು ಕ್ಲೋನ್ ಮಾಡಬೇಕು, ಅಥವಾ 'ಈವೆಂಟ್ಟೈಮ್' ಶಾಶ್ವತವಾಗಿ ಬದಲಾಗುತ್ತದೆ! const targetTime = eventTime.clone().tz(targetTimeZone);
ಹಿಂತಿರುಗಿ { ಸ್ಥಳೀಯ: eventTime.format(timeFormat), ಗುರಿ: targetTime.format(timeFormat), }; }
ಸ್ಥಿರ ವೇಳಾಪಟ್ಟಿ = 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
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ISO 8601 ನ ನಿರೀಕ್ಷಿತ ದಿನಾಂಕ ಸ್ವರೂಪವನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ, ಅದನ್ನು ಕ್ಷಣದಲ್ಲಿ ಸಹಾಯಕವಾಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ. ನಾವು ಕಟ್ಟುನಿಟ್ಟಾದ ಪಾರ್ಸಿಂಗ್ ಅನ್ನು ಸಹ ಬಳಸುತ್ತಿದ್ದೇವೆ, ಅಂದರೆ ಫಾರ್ಮ್ಯಾಟ್ಗೆ ಹೊಂದಿಕೆಯಾಗದ ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ನೊಂದಿಗೆ ಕ್ಷಣವು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸುವುದಿಲ್ಲ. ISO ಅಲ್ಲದ ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರವಾನಿಸಿದರೆ, ಅದು ಅಮಾನ್ಯ ದಿನಾಂಕ ವಸ್ತುವಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಮತ್ತು ನಾವು ದೋಷವನ್ನು ಎಸೆಯುತ್ತೇವೆ. ತಾತ್ಕಾಲಿಕ ಅನುಷ್ಠಾನವು ಹೋಲುತ್ತದೆ, ಆದರೆ ಕೆಲವು ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹೊಂದಿದೆ.
ಫಂಕ್ಷನ್ getEventTimes (ಇನ್ಪುಟ್ಸ್ಟ್ರಿಂಗ್, ಯೂಸರ್ಟೈಮ್ಝೋನ್, ಟಾರ್ಗೆಟ್ಟೈಮ್ಝೋನ್) { // 1. ಇನ್ಪುಟ್ ಅನ್ನು ನೇರವಾಗಿ ತತ್ಕ್ಷಣಕ್ಕೆ ಪಾರ್ಸ್ ಮಾಡಿ, ನಂತರ ರಚಿಸಿ // ಬಳಕೆದಾರರ ವಲಯದಲ್ಲಿ ZonedDateTime. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. ಗುರಿ ವಲಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿ // ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಸ ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ; ಈವೆಂಟ್ಟೈಮ್ ಸುರಕ್ಷಿತವಾಗಿದೆ. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Intl ಬಳಸಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿ (ಅಂತರ್ನಿರ್ಮಿತ) ಸ್ಥಿರ ಆಯ್ಕೆಗಳು = { ವರ್ಷ: 'ಸಂಖ್ಯಾ', ತಿಂಗಳು: 'ಸಣ್ಣ', ದಿನ: 'ಸಂಖ್ಯಾ', ಗಂಟೆ: 'ಸಂಖ್ಯಾ', ನಿಮಿಷ: '2-ಅಂಕಿ', ಎರಡನೇ: '2-ಅಂಕಿ', timeZoneName: 'ಸಣ್ಣ' };
ಹಿಂತಿರುಗಿ { ಸ್ಥಳೀಯ: eventTime.toLocaleString(navigator.language, ಆಯ್ಕೆಗಳು), ಗುರಿ: targetTime.toLocaleString(navigator.language, ಆಯ್ಕೆಗಳು) }; }
ಸ್ಥಿರ ವೇಳಾಪಟ್ಟಿ = 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 ಗೆ ರವಾನಿಸಿದರೆ, Temporal ನಮಗೆ ವಿನಾಯಿತಿಯನ್ನು ನೀಡುತ್ತದೆ. ಗಮನಿಸಬೇಕಾದ ಒಂದು ವಿಷಯವೆಂದರೆ ಕಟ್ಟುನಿಟ್ಟಾದ ಪಾರ್ಸಿಂಗ್ನೊಂದಿಗೆ, ಕ್ಷಣ ಆವೃತ್ತಿಯು ಇನ್ನೂ ಹೆಚ್ಚು ಮೃದುವಾಗಿರುತ್ತದೆ. ಟೆಂಪೊರಲ್ಗೆ ಸ್ಟ್ರಿಂಗ್ನ ಕೊನೆಯಲ್ಲಿ ಸಮಯ ವಲಯ ಆಫ್ಸೆಟ್ ಅಗತ್ಯವಿದೆ. ನಾವು 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) ಸಮಯವನ್ನು ಸೇರಿಸಿ .ಸೇರಿಸು(7, 'ದಿನಗಳು') (ರೂಪಾಂತರಗಳು) .ಸೇರಿಸು({ದಿನಗಳು: 7 }) (ಹೊಸ ವಸ್ತು) ವ್ಯತ್ಯಾಸ .diff(ಇತರ, 'ಗಂಟೆಗಳು') .ಇನ್(ಇತರ).ಗಂಟೆಗಳಿಂದ ಸಮಯ ವಲಯ .tz('ವಲಯ/ಹೆಸರು') .withTimeZone('ವಲಯ/ಹೆಸರು')
ಮೊದಲ ನೋಟದಲ್ಲಿ, ವ್ಯತ್ಯಾಸವು ಸ್ವಲ್ಪ ಭಿನ್ನವಾಗಿರಬಹುದು (ಮತ್ತು ತಾತ್ಕಾಲಿಕ, ಕೆಲವೊಮ್ಮೆ ಹೆಚ್ಚು ಮೌಖಿಕ ಮತ್ತು ಹೆಚ್ಚು ಕಟ್ಟುನಿಟ್ಟಾದ ಸಂದರ್ಭದಲ್ಲಿ) ಸಿಂಟ್ಯಾಕ್ಸ್, ಆದರೆ Moment.js ನಲ್ಲಿ ಟೆಂಪೊರಲ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ ಹಲವಾರು ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳಿವೆ:
ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗಿರುವುದು ಎಂದರೆ ಕಡಿಮೆ ಆಶ್ಚರ್ಯಗಳು ಮತ್ತು ಅನಪೇಕ್ಷಿತ ದೋಷಗಳು. ಕ್ಷಣವು ಹೆಚ್ಚು ಸೌಮ್ಯವಾಗಿರುವಂತೆ ತೋರಬಹುದು, ಆದರೆ ಇದು "ಊಹೆಯನ್ನು" ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು ಕೆಲವೊಮ್ಮೆ ತಪ್ಪಾದ ದಿನಾಂಕಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ನೀವು ತಾತ್ಕಾಲಿಕವಾಗಿ ಏನಾದರೂ ಅಮಾನ್ಯವನ್ನು ನೀಡಿದರೆ, ಅದು ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ. ಕೋಡ್ ರನ್ ಆಗಿದ್ದರೆ, ನೀವು ಮಾನ್ಯವಾದ ದಿನಾಂಕವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೀರಿ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ. ಕ್ಷಣವು ಅಪ್ಲಿಕೇಶನ್ನ ಬಂಡಲ್ಗೆ ಗಮನಾರ್ಹ ಗಾತ್ರವನ್ನು ಸೇರಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ನೀವು ಕ್ಷಣ-ಸಮಯ ವಲಯ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ. ಟೆಂಪೊರಲ್ ಏನನ್ನೂ ಸೇರಿಸುವುದಿಲ್ಲ (ಒಮ್ಮೆ ಅದನ್ನು ನಿಮ್ಮ ಗುರಿ ಬ್ರೌಸರ್ಗಳಲ್ಲಿ ರವಾನಿಸಲಾಗುತ್ತದೆ). ದಿನಾಂಕ ಪರಿವರ್ತನೆಗಳು ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ನೀವು ಎಂದಿಗೂ ಡೇಟಾವನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ಅಥವಾ ಓವರ್ರೈಟ್ ಮಾಡುವುದಿಲ್ಲ ಎಂಬ ವಿಶ್ವಾಸವನ್ನು ಅಸ್ಥಿರತೆಯು ನಿಮಗೆ ನೀಡುತ್ತದೆ. ನಿಮ್ಮ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅವಲಂಬಿಸಿ ಸಮಯದ ವಿಭಿನ್ನ ಪ್ರಾತಿನಿಧ್ಯಗಳು (ತತ್ಕ್ಷಣ, ಸರಳ ದಿನಾಂಕ ಸಮಯ, ಝೋನೆಡ್ಡೇಟ್ಟೈಮ್), ಅಲ್ಲಿ ಕ್ಷಣವು ಯಾವಾಗಲೂ ಯುಟಿಸಿ ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ನ ಸುತ್ತ ಸುತ್ತುತ್ತದೆ. Temporal ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ಗಾಗಿ Intl API ಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಅಂದರೆ ನೀವು ಟೋಕನ್ಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸದೆಯೇ ಲೊಕೇಲ್-ಅವೇರ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಹೊಂದಬಹುದು.
ಪಾಲಿಫಿಲ್ ಕುರಿತು ಟಿಪ್ಪಣಿಗಳು ಮೊದಲೇ ಹೇಳಿದಂತೆ, @js-temporal/polyfill ಹೆಸರಿನ npm ಪ್ಯಾಕೇಜ್ನಂತೆ ವಿತರಿಸಲಾದ ತಾತ್ಕಾಲಿಕ ಪಾಲಿಫಿಲ್ ಲಭ್ಯವಿದೆ. ನೀವು ಇಂದು ಟೆಂಪೊರಲ್ ಅನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ, ಇನ್ನೂ API ಅನ್ನು ರವಾನಿಸದ Safari ನಂತಹ ಬ್ರೌಸರ್ಗಳನ್ನು ಬೆಂಬಲಿಸಲು ನಿಮಗೆ ಈ ಪಾಲಿಫಿಲ್ ಅಗತ್ಯವಿದೆ. ಇದರೊಂದಿಗೆ ಕೆಟ್ಟ ಸುದ್ದಿ ಎಂದರೆ ಅದು ನಿಮ್ಮ ಬಂಡಲ್ ಗಾತ್ರಕ್ಕೆ ಸೇರಿಸುತ್ತದೆ. ಒಳ್ಳೆಯ ಸುದ್ದಿ ಏನೆಂದರೆ, ಇದು ಇನ್ನೂ ಕ್ಷಣ ಅಥವಾ ಕ್ಷಣ-ಸಮಯ ವಲಯಕ್ಕಿಂತ ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಸೇರಿಸುತ್ತದೆ. Bundlephobia.com ವರದಿ ಮಾಡಿರುವಂತೆ ಬಂಡಲ್ ಗಾತ್ರಗಳ ಹೋಲಿಕೆ ಇಲ್ಲಿದೆ, npm ಪ್ಯಾಕೇಜ್ ಗಾತ್ರಗಳ ಮಾಹಿತಿಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುವ ವೆಬ್ಸೈಟ್ (ಬಂಡಲ್ಫೋಬಿಯಾ ವಿಶ್ಲೇಷಣೆಯನ್ನು ನೋಡಲು ಪ್ರತಿ ಪ್ಯಾಕೇಜ್ ಹೆಸರಿನ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ):
ಪ್ಯಾಕೇಜ್ ಮಿನಿಫೈಡ್ ಮಿನಿಫೈಡ್ & ಜಿಜಿಪ್ಡ್ @js-temporal/polyfill 154.1 ಕೆಬಿ 44.1 ಕೆಬಿ ಕ್ಷಣ 294.4 ಕೆಬಿ 75.4 ಕೆಬಿ ಕ್ಷಣ-ಸಮಯವಲಯ 1 MB 114.2 ಕೆಬಿ
ಪಾಲಿಫಿಲ್ ಐತಿಹಾಸಿಕವಾಗಿ ಮೆಮೊರಿ ಬಳಕೆಯ ಸುತ್ತ ಕೆಲವು ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಬರೆಯುವ ಸಮಯದಲ್ಲಿ, ಇದು ಆಲ್ಫಾ ಸ್ಥಿತಿಯಲ್ಲಿದೆ ಎಂದು ಪರಿಗಣಿಸಲಾಗಿದೆ. ಈ ಕಾರಣದಿಂದಾಗಿ, ಅದು ಹೆಚ್ಚು ಪ್ರಬುದ್ಧ ಸ್ಥಿತಿಯನ್ನು ತಲುಪುವವರೆಗೆ ನೀವು ಅದನ್ನು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಬಳಸಲು ಬಯಸುವುದಿಲ್ಲ. ಇನ್ನೊಂದು ಒಳ್ಳೆಯ ಸುದ್ದಿ ಏನೆಂದರೆ ಪಾಲಿಫಿಲ್ ಹೆಚ್ಚು ಸಮಯ ಬೇಕಾಗುವುದಿಲ್ಲ (ನೀವು ಹಳೆಯ ಬ್ರೌಸರ್ಗಳನ್ನು ಬೆಂಬಲಿಸುವ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ). ಬರೆಯುವ ಸಮಯದಲ್ಲಿ, Temporal ಅನ್ನು Chrome, Edge, ಮತ್ತು Firefox ನಲ್ಲಿ ರವಾನಿಸಲಾಗಿದೆ. ಇದು ಸಫಾರಿಯಲ್ಲಿ ಇನ್ನೂ ಸಿದ್ಧವಾಗಿಲ್ಲ, ಆದರೂ ಇದು ಇತ್ತೀಚಿನ ತಂತ್ರಜ್ಞಾನ ಪೂರ್ವವೀಕ್ಷಣೆಯಲ್ಲಿ ರನ್ಟೈಮ್ ಫ್ಲ್ಯಾಗ್ನೊಂದಿಗೆ ಲಭ್ಯವಿರುತ್ತದೆ.
