M

MLOG

ಕನ್ನಡ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ APIಗೆ ಒಂದು ಆಳವಾದ ಮಾರ್ಗದರ್ಶಿ, ವೈವಿಧ್ಯಮಯ ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಂದರ್ಭಗಳಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಒಂದು ಆಧುನಿಕ ಪರಿಹಾರ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ API: ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಆಧುನಿಕ ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ನಿರ್ವಹಣೆ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ `Date` ಆಬ್ಜೆಕ್ಟ್ ಬಹಳ ಕಾಲದಿಂದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ನಿರಾಶೆಯ ಮೂಲವಾಗಿದೆ. ಅದರ ಬದಲಾಯಿಸಬಹುದಾದ ಸ್ವಭಾವ (mutability), ಅಸಂಗತ API, ಮತ್ತು ಕಳಪೆ ಟೈಮ್‌ಝೋನ್ ಬೆಂಬಲದಿಂದಾಗಿ, Moment.js ಮತ್ತು date-fns ನಂತಹ ಹಲವಾರು ಲೈಬ್ರರಿಗಳು ಈ ಕೊರತೆಗಳನ್ನು ತುಂಬಲು ಬಂದಿವೆ. ಈಗ, ಟೆಂಪೊರಲ್ APIಯೊಂದಿಗೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸುಧಾರಿತ ಸ್ಪಷ್ಟತೆ ಮತ್ತು ನಿಖರತೆಯೊಂದಿಗೆ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಆಧುನಿಕ, ಅಂತರ್ನಿರ್ಮಿತ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತದೆ. ಈ ಲೇಖನವು ಟೆಂಪೊರಲ್ APIಯ ಸಮಗ್ರ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅದರ ವೈಶಿಷ್ಟ್ಯಗಳು, ಪ್ರಯೋಜನಗಳು ಮತ್ತು ವೈವಿಧ್ಯಮಯ ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಂದರ್ಭಗಳಲ್ಲಿನ ಬಳಕೆಯ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತದೆ.

ಟೆಂಪೊರಲ್ API ಎಂದರೇನು?

ಟೆಂಪೊರಲ್ API ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಒಂದು ಹೊಸ, ಗ್ಲೋಬಲ್ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದ್ದು, ಇದನ್ನು `Date` ಆಬ್ಜೆಕ್ಟ್‌ನ ನ್ಯೂನತೆಗಳನ್ನು ನಿವಾರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಇದು ದಿನಾಂಕಗಳು, ಸಮಯಗಳು, ಟೈಮ್‌ಝೋನ್‌ಗಳು ಮತ್ತು ಕ್ಯಾಲೆಂಡರ್ ಸಿಸ್ಟಮ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಒಂದು ಸ್ಪಷ್ಟವಾದ, ಬದಲಾಯಿಸಲಾಗದ (immutable) API ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಮುಖ್ಯವಾಗಿ, ಇದು ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆ ಮತ್ತು ನಿರೀಕ್ಷೆಗಳಿಗೆ ಹೆಚ್ಚು ಹತ್ತಿರವಾಗುವಂತೆ ಪ್ರತಿನಿಧಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿದೆ, ಇದರಿಂದಾಗಿ ಅಂತರರಾಷ್ಟ್ರೀಕರಣವು ಹೆಚ್ಚು ಸರಳವಾಗುತ್ತದೆ.

ಪ್ರಮುಖ ವೈಶಿಷ್ಟ್ಯಗಳು:

ಮೂಲಭೂತ ಟೆಂಪೊರಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು

ಟೆಂಪೊರಲ್ API ಹಲವಾರು ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಕೆಲವು ಪ್ರಮುಖವಾದವುಗಳು:

ದಿನಾಂಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

`Temporal.PlainDate` ಅನ್ನು ರಚಿಸುವುದು

`Temporal.PlainDate` ಅನ್ನು ರಚಿಸಲು, ನೀವು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬಳಸಬಹುದು:

const plainDate = new Temporal.PlainDate(2024, 10, 27); // ವರ್ಷ, ತಿಂಗಳು (1-12), ದಿನ
console.log(plainDate.toString()); // ಔಟ್‌ಪುಟ್: 2024-10-27

