ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ API: ಟೈಮ್‌ಝೋನ್-ಅರಿವಿನ ದಿನಾಂಕದ ಲೆಕ್ಕಾಚಾರಗಳಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ

ಇಂದಿನ ಅಂತರ್ಸಂಪರ್ಕಿತ ಜಗತ್ತಿನಲ್ಲಿ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಆಗಾಗ್ಗೆ ವಿವಿಧ ಟೈಮ್‌ಝೋನ್‌ಗಳಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ. ನೀವು ಜಾಗತಿಕ ಇ-ಕಾಮರ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್, ಶೆಡ್ಯೂಲಿಂಗ್ ಟೂಲ್, ಅಥವಾ ಹಣಕಾಸಿನ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ನಿಖರವಾದ ಟೈಮ್‌ಝೋನ್-ಅರಿವಿನ ದಿನಾಂಕದ ಲೆಕ್ಕಾಚಾರಗಳು ನಿರ್ಣಾಯಕವಾಗಿವೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ, ಟೈಮ್‌ಝೋನ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಮಿತಿಗಳನ್ನು ಹೊಂದಿತ್ತು, ಆದರೆ ಟೆಂಪೊರಲ್ API, ಒಂದು ಹೊಸ ಮಾನದಂಡ, ಈ ಸವಾಲುಗಳನ್ನು ನೇರವಾಗಿ ಎದುರಿಸುತ್ತದೆ. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ ಟೆಂಪೊರಲ್ API ಯ ಬಗ್ಗೆ ಆಳವಾಗಿ ಚರ್ಚಿಸುತ್ತದೆ, ಅದರ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ ಮತ್ತು ಸಂಕೀರ್ಣ ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಖರತೆ ಮತ್ತು ಸುಲಭವಾಗಿ ಹೇಗೆ ಮಾಡುವುದು ಎಂದು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಟೈಮ್‌ಝೋನ್ ನಿರ್ವಹಣೆಯ ಸವಾಲುಗಳು

ಟೆಂಪೊರಲ್ API ಗಿಂತ ಮೊದಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗಳು ಅಂತರ್ನಿರ್ಮಿತ Date ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಅವಲಂಬಿಸಿದ್ದರು. ಕಾರ್ಯಸಾಧ್ಯವಾಗಿದ್ದರೂ, ಟೈಮ್‌ಝೋನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ Date ಆಬ್ಜೆಕ್ಟ್ ಹಲವಾರು ನ್ಯೂನತೆಗಳನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತದೆ:

• ಅಸಮಂಜಸ ನಡವಳಿಕೆ: ಬ್ರೌಸರ್ ಅಥವಾ ಸರ್ವರ್‌ನ ಸ್ಥಳೀಯ ಟೈಮ್‌ಝೋನ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿ Date ಆಬ್ಜೆಕ್ಟ್‌ನ ನಡವಳಿಕೆ ಬದಲಾಗುತ್ತದೆ. ಇದು ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ನಿರೂಪಣೆಗಳನ್ನು ಊಹಿಸಲು ಮತ್ತು ನಿಯಂತ್ರಿಸಲು ಕಷ್ಟವಾಗಿಸುತ್ತದೆ.
• ಬದಲಾಯಿಸಬಹುದಾದ ಸ್ಥಿತಿ: Date ಆಬ್ಜೆಕ್ಟ್ ಬದಲಾಯಿಸಬಹುದಾದದ್ದು, ಅಂದರೆ ಅದರ ಮೌಲ್ಯಗಳನ್ನು ನೇರವಾಗಿ ಮಾರ್ಪಡಿಸಬಹುದು. ಇದು ಅನಿರೀಕ್ಷಿತ ಅಡ್ಡ ಪರಿಣಾಮಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವುದನ್ನು ಹೆಚ್ಚು ಸಂಕೀರ್ಣಗೊಳಿಸುತ್ತದೆ.
• ಸ್ಪಷ್ಟತೆಯ ಕೊರತೆ: Date ಆಬ್ಜೆಕ್ಟ್‌ನ ವಿಧಾನಗಳು ಅಸ್ಪಷ್ಟವಾಗಿರಬಹುದು ಮತ್ತು ಉದ್ದೇಶಿತ ಟೈಮ್‌ಝೋನ್ ಅಥವಾ ಫಾರ್ಮ್ಯಾಟ್ ಅನ್ನು ಗ್ರಹಿಸಲು ಕಷ್ಟವಾಗಿಸುತ್ತದೆ.
• ಟೈಮ್‌ಝೋನ್ ಪರಿವರ್ತನೆಗಳು: ಅಂತರ್ನಿರ್ಮಿತ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಖರವಾದ ಟೈಮ್‌ಝೋನ್ ಪರಿವರ್ತನೆಗಳನ್ನು ಮಾಡಲು ಆಗಾಗ್ಗೆ ಸಂಕೀರ್ಣ ಲೆಕ್ಕಾಚಾರಗಳು ಮತ್ತು ಮೂರನೇ-ಪಕ್ಷದ ಲೈಬ್ರರಿಗಳು ಬೇಕಾಗುತ್ತವೆ, ಇದು ಕೋಡ್‌ಗೆ ಸಂಕೀರ್ಣತೆಯನ್ನು ಸೇರಿಸುತ್ತದೆ.

