M

MLOG

ಕನ್ನಡ

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

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪರಲ್ ಅವಧಿ: ಸಮಯದ ಮಧ್ಯಂತರ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

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

ಟೆಂಪರಲ್.ಡ್ಯೂರೇಷನ್ ಎಂದರೇನು?

Temporal.Duration ಸಮಯದ ವ್ಯಾಪ್ತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇದನ್ನು ವರ್ಷಗಳು, ತಿಂಗಳುಗಳು, ದಿನಗಳು, ಗಂಟೆಗಳು, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳು ಮತ್ತು ಒಂದು ಸೆಕೆಂಡಿನ ಭಾಗಗಳಲ್ಲಿ (ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳು, ಮೈಕ್ರೋಸೆಕೆಂಡ್‌ಗಳು, ನ್ಯಾನೊ ಸೆಕೆಂಡ್‌ಗಳು) ವ್ಯಕ್ತಪಡಿಸುತ್ತದೆ. ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಬಿಂದುವನ್ನು ಪ್ರತಿನಿಧಿಸುವ Date ವಸ್ತುಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, Temporal.Duration ಸಮಯದ ಪ್ರಮಾಣವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದು ISO 8601 ಅವಧಿಯ ಸ್ವರೂಪವನ್ನು ಅನುಸರಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, P1Y2M10DT2H30M ಎಂದರೆ 1 ವರ್ಷ, 2 ತಿಂಗಳುಗಳು, 10 ದಿನಗಳು, 2 ಗಂಟೆಗಳು ಮತ್ತು 30 ನಿಮಿಷಗಳು). ಟೆಂಪರಲ್ API ಅನ್ನು ಲೆಗಸಿ Date ವಸ್ತುವಿಗಿಂತ ಹೆಚ್ಚು ಅರ್ಥಗರ್ಭಿತ ಮತ್ತು ದೋಷ-ಮುಕ್ತವಾಗಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

ಟೆಂಪರಲ್.ಡ್ಯೂರೇಷನ್ ವಸ್ತುಗಳನ್ನು ರಚಿಸುವುದು

Temporal.Duration ವಸ್ತುಗಳನ್ನು ರಚಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿವೆ:

1. ಒಂದು ಸಾಮಾನ್ಯ ವಸ್ತುವಿನಿಂದ

ಬಯಸಿದ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಒಂದು ವಸ್ತುವನ್ನು ರವಾನಿಸುವ ಮೂಲಕ ನೀವು ಒಂದು ಅವಧಿಯನ್ನು ರಚಿಸಬಹುದು:

const duration = new Temporal.Duration(1, 2, 10, 2, 30, 0, 0, 0);
console.log(duration.toString()); // Output: P1Y2M10DT2H30M

ಇದು 1 ವರ್ಷ, 2 ತಿಂಗಳುಗಳು, 10 ದಿನಗಳು, 2 ಗಂಟೆಗಳು ಮತ್ತು 30 ನಿಮಿಷಗಳ ಅವಧಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ವಾದಗಳು ಈ ಕೆಳಗಿನ ಕ್ರಮಕ್ಕೆ ಅನುಗುಣವಾಗಿವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ: years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds.

2. ISO 8601 ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ

ನೀವು Temporal.Duration.from() ಅನ್ನು ಬಳಸಿಕೊಂಡು ISO 8601 ಅವಧಿಯ ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಅವಧಿಯನ್ನು ಸಹ ರಚಿಸಬಹುದು:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.toString()); // Output: P1Y2M10DT2H30M

ಸ್ಟ್ರಿಂಗ್ ಸ್ವರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಅಥವಾ ಬಾಹ್ಯ ಮೂಲದಿಂದ ಸ್ವೀಕರಿಸಿದ ಅವಧಿಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

3. add() ಮತ್ತು subtract() ವಿಧಾನಗಳನ್ನು Temporal.Instant, Temporal.ZonedDateTime, ಇತ್ಯಾದಿಗಳೊಂದಿಗೆ ಬಳಸುವುದು

ನೀವು ಇತರ ಟೆಂಪರಲ್ ಪ್ರಕಾರಗಳಿಗೆ (Temporal.Instant ಅಥವಾ Temporal.ZonedDateTime ನಂತಹ) Temporal.Duration ಅನ್ನು ಸೇರಿಸಿದಾಗ ಅಥವಾ ಕಳೆದಾಗ, ನೀವು ಅವುಗಳನ್ನು ಕಳೆದರೆ ಎರಡು ಸಮಯ ಬಿಂದುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಪ್ರತಿನಿಧಿಸುವ Temporal.Duration ಅನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