ನೀವು `from` ಮೆಥಡ್ ಅನ್ನು ಕೂಡ ಬಳಸಬಹುದು, ಇದು ISO 8601 ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ:

const plainDateFromString = Temporal.PlainDate.from('2024-10-27');
console.log(plainDateFromString.toString()); // ಔಟ್‌ಪುಟ್: 2024-10-27

ದಿನಾಂಕದ ಘಟಕಗಳನ್ನು ಪಡೆಯುವುದು

ನೀವು `year`, `month`, ಮತ್ತು `day` ನಂತಹ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತ್ಯೇಕ ದಿನಾಂಕದ ಘಟಕಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:

console.log(plainDate.year); // ಔಟ್‌ಪುಟ್: 2024
console.log(plainDate.month); // ಔಟ್‌ಪುಟ್: 10
console.log(plainDate.day); // ಔಟ್‌ಪುಟ್: 27

ದಿನಾಂಕದ ಅಂಕಗಣಿತ

ದಿನಗಳು, ವಾರಗಳು, ತಿಂಗಳುಗಳು, ಅಥವಾ ವರ್ಷಗಳನ್ನು ಕೂಡಿಸಲು ಅಥವಾ ಕಳೆಯಲು, `plus` ಮತ್ತು `minus` ಮೆಥಡ್‌ಗಳನ್ನು ಬಳಸಿ. ಈ ಮೆಥಡ್‌ಗಳು ಹೊಸ `Temporal.PlainDate` ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ:

const nextWeek = plainDate.plus({ days: 7 });
console.log(nextWeek.toString()); // ಔಟ್‌ಪುಟ್: 2024-11-03

const lastMonth = plainDate.minus({ months: 1 });
console.log(lastMonth.toString()); // ಔಟ್‌ಪುಟ್: 2024-09-27

ದಿನಾಂಕಗಳನ್ನು ಹೋಲಿಸುವುದು

ನೀವು `compare` ಮೆಥಡ್ ಬಳಸಿ ದಿನಾಂಕಗಳನ್ನು ಹೋಲಿಸಬಹುದು:

const date1 = new Temporal.PlainDate(2024, 10, 27);
const date2 = new Temporal.PlainDate(2024, 11, 15);

console.log(Temporal.PlainDate.compare(date1, date2)); // ಔಟ್‌ಪುಟ್: -1 (date1, date2 ಗಿಂತ ಮೊದಲಿನದು)

ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

`Temporal.PlainTime` ಅನ್ನು ರಚಿಸುವುದು

`Temporal.PlainTime` ಅನ್ನು ರಚಿಸಲು, ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸಿ:

const plainTime = new Temporal.PlainTime(10, 30, 0); // ಗಂಟೆ, ನಿಮಿಷ, ಸೆಕೆಂಡ್
console.log(plainTime.toString()); // ಔಟ್‌ಪುಟ್: 10:30:00

ಅಥವಾ `from` ಮೆಥಡ್ ಅನ್ನು ISO 8601 ಸಮಯದ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಬಳಸಿ:

const plainTimeFromString = Temporal.PlainTime.from('10:30:00');
console.log(plainTimeFromString.toString()); // ಔಟ್‌ಪುಟ್: 10:30:00

ಸಮಯದ ಘಟಕಗಳನ್ನು ಪಡೆಯುವುದು

console.log(plainTime.hour); // ಔಟ್‌ಪುಟ್: 10
console.log(plainTime.minute); // ಔಟ್‌ಪುಟ್: 30
console.log(plainTime.second); // ಔಟ್‌ಪುಟ್: 0

ಸಮಯದ ಅಂಕಗಣಿತ

const later = plainTime.plus({ minutes: 15 });
console.log(later.toString()); // ಔಟ್‌ಪುಟ್: 10:45:00

ದಿನಾಂಕ ಮತ್ತು ಸಮಯದೊಂದಿಗೆ ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

`Temporal.PlainDateTime` ಅನ್ನು ರಚಿಸುವುದು