ಈ ಮಿತಿಗಳು ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಅಂತರರಾಷ್ಟ್ರೀಯ ಬಳಕೆದಾರರು ಅಥವಾ ವಿವಿಧ ಟೈಮ್‌ಝೋನ್‌ಗಳಲ್ಲಿ ಈವೆಂಟ್‌ಗಳನ್ನು ನಿಗದಿಪಡಿಸಬೇಕಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ಉದಾಹರಣೆಗೆ, ಸಭೆಗಳನ್ನು ನಿಗದಿಪಡಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಅಪ್ಲಿಕೇಶನ್ ಸರಿಯಾಗಿ ಟೈಮ್‌ಝೋನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸದಿದ್ದರೆ, ವಿವಿಧ ಸ್ಥಳಗಳಲ್ಲಿರುವ ಬಳಕೆದಾರರು ಗಮನಾರ್ಹ ಶೆಡ್ಯೂಲಿಂಗ್ ಸಂಘರ್ಷಗಳನ್ನು ಅನುಭವಿಸಬಹುದು.

ಟೆಂಪೊರಲ್ API ಪರಿಚಯ

ಟೆಂಪೊರಲ್ API ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಗೆ ಒಂದು ಹೊಸ ಪ್ರಸ್ತಾಪವಾಗಿದೆ, ಪ್ರಸ್ತುತ TC39 ಪ್ರಕ್ರಿಯೆಯ ಹಂತ 3 ರಲ್ಲಿದೆ, ಅಂದರೆ ಇದು ಮಾನದಂಡವಾಗುವ ಹಾದಿಯಲ್ಲಿದೆ. ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಟೈಮ್‌ಝೋನ್ ನಿರ್ವಹಣೆ ಸೇರಿದಂತೆ ದಿನಾಂಕ ಮತ್ತು ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಒಂದು ದೃಢವಾದ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿದೆ. ಟೆಂಪೊರಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ Date ಆಬ್ಜೆಕ್ಟ್‌ಗಿಂತ ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ:

• ಅಪರಿವರ್ತನೀಯತೆ: ಟೆಂಪೊರಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಪರಿವರ್ತನೀಯವಾಗಿವೆ. ಒಮ್ಮೆ ರಚಿಸಿದ ನಂತರ, ಅವುಗಳ ಮೌಲ್ಯಗಳನ್ನು ನೇರವಾಗಿ ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ, ಇದು ಸುರಕ್ಷಿತ ಮತ್ತು ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ.
• ಸ್ಪಷ್ಟತೆ ಮತ್ತು ನಿಖರತೆ: API ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ನಿರ್ವಹಣೆಗಾಗಿ ಸ್ಪಷ್ಟ ಮತ್ತು ನಿಖರವಾದ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅಸ್ಪಷ್ಟತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಟೈಮ್‌ಝೋನ್ ಬೆಂಬಲ: ಟೆಂಪೊರಲ್ API ಟೈಮ್‌ಝೋನ್‌ಗಳಿಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ವಿವಿಧ ಟೈಮ್‌ಝೋನ್‌ಗಳ ನಡುವೆ ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಡೇಲೈಟ್ ಸೇವಿಂಗ್ ಟೈಮ್ (DST) ಅನ್ನು ನಿರ್ವಹಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
• ಸರಳೀಕೃತ ಲೆಕ್ಕಾಚಾರಗಳು: API ದಿನಗಳು, ತಿಂಗಳುಗಳು, ಅಥವಾ ವರ್ಷಗಳನ್ನು ಸೇರಿಸುವುದು ಮತ್ತು ಎರಡು ದಿನಾಂಕಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವಂತಹ ಸಾಮಾನ್ಯ ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
• ಆಧುನಿಕ ವಿನ್ಯಾಸ: API ಅನ್ನು ಆಧುನಿಕ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ದಿನಾಂಕ ಮತ್ತು ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.