const now = Temporal.Now.zonedDateTimeISO();
const later = now.add({ hours: 5 });
const duration = later.since(now);
console.log(duration.toString()); // Output: PT5H

ಅವಧಿ ಘಟಕಗಳಿಗೆ ಪ್ರವೇಶ

ನೀವು ಅದರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು Temporal.Duration ವಸ್ತುವಿನ ವೈಯಕ್ತಿಕ ಘಟಕಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.years);      // Output: 1
console.log(duration.months);     // Output: 2
console.log(duration.days);       // Output: 10
console.log(duration.hours);      // Output: 2
console.log(duration.minutes);     // Output: 30
console.log(duration.seconds);     // Output: 0
console.log(duration.milliseconds); // Output: 0
console.log(duration.microseconds); // Output: 0
console.log(duration.nanoseconds);  // Output: 0

ಅವಧಿಗಳೊಂದಿಗೆ ಅಂಕಗಣಿತವನ್ನು ನಿರ್ವಹಿಸುವುದು

Temporal.Duration ವಸ್ತುಗಳು add() ಮತ್ತು subtract() ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸೇರ್ಪಡೆ ಮತ್ತು ವ್ಯವಕಲನವನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ. ಈ ವಿಧಾನಗಳು ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಹೊಸ Temporal.Duration ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತವೆ.

const duration1 = Temporal.Duration.from("P1Y2M");
const duration2 = Temporal.Duration.from("P3M4D");

const addedDuration = duration1.add(duration2);
console.log(addedDuration.toString()); // Output: P1Y5M4D

const subtractedDuration = duration1.subtract(duration2);
console.log(subtractedDuration.toString()); // Output: P10M26D

ನೀವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಲೆಕ್ಕಾಚಾರಗಳಿಗಾಗಿ ಈ ವಿಧಾನಗಳನ್ನು ಸರಪಳಿಯಾಗಿ ಮಾಡಬಹುದು:

const duration = Temporal.Duration.from("P1D").add({ hours: 12 }).subtract({ minutes: 30 });
console.log(duration.toString()); // Output: P1DT11H30M

negated() ವಿಧಾನವು ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ನಿರಾಕರಿಸುವುದರೊಂದಿಗೆ ಹೊಸ Temporal.Duration ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Output: -P1Y2M10DT2H30M

abs() ವಿಧಾನವು ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ಧನಾತ್ಮಕ ಮೌಲ್ಯಗಳಾಗಿ (ಸಂಪೂರ್ಣ ಮೌಲ್ಯಗಳು) ಹೊಂದಿರುವ ಹೊಸ Temporal.Duration ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ:

const duration = Temporal.Duration.from("-P1Y2M10DT2H30M");
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Output: P1Y2M10DT2H30M

with() ವಿಧಾನವು ಕೆಲವು ಅಥವಾ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಸ ಮೌಲ್ಯಗಳಿಗೆ ಬದಲಾಯಿಸಿದ ಹೊಸ Temporal.Duration ನಿದರ್ಶನವನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ವಾದ ವಸ್ತುವಿನಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಅವಧಿಯ ಮೂಲ ಮೌಲ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const newDuration = duration.with({ years: 2, days: 5 });
console.log(newDuration.toString()); // Output: P2Y2M5DT2H30M

ಅವಧಿಗಳನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸುವುದು

ಅವಧಿಗಳನ್ನು ಕೆಲವೊಮ್ಮೆ ಸಾಮಾನ್ಯವಲ್ಲದ ರೂಪದಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಬಹುದು (ಉದಾಹರಣೆಗೆ, P1Y12M, ಇದನ್ನು P2Y ಗೆ ಸರಳಗೊಳಿಸಬಹುದು). normalized() ವಿಧಾನವು ಅವಧಿಯನ್ನು ಅದರ ಅತ್ಯಂತ ಕಾಂಪ್ಯಾಕ್ಟ್ ರೂಪಕ್ಕೆ ಸರಳಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಬದಲಾಗುವ ತಿಂಗಳ ಉದ್ದಗಳ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಉಲ್ಲೇಖ ದಿನಾಂಕದ ಅಗತ್ಯವಿದೆ. ಸರಿಯಾಗಿ ಸಾಮಾನ್ಯಗೊಳಿಸಲು, ನಿಮಗೆ Temporal.PlainDate, Temporal.ZonedDateTime ಅಥವಾ Temporal.Instant ನಿದರ್ಶನದ ಅಗತ್ಯವಿದೆ.

ಉದಾಹರಣೆಗೆ, ತಿಂಗಳುಗಳು ಮತ್ತು ದಿನಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಅವಧಿಯನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸಲು ಉಲ್ಲೇಖ ದಿನಾಂಕದ ಅಗತ್ಯವಿದೆ:

const duration = Temporal.Duration.from("P1M32D");
const referenceDate = Temporal.PlainDate.from("2024-01-01");
const normalizedDuration = duration.normalized({ relativeTo: referenceDate });
console.log(normalizedDuration.toString()); // Output: P2M1D

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಜನವರಿ 1, 2024 ಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ ಅವಧಿ P1M32D ಅನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸಲಾಗಿದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ P2M1D ಆಗುತ್ತದೆ, ಏಕೆಂದರೆ ಜನವರಿಯಲ್ಲಿ 31 ದಿನಗಳಿವೆ.

ನೀವು ಸಮಯದ ಘಟಕಗಳನ್ನು ಮಾತ್ರ ವ್ಯವಹರಿಸುತ್ತಿದ್ದರೆ (ಗಂಟೆಗಳು, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳು, ಇತ್ಯಾದಿ), ನೀವು ಉಲ್ಲೇಖ ದಿನಾಂಕವಿಲ್ಲದೆ ಸಾಮಾನ್ಯಗೊಳಿಸಬಹುದು:

const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //or omit relativeTo argument
console.log(normalizedDuration.toString()); // Output: P1DT2H1M

ಅವಧಿಗಳನ್ನು ಹೋಲಿಸುವುದು

ನೀವು compare() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಅವಧಿಗಳನ್ನು ಹೋಲಿಸಬಹುದು. ಈ ವಿಧಾನವು ಹಿಂದಿರುಗಿಸುತ್ತದೆ:

const duration1 = Temporal.Duration.from("P1Y");
const duration2 = Temporal.Duration.from("P6M");

const comparisonResult = Temporal.Duration.compare(duration1, duration2);
console.log(comparisonResult); // Output: 1

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

1. ಈವೆಂಟ್ ವರೆಗಿನ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು

ನೀವು ನಿರ್ದಿಷ್ಟ ಈವೆಂಟ್ ವರೆಗೆ ಉಳಿದಿರುವ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ. ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ಪಡೆಯಲು Temporal.Now.zonedDateTimeISO() ಅನ್ನು ಬಳಸಿ, ಮತ್ತು ಈವೆಂಟ್‌ನ ದಿನಾಂಕವನ್ನು ಕಳೆಯಿರಿ. ಈವೆಂಟ್‌ನ ದಿನಾಂಕವು ಮುಗಿದಿದ್ದರೆ, ಔಟ್‌ಪುಟ್ ನಕಾರಾತ್ಮಕವಾಗಿರುತ್ತದೆ.

const eventDate = Temporal.ZonedDateTime.from({ timeZone: 'America/Los_Angeles', year: 2024, month: 12, day: 25, hour: 9, minute: 0, second: 0 });
const now = Temporal.Now.zonedDateTimeISO('America/Los_Angeles');

const durationUntilEvent = eventDate.since(now);

console.log(durationUntilEvent.toString()); // Output: e.g., P262DT14H30M (depending on the current date and time)

2. ಪ್ರಾಜೆಕ್ಟ್ ಕಾರ್ಯ ಅವಧಿಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು

ಪ್ರಾಜೆಕ್ಟ್ ನಿರ್ವಹಣೆಯಲ್ಲಿ, ಕಾರ್ಯಗಳ ಅಂದಾಜು ಅಥವಾ ನಿಜವಾದ ಅವಧಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ನೀವು Temporal.Duration ಅನ್ನು ಬಳಸಬಹುದು.

const task1EstimatedDuration = Temporal.Duration.from("PT8H"); // 8 hours
const task2EstimatedDuration = Temporal.Duration.from("PT16H"); // 16 hours

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`Total estimated duration: ${totalEstimatedDuration.toString()}`); // Output: Total estimated duration: P1DT

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

ವಯಸ್ಸನ್ನು ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಅಧಿಕ ವರ್ಷಗಳು ಮತ್ತು ಸಮಯ ವಲಯಗಳನ್ನು ಪರಿಗಣಿಸಬೇಕಾದರೆ, Temporal.Duration ಸಮಂಜಸವಾದ ಅಂದಾಜನ್ನು ಒದಗಿಸುತ್ತದೆ:

const birthDate = Temporal.PlainDate.from("1990-05-15");
const currentDate = Temporal.PlainDate.from("2024-01-20");

const ageDuration = currentDate.since(birthDate, { smallestUnit: 'years' });
console.log(`Estimated age: ${ageDuration.years} years`); // Output: Estimated age: 33 years

4. ಮಾನವ-ಓದಬಲ್ಲ ಅವಧಿಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವುದು

ಹೆಚ್ಚಾಗಿ, ನೀವು ಅವಧಿಗಳನ್ನು ಮಾನವ-ಓದಬಲ್ಲ ಸ್ವರೂಪದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಬೇಕಾಗುತ್ತದೆ. Temporal.Duration ಅಂತರ್ನಿರ್ಮಿತ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೂ, ನೀವು ಕಸ್ಟಮ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ತರ್ಕವನ್ನು ರಚಿಸಬಹುದು:

function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} year${duration.years > 1 ? 's' : ''}`);
  if (duration.months) parts.push(`${duration.months} month${duration.months > 1 ? 's' : ''}`);
  if (duration.days) parts.push(`${duration.days} day${duration.days > 1 ? 's' : ''}`);
  if (duration.hours) parts.push(`${duration.hours} hour${duration.hours > 1 ? 's' : ''}`);
  if (duration.minutes) parts.push(`${duration.minutes} minute${duration.minutes > 1 ? 's' : ''}`);
  if (duration.seconds) parts.push(`${duration.seconds} second${duration.seconds > 1 ? 's' : ''}`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // Output: 1 year, 2 months, 10 days, 2 hours, 30 minutes

ಸುಧಾರಿತ ಬಳಕೆ ಮತ್ತು ಪರಿಗಣನೆಗಳು

1. ಸಮಯ ವಲಯ ನಿರ್ವಹಣೆ

ಸಮಯ ವಲಯದ ಗಡಿಗಳನ್ನು ದಾಟುವ ಅಥವಾ ಹಗಲು ಉಳಿತಾಯ ಸಮಯ ಪರಿವರ್ತನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಸಮಯದ ಮಧ್ಯಂತರಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ, ನಿಖರವಾದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು Temporal.ZonedDateTime ಅನ್ನು ಬಳಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. Temporal.PlainDate ಮತ್ತು Temporal.PlainTime ಅನ್ನು ಬಳಸುವುದರಿಂದ ಯಾವುದೇ ಸಮಯ ವಲಯ ಪರಿವರ್ತನೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

2. ಚಿಕ್ಕ ಘಟಕ ಮತ್ತು ದುಂಡುಗೊಳಿಸುವಿಕೆ

since() ಮತ್ತು until() ವಿಧಾನಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಫಲಿತಾಂಶದ ಅವಧಿಗೆ ಚಿಕ್ಕ ಘಟಕವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಆಯ್ಕೆಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಈವೆಂಟ್ ವರೆಗಿನ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು *until* ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ದಿನಗಳಿಗೆ ಸೀಮಿತಗೊಳಿಸುವುದು.

const eventDate = Temporal.PlainDate.from("2024-12-25");
const now = Temporal.PlainDate.from("2024-01-20");

const durationUntilEvent = now.until(eventDate, { smallestUnit: 'days' });

console.log(durationUntilEvent.toString()); //example output PT340D

3. ಅಧಿಕ ಸೆಕೆಂಡುಗಳು

ಟೆಂಪರಲ್ ಸ್ಥಳೀಯವಾಗಿ ಅಧಿಕ ಸೆಕೆಂಡುಗಳನ್ನು ಪರಿಗಣಿಸುವುದಿಲ್ಲ. ನಿಮಗೆ ವಿಪರೀತ ನಿಖರತೆ ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು ಪ್ರತ್ಯೇಕವಾಗಿ ಅಧಿಕ ಸೆಕೆಂಡುಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ.

4. IANA ಸಮಯ ವಲಯಗಳು

ಟೆಂಪರಲ್ API IANA (ಇಂಟರ್ನೆಟ್ ಅಸೈನ್‌ಡ್ ನಂಬರ್ಸ್ ಅಥಾರಿಟಿ) ಸಮಯ ವಲಯ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಅವಲಂಬಿಸಿದೆ. ಸಮಯ ವಲಯ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿಖರವಾಗಿ ನಿರ್ವಹಿಸಲು ನಿಮ್ಮ ಪರಿಸರವು IANA ಡೇಟಾಬೇಸ್‌ನ ನವೀಕೃತ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಸಾಮಾನ್ಯ ಅಪಾಯಗಳು

ವಿವಿಧ ಸಂಸ್ಕೃತಿಗಳಲ್ಲಿ ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆ ಪ್ರಕರಣಗಳು

ಟೆಂಪರಲ್ API ಸಮಯ ವಲಯ ವ್ಯತ್ಯಾಸಗಳು ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳು ಮುಖ್ಯವಾಗಿರುವ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟವಾಗಿ ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ. ಕೆಲವು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

ತೀರ್ಮಾನ

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

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