ನೀವು `Temporal.PlainDateTime` ಅನ್ನು ನೇರವಾಗಿ ಅಥವಾ `Temporal.PlainDate` ಮತ್ತು `Temporal.PlainTime` ಅನ್ನು ಸಂಯೋಜಿಸಿ ರಚಿಸಬಹುದು:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
console.log(plainDateTime.toString()); // ಔಟ್‌ಪುಟ್: 2024-10-27T10:30:00

const date = new Temporal.PlainDate(2024, 10, 27);
const time = new Temporal.PlainTime(10, 30, 0);
const combinedDateTime = date.toPlainDateTime(time);
console.log(combinedDateTime.toString()); // ಔಟ್‌ಪುಟ್: 2024-10-27T10:30:00

ಟೈಮ್‌ಝೋನ್‌ಗಳು

ವಿವಿಧ ಸ್ಥಳಗಳಲ್ಲಿನ ಬಳಕೆದಾರರೊಂದಿಗೆ ವ್ಯವಹರಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಟೈಮ್‌ಝೋನ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ಟೆಂಪೊರಲ್ API `Temporal.ZonedDateTime` ಮತ್ತು `Temporal.TimeZone` ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೂಲಕ ದೃಢವಾದ ಟೈಮ್‌ಝೋನ್ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ.

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

`Temporal.ZonedDateTime` ಅನ್ನು ರಚಿಸಲು, ನಿಮಗೆ `Temporal.PlainDateTime` ಮತ್ತು ಒಂದು ಟೈಮ್‌ಝೋನ್ ಐಡೆಂಟಿಫೈಯರ್ ಅಗತ್ಯವಿದೆ. ಟೈಮ್‌ಝೋನ್ ಐಡೆಂಟಿಫೈಯರ್‌ಗಳು IANA ಟೈಮ್‌ಝೋನ್ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಆಧರಿಸಿವೆ (ಉದಾ., `America/Los_Angeles`, `Europe/London`, `Asia/Tokyo`).

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);
console.log(zonedDateTime.toString()); // ಔಟ್‌ಪುಟ್: 2024-10-27T10:30:00-07:00[America/Los_Angeles] (ಆಫ್‌ಸೆಟ್ DST ನಿಯಮಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ)

ಪರ್ಯಾಯವಾಗಿ, `Instant` ನಿಂದ `Temporal.ZonedDateTime` ಅನ್ನು ರಚಿಸಿ.

const instant = Temporal.Instant.fromEpochSeconds(1666866600); // ಉದಾಹರಣೆ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO(timeZone); // ಟೈಮ್‌ಝೋನ್ ಉದಾ. 'America/Los_Angeles'
console.log(zonedDateTimeFromInstant.toString());

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

ನೀವು `withTimeZone` ಮೆಥಡ್ ಬಳಸಿ `Temporal.ZonedDateTime` ಅನ್ನು ಬೇರೆ ಟೈಮ್‌ಝೋನ್‌ಗೆ ಪರಿವರ್ತಿಸಬಹುದು:

const newTimeZone = 'Europe/London';
const zonedDateTimeInLondon = zonedDateTime.withTimeZone(newTimeZone);
console.log(zonedDateTimeInLondon.toString()); // ಔಟ್‌ಪುಟ್: 2024-10-27T18:30:00+01:00[Europe/London]

ಟೈಮ್‌ಝೋನ್ ಆಫ್‌ಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

`Temporal.TimeZone` ಆಬ್ಜೆಕ್ಟ್‌ನ `getOffsetStringFor` ಮೆಥಡ್, ನೀಡಲಾದ `Temporal.Instant` ಗಾಗಿ ಆಫ್‌ಸೆಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ:

const timeZoneObject = new Temporal.TimeZone(timeZone);
const offsetString = timeZoneObject.getOffsetStringFor(zonedDateTime.toInstant());
console.log(offsetString); // ಔಟ್‌ಪುಟ್: -07:00 (DST ನಿಯಮಗಳನ್ನು ಅವಲಂಬಿಸಿ)