ಟೆಂಪೊರಲ್ API ಯಲ್ಲಿನ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು

ಟೆಂಪೊರಲ್ API ಹಲವಾರು ಹೊಸ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಮತ್ತು ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ, ಅವುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ:

• Temporal.Instant: ಯಾವುದೇ ಟೈಮ್‌ಝೋನ್‌ಗೆ ಸ್ವತಂತ್ರವಾಗಿ, ಸಮಯದ ನಿರ್ದಿಷ್ಟ ಬಿಂದುವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದು ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಆಧರಿಸಿದೆ, ಇದು ಸಮಯದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳಲು ಸೂಕ್ತವಾಗಿದೆ.
• Temporal.ZonedDateTime: ಟೈಮ್‌ಝೋನ್‌ನೊಂದಿಗೆ ಸಮಯದ ನಿರ್ದಿಷ್ಟ ಬಿಂದುವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದು ಇನ್‌ಸ್ಟಂಟ್ ಅನ್ನು ಟೈಮ್‌ಝೋನ್ ಆಫ್‌ಸೆಟ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ.
• Temporal.PlainDate: ಸಮಯ ಅಥವಾ ಟೈಮ್‌ಝೋನ್ ಇಲ್ಲದೆ ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕವನ್ನು (ವರ್ಷ, ತಿಂಗಳು, ದಿನ) ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• Temporal.PlainTime: ದಿನಾಂಕ ಅಥವಾ ಟೈಮ್‌ಝೋನ್ ಇಲ್ಲದೆ ನಿರ್ದಿಷ್ಟ ಸಮಯವನ್ನು (ಗಂಟೆ, ನಿಮಿಷ, ಸೆಕೆಂಡ್, ಮತ್ತು ಐಚ್ಛಿಕವಾಗಿ ಮಿಲಿಸೆಕೆಂಡ್ ಮತ್ತು ಮೈಕ್ರೋಸೆಕೆಂಡ್) ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• Temporal.PlainDateTime: ಟೈಮ್‌ಝೋನ್ ಇಲ್ಲದೆ ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• Temporal.TimeZone: 'America/Los_Angeles' ಅಥವಾ 'Europe/London' ನಂತಹ ಟೈಮ್‌ಝೋನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• Temporal.Duration: '2 ದಿನಗಳು, 5 ಗಂಟೆಗಳು, ಮತ್ತು 30 ನಿಮಿಷಗಳು' ನಂತಹ ಸಮಯದ ಅವಧಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

ಟೆಂಪೊರಲ್ API ಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು

ಟೆಂಪೊರಲ್ API ಇನ್ನೂ ಎಲ್ಲಾ ಬ್ರೌಸರ್‌ಗಳು ಮತ್ತು Node.js ಆವೃತ್ತಿಗಳಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಲಭ್ಯವಿಲ್ಲ. ಆದಾಗ್ಯೂ, ನೀವು ಅಧಿಕೃತ ಟೆಂಪೊರಲ್ ಪಾಲಿಫಿಲ್‌ನಂತಹ ಪಾಲಿಫಿಲ್ ಅನ್ನು ಬಳಸಿ ಇಂದೇ API ಯೊಂದಿಗೆ ಪ್ರಯೋಗವನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ಈ ಪಾಲಿಫಿಲ್ ಮಾನದಂಡದಂತೆಯೇ ಅದೇ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಸ್ಥಳೀಯ API ಅನ್ನು ಇನ್ನೂ ಬೆಂಬಲಿಸದ ಪರಿಸರದಲ್ಲಿಯೂ ನಿಮ್ಮ ಕೋಡ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

npm ಬಳಸಿ ಟೆಂಪೊರಲ್ ಪಾಲಿಫಿಲ್ ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಲು, ರನ್ ಮಾಡಿ:

            npm install @js-temporal/polyfill
            

              
                Copy
              
            
          

ನಂತರ, ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನಲ್ಲಿ, ನೀವು ಪಾಲಿಫಿಲ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿ ಮತ್ತು ಇನಿಶಿಯಲೈಸ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ:

            import { Temporal } from '@js-temporal/polyfill';

// Or, in a CommonJS environment:
// const { Temporal } = require('@js-temporal/polyfill');
            

              
                Copy
              
            
          

ಪಾಲಿಫಿಲ್ ಇನ್‌ಸ್ಟಾಲ್ ಮತ್ತು ಇಂಪೋರ್ಟ್ ಆದ ನಂತರ, ನೀವು ಟೆಂಪೊರಲ್ API ಅನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು. ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ.

ಟೈಮ್‌ಝೋನ್-ಅರಿವಿನ ದಿನಾಂಕದ ಲೆಕ್ಕಾಚಾರಗಳ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

1. ZonedDateTime ಅನ್ನು ರಚಿಸುವುದು

ಒಂದು ZonedDateTime ಅನ್ನು ರಚಿಸಲು, ನಿಮಗೆ ಒಂದು ಇನ್‌ಸ್ಟಂಟ್ ಮತ್ತು ಒಂದು ಟೈಮ್‌ಝೋನ್ ಬೇಕು:

            import { Temporal } from '@js-temporal/polyfill';

const instant = Temporal.Instant.fromEpochSeconds(1678886400); // March 15, 2023 00:00:00 UTC
const timezone = Temporal.TimeZone.from('America/Los_Angeles');
const zonedDateTime = instant.toZonedDateTime(timezone);

console.log(zonedDateTime.toString()); // 2023-03-14T17:00:00-07:00[America/Los_Angeles]
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ನಿಂದ Temporal.Instant ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಅದನ್ನು 'America/Los_Angeles' ಟೈಮ್‌ಝೋನ್‌ನಲ್ಲಿ ZonedDateTime ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತೇವೆ. ಔಟ್‌ಪುಟ್ ಲಾಸ್ ಏಂಜಲೀಸ್‌ನಲ್ಲಿನ ಸ್ಥಳೀಯ ಸಮಯವನ್ನು ಹೇಗೆ ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ, ಟೈಮ್‌ಝೋನ್ ಆಫ್‌ಸೆಟ್ ಅನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

2. ಟೈಮ್‌ಝೋನ್‌ಗಳ ನಡುವೆ ಪರಿವರ್ತಿಸುವುದು

ಟೈಮ್‌ಝೋನ್‌ಗಳ ನಡುವೆ ಪರಿವರ್ತಿಸುವುದು ಟೆಂಪೊರಲ್ API ಯ ಒಂದು ಪ್ರಮುಖ ಕಾರ್ಯವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಆ ಲಾಸ್ ಏಂಜಲೀಸ್ ಸಮಯವನ್ನು ಲಂಡನ್ ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸೋಣ:

            import { Temporal } from '@js-temporal/polyfill';

const instant = Temporal.Instant.fromEpochSeconds(1678886400);
const losAngelesTimezone = Temporal.TimeZone.from('America/Los_Angeles');
const londonTimezone = Temporal.TimeZone.from('Europe/London');
const losAngelesZonedDateTime = instant.toZonedDateTime(losAngelesTimezone);

const londonZonedDateTime = losAngelesZonedDateTime.withTimeZone(londonTimezone);

console.log(londonZonedDateTime.toString()); // 2023-03-15T00:00:00+00:00[Europe/London]
            

              
                Copy
              
            
          

ಇಲ್ಲಿ, ನಾವು ಲಾಸ್ ಏಂಜಲೀಸ್‌ನಿಂದ ಲಂಡನ್‌ಗೆ ZonedDateTime ಅನ್ನು ಪರಿವರ್ತಿಸುತ್ತೇವೆ. ಔಟ್‌ಪುಟ್ ಲಂಡನ್‌ನಲ್ಲಿ ಸಮಾನವಾದ ಸಮಯವನ್ನು ತೋರಿಸುತ್ತದೆ, ಸಮಯದ ವ್ಯತ್ಯಾಸ ಮತ್ತು ಯಾವುದೇ DST ಹೊಂದಾಣಿಕೆಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

3. ಸಮಯದ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು

ಎರಡು ದಿನಾಂಕಗಳು ಅಥವಾ ಸಮಯಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ಸರಳವಾಗಿದೆ:

            import { Temporal } from '@js-temporal/polyfill';