ನಿಖರವಾದ ಲೆಕ್ಕಾಚಾರಗಳಿಗಾಗಿ ಸರಿಯಾದ IANA ಟೈಮ್‌ಝೋನ್ ಐಡೆಂಟಿಫೈಯರ್‌ಗಳನ್ನು ಬಳಸುವುದು ಅತ್ಯಗತ್ಯ. ಈ ಐಡೆಂಟಿಫೈಯರ್‌ಗಳನ್ನು ಡೇಲೈಟ್ ಸೇವಿಂಗ್ ಟೈಮ್ ಮತ್ತು ಟೈಮ್‌ಝೋನ್ ಗಡಿಗಳಲ್ಲಿನ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸಲು ನಿಯಮಿತವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನವೀಕರಿಸಲಾಗುತ್ತದೆ.

ಅವಧಿಗಳು (Durations)

`Temporal.Duration` ಆಬ್ಜೆಕ್ಟ್ ಸಮಯದ ಒಂದು ಅವಧಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದನ್ನು ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳಿಂದ ಕೂಡಿಸಲು ಅಥವಾ ಕಳೆಯಲು ಬಳಸಬಹುದು.

`Temporal.Duration` ಅನ್ನು ರಚಿಸುವುದು

ನೀವು ವರ್ಷಗಳು, ತಿಂಗಳುಗಳು, ದಿನಗಳು, ಗಂಟೆಗಳು, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡ್‌ಗಳು, ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳು, ಮೈಕ್ರೋಸೆಕೆಂಡ್‌ಗಳು ಮತ್ತು ನ್ಯಾನೊಸೆಕೆಂಡ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ, ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸಿ `Temporal.Duration` ಅನ್ನು ರಚಿಸಬಹುದು:

const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8, 9); // ವರ್ಷಗಳು, ತಿಂಗಳುಗಳು, ದಿನಗಳು, ಗಂಟೆಗಳು, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡ್‌ಗಳು, ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳು, ಮೈಕ್ರೋಸೆಕೆಂಡ್‌ಗಳು, ನ್ಯಾನೊಸೆಕೆಂಡ್‌ಗಳು
console.log(duration.toString()); // ಔಟ್‌ಪುಟ್: P1Y2M3DT4H5M6.007008009S

ಅಥವಾ ISO 8601 ಅವಧಿಯ ಸ್ಟ್ರಿಂಗ್ ಬಳಸಿ:

const durationFromString = Temporal.Duration.from('P1Y2M3DT4H5M6S');
console.log(durationFromString.toString()); // ಔಟ್‌ಪುಟ್: P1Y2M3DT4H5M6S

ದಿನಾಂಕ ಮತ್ತು ಸಮಯಗಳಿಗೆ ಅವಧಿಗಳನ್ನು ಸೇರಿಸುವುದು

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const duration = new Temporal.Duration(0, 0, 7); // 7 ದಿನಗಳು
const newDate = plainDate.plus(duration);
console.log(newDate.toString()); // ಔಟ್‌ಪುಟ್: 2024-11-03

ಗಮನಿಸಿ, ತಿಂಗಳುಗಳು ಅಥವಾ ವರ್ಷಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಅವಧಿಗಳನ್ನು ದಿನಾಂಕಗಳಿಗೆ ಸೇರಿಸುವಾಗ ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸಬೇಕು, ಏಕೆಂದರೆ ಒಂದು ತಿಂಗಳು ಅಥವಾ ವರ್ಷದಲ್ಲಿನ ದಿನಗಳ ಸಂಖ್ಯೆ ಬದಲಾಗಬಹುದು.

ಕ್ಯಾಲೆಂಡರ್ ಸಿಸ್ಟಮ್ಸ್

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

ಪರ್ಯಾಯ ಕ್ಯಾಲೆಂಡರ್‌ಗಳನ್ನು ಬಳಸುವುದು

ಒಂದು ನಿರ್ದಿಷ್ಟ ಕ್ಯಾಲೆಂಡರ್ ಅನ್ನು ಬಳಸಲು, ನೀವು ಟೆಂಪೊರಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವಾಗ ಅದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:

const hebrewDate = new Temporal.PlainDate(5785, 1, 1, { calendar: 'hebrew' });
console.log(hebrewDate.toString()); // ನಿರ್ದಿಷ್ಟ ಔಟ್‌ಪುಟ್ ಅನುಷ್ಠಾನ ಮತ್ತು ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಬದಲಾಗಬಹುದು. ಇದನ್ನು ಬರೆಯುವ ಸಮಯದಲ್ಲಿ ಅನೇಕ ಪರಿಸರಗಳಲ್ಲಿ ಪಾಲಿಫಿಲ್ ಅಗತ್ಯವಿದೆ.

Important: ಗ್ರೆಗೋರಿಯನ್ ಅಲ್ಲದ ಕ್ಯಾಲೆಂಡರ್‌ಗಳಿಗೆ ಬೆಂಬಲಕ್ಕೆ ಪಾಲಿಫಿಲ್‌ಗಳು ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಬ್ರೌಸರ್/ಪರಿಸರದ ಬೆಂಬಲ ಬೇಕಾಗಬಹುದು. ಇತ್ತೀಚಿನ ಮಾಹಿತಿಗಾಗಿ ಟೆಂಪೊರಲ್ API ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಮತ್ತು ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯ ಟೇಬಲ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.

ದಿನಾಂಕ ಮತ್ತು ಸಮಯಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು

ಟೆಂಪೊರಲ್ API ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಕುಶಲತೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿದರೆ, ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ `Intl.DateTimeFormat` ಆಬ್ಜೆಕ್ಟ್‌ನಿಂದ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಇದು ಅಂತರರಾಷ್ಟ್ರೀಕರಣ APIಯ ಭಾಗವಾಗಿದೆ. ಟೆಂಪೊರಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು `Intl.DateTimeFormat` ನೊಂದಿಗೆ ಮನಬಂದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

`Intl.DateTimeFormat` ಅನ್ನು ಬಳಸುವುದು

`Intl.DateTimeFormat` ಬಳಸಿ `Temporal.PlainDate` ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು ಹೇಗೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatter.format(plainDate)); // ಔಟ್‌ಪುಟ್: October 27, 2024

const formatterGerman = new Intl.DateTimeFormat('de-DE', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatterGerman.format(plainDate)); // ಔಟ್‌ಪುಟ್: 27. Oktober 2024

ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ನೀವು ಫಾರ್ಮ್ಯಾಟ್ ಆಯ್ಕೆಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು. `Intl.DateTimeFormat` ಗೆ ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಲೋಕೇಲ್ ಆಗಿದೆ, ಇದು ಫಾರ್ಮ್ಯಾಟಿಂಗ್‌ಗಾಗಿ ಬಳಸುವ ಭಾಷೆ ಮತ್ತು ಪ್ರಾದೇಶಿಕ ಸಂಪ್ರದಾಯಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ವಿಭಿನ್ನ ಲೋಕೇಲ್‌ಗಳನ್ನು (ಉದಾ., 'en-US', 'de-DE', 'fr-FR', 'ja-JP') ಬಳಸುವುದರಿಂದ ವಿಭಿನ್ನ ಔಟ್‌ಪುಟ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು ಉತ್ಪತ್ತಿಯಾಗುತ್ತವೆ.

`Temporal.ZonedDateTime` ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು

`Temporal.ZonedDateTime` ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು ಇದೇ ರೀತಿ ಇರುತ್ತದೆ, ಆದರೆ ನೀವು ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ಟೈಮ್‌ಝೋನ್ ಮಾಹಿತಿಯನ್ನು ಸಹ ಸೇರಿಸಬಹುದು:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);

const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric', timeZoneName: 'short' });
console.log(formatter.format(zonedDateTime)); // ಔಟ್‌ಪುಟ್: October 27, 2024, 10:30 AM PDT (ಟೈಮ್‌ಝೋನ್ ಸಂಕ್ಷೇಪಣವು DST ನಿಯಮಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ)

ಅಂತರರಾಷ್ಟ್ರೀಕರಣದ ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಈ ಕೆಳಗಿನ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ:

ಟೆಂಪೊರಲ್ API ಮತ್ತು ಹಳೆಯ Date ಆಬ್ಜೆಕ್ಟ್ ನಡುವಿನ ಹೋಲಿಕೆ

ಹಳೆಯ `Date` ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಹೋಲಿಸಿದರೆ ಟೆಂಪೊರಲ್ APIಯ ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸಗಳು ಮತ್ತು ಪ್ರಯೋಜನಗಳನ್ನು ಎತ್ತಿ ತೋರಿಸುವ ಟೇಬಲ್ ಇಲ್ಲಿದೆ:

ವೈಶಿಷ್ಟ್ಯ ಹಳೆಯ `Date` ಆಬ್ಜೆಕ್ಟ್ ಟೆಂಪೊರಲ್ API
ಬದಲಾಯಿಸುವಿಕೆ (Mutability) ಬದಲಾಯಿಸಬಹುದಾದ (ಮೂಲ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ) ಬದಲಾಯಿಸಲಾಗದ (ಹೊಸ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ)
ಟೈಮ್‌ಝೋನ್ ಬೆಂಬಲ ಸೀಮಿತ ಮತ್ತು ಆಗಾಗ್ಗೆ ಸಮಸ್ಯಾತ್ಮಕ IANA ಟೈಮ್‌ಝೋನ್ ಡೇಟಾಬೇಸ್ ಆಧಾರಿತ, ದೃಢ ಮತ್ತು ನಿಖರ
API ಅಸಂಗತ ಮತ್ತು ಬಳಸಲು ಕಷ್ಟ ಸ್ಪಷ್ಟ, ಸ್ಥಿರ, ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ
ನಿಖರತೆ ಮಿಲಿಸೆಕೆಂಡ್ ನ್ಯಾನೊಸೆಕೆಂಡ್
ಕ್ಯಾಲೆಂಡರ್ ಸಿಸ್ಟಮ್ಸ್ ಗ್ರೆಗೋರಿಯನ್‌ಗೆ ಸೀಮಿತ ಪರ್ಯಾಯ ಕ್ಯಾಲೆಂಡರ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ (ವಿಕಸನಗೊಳ್ಳುತ್ತಿರುವ ಬೆಂಬಲದೊಂದಿಗೆ)
ಅಂತರರಾಷ್ಟ್ರೀಕರಣ ದೃಢವಾದ ಅಂತರರಾಷ್ಟ್ರೀಕರಣಕ್ಕಾಗಿ ಬಾಹ್ಯ ಲೈಬ್ರರಿಗಳ ಅಗತ್ಯವಿದೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲ ಮತ್ತು `Intl.DateTimeFormat` ನೊಂದಿಗೆ ಮನಬಂದಂತೆ ಸಂಯೋಜನೆ

ಬ್ರೌಸರ್ ಬೆಂಬಲ ಮತ್ತು ಪಾಲಿಫಿಲ್‌ಗಳು

ತುಲನಾತ್ಮಕವಾಗಿ ಹೊಸ API ಆಗಿರುವುದರಿಂದ, ಟೆಂಪೊರಲ್ APIಗೆ ಬ್ರೌಸರ್ ಬೆಂಬಲವು ಇನ್ನೂ ವಿಕಸನಗೊಳ್ಳುತ್ತಿದೆ. ಯಾವ ಬ್ರೌಸರ್‌ಗಳು ಮತ್ತು ಪರಿಸರಗಳು ಇದನ್ನು ನೇರವಾಗಿ ಬೆಂಬಲಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನೋಡಲು ಇತ್ತೀಚಿನ ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯ ಟೇಬಲ್‌ಗಳನ್ನು (ಉದಾ., MDN ವೆಬ್ ಡಾಕ್ಸ್‌ನಲ್ಲಿ) ಪರಿಶೀಲಿಸಿ. ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳು ಅಥವಾ ನೇರ ಬೆಂಬಲವಿಲ್ಲದ ಪರಿಸರಗಳಿಗಾಗಿ, ಟೆಂಪೊರಲ್ API ಕಾರ್ಯವನ್ನು ಒದಗಿಸಲು ನೀವು ಪಾಲಿಫಿಲ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಸೂಕ್ತ ಆಯ್ಕೆಗಳನ್ನು ಹುಡುಕಲು ವೆಬ್‌ನಲ್ಲಿ "Temporal API polyfill" ಎಂದು ಹುಡುಕಿ.

ತೀರ್ಮಾನ

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

ಹೆಚ್ಚಿನ ಕಲಿಕೆ