const date1 = Temporal.PlainDate.from('2023-03-15');
const date2 = Temporal.PlainDate.from('2023-03-20');

const duration = date2.until(date1);

console.log(duration.toString()); // -P5D

const duration2 = date1.until(date2);

console.log(duration2.toString()); // P5D
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು PlainDate ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಎರಡು ದಿನಾಂಕಗಳ ನಡುವಿನ ಅವಧಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಫಲಿತಾಂಶವು Duration ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ, ಇದನ್ನು ಮುಂದಿನ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಬಳಸಬಹುದು.

4. ಸಮಯವನ್ನು ಸೇರಿಸುವುದು ಮತ್ತು ಕಳೆಯುವುದು

ಸಮಯದ ಘಟಕಗಳನ್ನು ಸೇರಿಸುವುದು ಅಥವಾ ಕಳೆಯುವುದು ಸಹ ಸರಳೀಕೃತವಾಗಿದೆ:

            import { Temporal } from '@js-temporal/polyfill';

const now = Temporal.Now.zonedDateTime('America/New_York');
const tomorrow = now.add({ days: 1 });
const oneHourAgo = now.subtract({ hours: 1 });

console.log(tomorrow.toString());
console.log(oneHourAgo.toString());
            

              
                Copy
              
            
          

ಈ ಕೋಡ್ 'America/New_York' ಟೈಮ್‌ಝೋನ್‌ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಸಮಯದಿಂದ ಒಂದು ದಿನವನ್ನು ಸೇರಿಸುವುದನ್ನು ಮತ್ತು ಒಂದು ಗಂಟೆಯನ್ನು ಕಳೆಯುವುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಟೆಂಪೊರಲ್ API DST ಪರಿವರ್ತನೆಗಳನ್ನು ಸುಲಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ.

5. ಪ್ಲೇನ್ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

ಟೆಂಪೊರಲ್ API ಯಾವುದೇ ಟೈಮ್‌ಝೋನ್‌ಗೆ ಸ್ವತಂತ್ರವಾಗಿ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು PlainDate, PlainTime, ಮತ್ತು PlainDateTime ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಸಹ ಒದಗಿಸುತ್ತದೆ.

            import { Temporal } from '@js-temporal/polyfill';

const plainDate = Temporal.PlainDate.from('2023-10-27');
const plainTime = Temporal.PlainTime.from('14:30:00');
const plainDateTime = Temporal.PlainDateTime.from('2023-10-27T14:30:00');

console.log(plainDate.toString());     // 2023-10-27
console.log(plainTime.toString());     // 14:30:00
console.log(plainDateTime.toString()); // 2023-10-27T14:30:00
            

              
                Copy
              
            
          

ಈ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಹುಟ್ಟುಹಬ್ಬಗಳು ಅಥವಾ ಈವೆಂಟ್ ಪ್ರಾರಂಭದ ಸಮಯಗಳಂತಹ ಟೈಮ್‌ಝೋನ್‌ಗಳ ಸಂಕೀರ್ಣತೆ ಇಲ್ಲದೆ ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಉಪಯುಕ್ತವಾಗಿವೆ.

ಟೆಂಪೊರಲ್ API ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಟೆಂಪೊರಲ್ API ಅನ್ನು ಬಳಸುವಾಗ ಪರಿಗಣಿಸಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• ಯಾವಾಗಲೂ ಟೈಮ್‌ಝೋನ್‌ಗಳನ್ನು ಬಳಸಿ: ವಿವಿಧ ಪ್ರದೇಶಗಳಲ್ಲಿ ಸಂಬಂಧಿತವಾಗಿರಬಹುದಾದ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ, ಯಾವಾಗಲೂ ಟೈಮ್‌ಝೋನ್‌ಗಳನ್ನು ಬಳಸಿ. ಇದು ಅಸ್ಪಷ್ಟತೆಯನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ನಿಖರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಡೇಟಾವನ್ನು UTC ಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ: ಡೇಟಾಬೇಸ್ ಅಥವಾ ಇತರ ನಿರಂತರ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು, ಟೈಮ್‌ಝೋನ್-ಸಂಬಂಧಿತ ತೊಡಕುಗಳನ್ನು ತಪ್ಪಿಸಲು UTC (ಸಮನ್ವಯ ಸಾರ್ವತ್ರಿಕ ಸಮಯ) ಬಳಸಿ.
• ಪ್ರದರ್ಶನಕ್ಕಾಗಿ ಪರಿವರ್ತಿಸಿ: ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ಪ್ರದರ್ಶನ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮಾತ್ರ ಬಳಕೆದಾರರ ಸ್ಥಳೀಯ ಟೈಮ್‌ಝೋನ್‌ಗೆ ಪರಿವರ್ತಿಸಿ.
• ಅಪರಿವರ್ತನೀಯತೆಯನ್ನು ಬಳಸಿ: ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಬರೆಯಲು ಟೆಂಪೊರಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಅಪರಿವರ್ತನೀಯತೆಯನ್ನು ಬಳಸಿಕೊಳ್ಳಿ. ಟೆಂಪೊರಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ನೇರವಾಗಿ ಮಾರ್ಪಡಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ.
• ಸರಿಯಾದ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ: ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಸೂಕ್ತವಾದ ಟೆಂಪೊರಲ್ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರವನ್ನು (Instant, ZonedDateTime, PlainDate, ಇತ್ಯಾದಿ) ಆಯ್ಕೆಮಾಡಿ.
• DST ಪರಿವರ್ತನೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ: ಡೇಲೈಟ್ ಸೇವಿಂಗ್ ಟೈಮ್ (DST) ಪರಿವರ್ತನೆಗಳ ಬಗ್ಗೆ ಮತ್ತು ಅವು ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಲೆಕ್ಕಾಚಾರಗಳ ಮೇಲೆ ಹೇಗೆ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ ಎಂಬುದರ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ. ಟೆಂಪೊರಲ್ API DST ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ದೋಷನಿವಾರಣೆಯಲ್ಲಿ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಪರಿಗಣಿಸಿ: ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ, ಟೈಮ್‌ಝೋನ್‌ಗಳು ಮತ್ತು ದಿನಾಂಕ/ಸಮಯ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸ್ಪಷ್ಟ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ ನಿಯಂತ್ರಣಗಳನ್ನು ಒದಗಿಸಿ. ಬಳಕೆದಾರರ ಸ್ಥಳೀಯ ಆದ್ಯತೆಗಳು ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ರೂಢಿಗಳನ್ನು ಪರಿಗಣಿಸಿ.

ಟೆಂಪೊರಲ್ API ಯ ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು

ಟೆಂಪೊರಲ್ API ಅತ್ಯಂತ ಬಹುಮುಖವಾಗಿದೆ ಮತ್ತು ಅನೇಕ ಕೈಗಾರಿಕೆಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಅನ್ವಯಯೋಗ್ಯವಾಗಿದೆ:

• ಇ-ಕಾಮರ್ಸ್: ವಿವಿಧ ಟೈಮ್‌ಝೋನ್‌ಗಳಲ್ಲಿ ಉತ್ಪನ್ನ ಬಿಡುಗಡೆ ಸಮಯಗಳು, ಪ್ರಚಾರದ ಅವಧಿಗಳು ಮತ್ತು ಆರ್ಡರ್ ಪೂರೈಕೆಯನ್ನು ನಿರ್ವಹಿಸುವುದು.
• ಶೆಡ್ಯೂಲಿಂಗ್ ಮತ್ತು ಕ್ಯಾಲೆಂಡರಿಂಗ್: ಟೈಮ್‌ಝೋನ್ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು, ವಿಶ್ವಾದ್ಯಂತ ಬಳಕೆದಾರರಿಗಾಗಿ ಅಪಾಯಿಂಟ್‌ಮೆಂಟ್‌ಗಳು, ಸಭೆಗಳು ಮತ್ತು ಈವೆಂಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು ಮತ್ತು ನಿರ್ವಹಿಸುವುದು.
• ಹಣಕಾಸು ಅಪ್ಲಿಕೇಶನ್‌ಗಳು: ವಿವಿಧ ಹಣಕಾಸು ಮಾರುಕಟ್ಟೆಗಳಲ್ಲಿ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಬಡ್ಡಿ ದರಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು, ವಹಿವಾಟುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಮತ್ತು ವರದಿಗಳನ್ನು ರಚಿಸುವುದು.
• ಪ್ರಯಾಣ ಮತ್ತು ಆತಿಥ್ಯ: ಟೈಮ್‌ಝೋನ್‌ಗಳು ಮತ್ತು ಪ್ರಯಾಣದ ದಿನಾಂಕಗಳನ್ನು ಪರಿಗಣಿಸಿ ವಿಮಾನಗಳು, ಹೋಟೆಲ್‌ಗಳು ಮತ್ತು ಚಟುವಟಿಕೆಗಳನ್ನು ಬುಕ್ ಮಾಡುವುದು.
• ಯೋಜನಾ ನಿರ್ವಹಣೆ: ಭೌಗೋಳಿಕವಾಗಿ ಹರಡಿರುವ ತಂಡಗಳಲ್ಲಿ ಯೋಜನೆಯ ಗಡುವುಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು, ಕಾರ್ಯಗಳನ್ನು ಹಂಚುವುದು ಮತ್ತು ಪ್ರಗತಿಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದು.
• ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ ವೇದಿಕೆಗಳು: ವಿಶ್ವಾದ್ಯಂತ ಬಳಕೆದಾರರಿಗೆ ಸರಿಯಾದ ಸ್ಥಳೀಯ ಸಮಯದಲ್ಲಿ ಪೋಸ್ಟ್‌ಗಳನ್ನು ನಿಗದಿಪಡಿಸುವುದು ಮತ್ತು ವಿಷಯವನ್ನು ಪ್ರದರ್ಶಿಸುವುದು.

ತೀರ್ಮಾನ: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಭವಿಷ್ಯವನ್ನು ಅಪ್ಪಿಕೊಳ್ಳುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ API ದಿನಾಂಕ ಮತ್ತು ಸಮಯದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ದೀರ್ಘಕಾಲದ ಸವಾಲುಗಳಿಗೆ, ವಿಶೇಷವಾಗಿ ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಬಳಕೆದಾರ-ಸ್ನೇಹಿ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತದೆ. ಅದರ ಅಪರಿವರ್ತನೀಯತೆ, ಸ್ಪಷ್ಟತೆ, ಮತ್ತು ದೃಢವಾದ ಟೈಮ್‌ಝೋನ್ ಬೆಂಬಲವು ಸಾಂಪ್ರದಾಯಿಕ Date ಆಬ್ಜೆಕ್ಟ್‌ಗಿಂತ ಗಮನಾರ್ಹ ಸುಧಾರಣೆಯಾಗಿದೆ. ಟೆಂಪೊರಲ್ API ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ, ನಿರ್ವಹಿಸಬಹುದಾದ ಮತ್ತು ಜಾಗತಿಕವಾಗಿ-ಅರಿವಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಟೆಂಪೊರಲ್ API ವ್ಯಾಪಕವಾಗಿ ಅಳವಡಿಕೆಯಾದಂತೆ, ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನಾವು ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ಕ್ರಾಂತಿಗೊಳಿಸುತ್ತದೆ. ಇಂದೇ ಟೆಂಪೊರಲ್ API ಯೊಂದಿಗೆ ಪ್ರಯೋಗವನ್ನು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ನಿರ್ವಹಣೆಯ ಭವಿಷ್ಯಕ್ಕಾಗಿ ಸಿದ್ಧರಾಗಿ.

API ಯ ಸಾಮರ್ಥ್ಯಗಳ ಬಗ್ಗೆ ಆಳವಾದ ತಿಳುವಳಿಕೆಯನ್ನು ಪಡೆಯಲು ಅಧಿಕೃತ ಟೆಂಪೊರಲ್ API ದಸ್ತಾವೇಜನ್ನು ಅನ್ವೇಷಿಸಲು ಮತ್ತು ಒದಗಿಸಿದ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಲು ಪರಿಗಣಿಸಿ. ನಿಖರತೆ, ಸ್ಪಷ್ಟತೆ, ಮತ್ತು ಬಳಕೆಯ ಸುಲಭತೆಯ ಮೇಲೆ ಗಮನಹರಿಸುವುದರೊಂದಿಗೆ, ಟೆಂಪೊರಲ್ API ವಿಶ್ವಾದ್ಯಂತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅನಿವಾರ್ಯ ಸಾಧನವಾಗಲು ಸಿದ್ಧವಾಗಿದೆ.

ಟೆಂಪೊರಲ್ API ಯ ಶಕ್ತಿಯನ್ನು ಅಪ್ಪಿಕೊಳ್ಳಿ ಮತ್ತು ಪ್ರಪಂಚದಾದ್ಯಂತ ಸಮಯ ಮತ್ತು ದಿನಾಂಕಗಳನ್ನು ಮನಬಂದಂತೆ ನಿರ್ವಹಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ!