JavaScript டெம்பொரல் கால அளவு: நேர இடைவெளி கணக்கீடுகளில் நிபுணத்துவம் பெறுதல்

JavaScript-ன் டெம்பொரல் API தேதிகள், நேரங்கள் மற்றும் நேர இடைவெளிகளைக் கையாள ஒரு நவீன மற்றும் சக்திவாய்ந்த வழியை அறிமுகப்படுத்துகிறது. Temporal.Duration ஆப்ஜெக்ட் நேரத்தின் நீளத்தைக் குறிக்கிறது, நேர இடைவெளிகளுடன் கணக்கீடுகளைச் செய்வதற்கு தெளிவான மற்றும் உள்ளுணர்வு அணுகுமுறையை வழங்குகிறது. இந்த கட்டுரை Temporal.Duration இன் விவரங்களை ஆராய்கிறது, பல்வேறு பயன்பாட்டு நிகழ்வுகளுக்கான கால அளவை எவ்வாறு உருவாக்குவது, கையாளுவது மற்றும் வடிவமைப்பது என்பதை விளக்குகிறது.

Temporal.Duration என்றால் என்ன?

Temporal.Duration என்பது ஒரு கால அளவைக் குறிக்கிறது, அதை வருடங்கள், மாதங்கள், நாட்கள், மணிநேரம், நிமிடங்கள், வினாடிகள் மற்றும் வினாடியின் பின்னங்கள் (மில்லி வினாடிகள், மைக்ரோ வினாடிகள், நானோ வினாடிகள்) ஆகியவற்றின் அடிப்படையில் வெளிப்படுத்துகிறது. ஒரு குறிப்பிட்ட நேரத்தைக் குறிக்கும் Date ஆப்ஜெக்ட்களைப் போலல்லாமல், Temporal.Duration நேர அளவைக் குறிக்கிறது. இது ISO 8601 கால அளவு வடிவமைப்பைப் பின்பற்றுகிறது (எ.கா., P1Y2M10DT2H30M என்பது 1 வருடம், 2 மாதங்கள், 10 நாட்கள், 2 மணிநேரம் மற்றும் 30 நிமிடங்களைக் குறிக்கிறது). மரபு Date ஆப்ஜெக்டை விட டெம்பொரல் API மிகவும் உள்ளுணர்வுடனும் குறைவான பிழையுடனும் இருக்கும் வகையில் வடிவமைக்கப்பட்டுள்ளது.

Temporal.Duration ஆப்ஜெக்ட்களை உருவாக்குதல்

Temporal.Duration ஆப்ஜெக்ட்களை உருவாக்க பல வழிகள் உள்ளன:

1. சாதாரண ஆப்ஜெக்ட்டிலிருந்து

விரும்பிய பண்புகளுடன் ஒரு ஆப்ஜெக்ட்டை அனுப்புவதன் மூலம் நீங்கள் ஒரு கால அளவை உருவாக்கலாம்:

const duration = new Temporal.Duration(1, 2, 10, 2, 30, 0, 0, 0);
console.log(duration.toString()); // வெளியீடு: 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()); // வெளியீடு: P1Y2M10DT2H30M

சரம் வடிவத்தில் சேமிக்கப்பட்ட அல்லது வெளிப்புற மூலத்திலிருந்து பெறப்பட்ட கால அளவுகளைக் கையாளும் போது இது மிகவும் பயனுள்ளதாக இருக்கும்.

3. Temporal.Instant, Temporal.ZonedDateTime போன்றவற்றுடன் add() மற்றும் subtract() முறைகளைப் பயன்படுத்துதல்

மற்ற டெம்பொரல் வகைகளிலிருந்து (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()); // வெளியீடு: PT5H

கால அளவு கூறுகளை அணுகுதல்

Temporal.Duration ஆப்ஜெக்டின் தனிப்பட்ட கூறுகளை அதன் பண்புகளைப் பயன்படுத்தி அணுகலாம்:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.years);      // வெளியீடு: 1
console.log(duration.months);     // வெளியீடு: 2
console.log(duration.days);       // வெளியீடு: 10
console.log(duration.hours);      // வெளியீடு: 2
console.log(duration.minutes);     // வெளியீடு: 30
console.log(duration.seconds);     // வெளியீடு: 0
console.log(duration.milliseconds); // வெளியீடு: 0
console.log(duration.microseconds); // வெளியீடு: 0
console.log(duration.nanoseconds);  // வெளியீடு: 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()); // வெளியீடு: P1Y5M4D

const subtractedDuration = duration1.subtract(duration2);
console.log(subtractedDuration.toString()); // வெளியீடு: P10M26D

மேலும் சிக்கலான கணக்கீடுகளுக்கு இந்த முறைகளையும் நீங்கள் சங்கிலியால் பிணைக்கலாம்:

const duration = Temporal.Duration.from("P1D").add({ hours: 12 }).subtract({ minutes: 30 });
console.log(duration.toString()); // வெளியீடு: P1DT11H30M

negated() முறை அனைத்து கூறுகளும் எதிர்மறையான புதிய Temporal.Duration ஆப்ஜெக்டை வழங்கும்:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // வெளியீடு: -P1Y2M10DT2H30M

abs() முறை அனைத்து கூறுகளையும் நேர்மறை மதிப்புகளாக (முழுமையான மதிப்புகள்) கொண்ட புதிய Temporal.Duration ஆப்ஜெக்டை வழங்கும்:

const duration = Temporal.Duration.from("-P1Y2M10DT2H30M");
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // வெளியீடு: P1Y2M10DT2H30M

புதிய மதிப்புகளுக்கு மாற்றப்பட்ட சில அல்லது அனைத்து பண்புகளுடன் புதிய Temporal.Duration நிகழ்வை உருவாக்க with() முறை உங்களை அனுமதிக்கிறது. ஆர்க்யுமெண்ட் ஆப்ஜெக்டில் ஒரு மதிப்பு குறிப்பிடப்படவில்லை எனில், கால அளவின் அசல் மதிப்பு பயன்படுத்தப்படும். உதாரணமாக:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const newDuration = duration.with({ years: 2, days: 5 });
console.log(newDuration.toString()); // வெளியீடு: 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()); // வெளியீடு: P2M1D

இந்த எடுத்துக்காட்டில், P1M32D கால அளவு ஜனவரி 1, 2024 க்குச் சான்றாக இயல்பாக்கப்படுகிறது, இதன் விளைவாக P2M1D கிடைக்கிறது, ஏனெனில் ஜனவரி 31 நாட்களைக் கொண்டுள்ளது.

நீங்கள் நேர கூறுகளை மட்டுமே (மணிநேரம், நிமிடங்கள், வினாடிகள் போன்றவை) கையாளுகிறீர்கள் என்றால், குறிப்பு தேதி இல்லாமல் நீங்கள் இயல்பாக்கலாம்:

const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //அல்லது relativeTo ஆர்க்யுமெண்ட்டை தவிர்க்கவும்
console.log(normalizedDuration.toString()); // வெளியீடு: P1DT2H1M

கால அளவுகளை ஒப்பிடுதல்

compare() முறையைப் பயன்படுத்தி கால அளவுகளை ஒப்பிடலாம். இந்த முறை திரும்பும்:

• முதல் கால அளவு இரண்டாவது கால அளவை விட குறைவாக இருந்தால் -1.
• கால அளவுகள் சமமாக இருந்தால் 0.
• முதல் கால அளவு இரண்டாவது கால அளவை விட அதிகமாக இருந்தால் 1.

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

const comparisonResult = Temporal.Duration.compare(duration1, duration2);
console.log(comparisonResult); // வெளியீடு: 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()); // வெளியீடு: எ.கா., P262DT14H30M (தற்போதைய தேதி மற்றும் நேரத்தைப் பொறுத்து)

2. திட்ட பணி கால அளவுகளை கண்காணித்தல்

திட்ட மேலாண்மையில், பணிகளின் மதிப்பிடப்பட்ட அல்லது உண்மையான கால அளவைக் கண்காணிக்க Temporal.Duration ஐப் பயன்படுத்தலாம்.

const task1EstimatedDuration = Temporal.Duration.from("PT8H"); // 8 மணிநேரம்
const task2EstimatedDuration = Temporal.Duration.from("PT16H"); // 16 மணிநேரம்

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`மொத்த மதிப்பிடப்பட்ட கால அளவு: ${totalEstimatedDuration.toString()}`); // வெளியீடு: மொத்த மதிப்பிடப்பட்ட கால அளவு: 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(`மதிப்பிடப்பட்ட வயது: ${ageDuration.years} வருடங்கள்`); // வெளியீடு: மதிப்பிடப்பட்ட வயது: 33 வருடங்கள்

4. மனிதனால் படிக்கக்கூடிய கால அளவுகளைக் காட்டுகிறது

பெரும்பாலும், நீங்கள் மனிதனால் படிக்கக்கூடிய வடிவத்தில் கால அளவுகளைக் காட்ட வேண்டும். Temporal.Duration உள்ளமைக்கப்பட்ட வடிவமைக்கும் செயல்பாடுகளைக் கொண்டிருக்கவில்லை என்றாலும், நீங்கள் தனிப்பயன் வடிவமைக்கும் தர்க்கத்தை உருவாக்கலாம்:

function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} வருடம்${duration.years > 1 ? 'கள்' : ''}`);
  if (duration.months) parts.push(`${duration.months} மாதம்${duration.months > 1 ? 'கள்' : ''}`);
  if (duration.days) parts.push(`${duration.days} நாள்${duration.days > 1 ? 'கள்' : ''}`);
  if (duration.hours) parts.push(`${duration.hours} மணி${duration.hours > 1 ? 'கள்' : ''}`);
  if (duration.minutes) parts.push(`${duration.minutes} நிமிடம்${duration.minutes > 1 ? 'கள்' : ''}`);
  if (duration.seconds) parts.push(`${duration.seconds} வினாடி${duration.seconds > 1 ? 'கள்' : ''}`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // வெளியீடு: 1 வருடம், 2 மாதங்கள், 10 நாட்கள், 2 மணிநேரம், 30 நிமிடங்கள்

மேம்பட்ட பயன்பாடு மற்றும் பரிசீலனைகள்

1. நேர மண்டல கையாளுதல்

நேர மண்டல எல்லைகள் அல்லது பகல் சேமிப்பு நேர மாற்றங்களைக் கடக்கும் நேர இடைவெளிகளைக் கையாளும் போது, துல்லியமான கணக்கீடுகளை உறுதி செய்ய Temporal.ZonedDateTime ஐப் பயன்படுத்துவது முக்கியம். Temporal.PlainDate மற்றும் Temporal.PlainTime ஐப் பயன்படுத்துவது எந்த நேர மண்டல மாற்றங்களையும் தவிர்க்கும்.

2. மிகச்சிறிய அலகு மற்றும் சுற்றுதல்

`since()` மற்றும் `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()); //உதாரண வெளியீடு PT340D

3. லீப் வினாடிகள்

டெம்பொரல் லீப் வினாடிகளை உள்நாட்டில் கணக்கில் எடுத்துக்கொள்வதில்லை. உங்களுக்கு அதிக துல்லியம் தேவைப்பட்டால், நீங்கள் லீப் வினாடிகளைத் தனியாகக் கையாள வேண்டும்.

4. IANA நேர மண்டலங்கள்

டெம்பொரல் API IANA (இணைய ஒதுக்கப்பட்ட எண்கள் ஆணையம்) நேர மண்டல தரவுத்தளத்தை நம்பியுள்ளது. நேர மண்டல மாற்றங்களை துல்லியமாகக் கையாள உங்கள் சூழலில் IANA தரவுத்தளத்தின் புதுப்பிக்கப்பட்ட பதிப்பு இருப்பதை உறுதிப்படுத்தவும்.

சிறந்த நடைமுறைகள்

• கால அளவு சரங்களுக்கு ISO 8601 வடிவமைப்பைப் பயன்படுத்தவும்: இது நிலைத்தன்மை மற்றும் இயங்குதிறனை உறுதி செய்கிறது.
• பொருத்தமான டெம்பொரல் வகையைத் தேர்ந்தெடுக்கவும்: உங்களுக்கு நேர மண்டல ஆதரவு தேவையா இல்லையா என்பதைப் பொறுத்து Temporal.PlainDate, Temporal.PlainTime, Temporal.ZonedDateTime அல்லது Temporal.Instant ஐப் பயன்படுத்தவும்.
• தேவைப்படும்போது கால அளவுகளை இயல்பாக்கவும்: இயல்பாக்கல் கால அளவுகளை எளிதாக்குகிறது மற்றும் அவற்றை ஒப்பிடுவதை எளிதாக்குகிறது.
• நேர மண்டலங்களை கவனமாகக் கையாளவும்: நேர மண்டல மாற்றங்கள் சிக்கலானதாக இருக்கும், எனவே Temporal.ZonedDateTime ஐப் பயன்படுத்தவும் மற்றும் பகல் சேமிப்பு நேர மாற்றங்களைப் பற்றி எச்சரிக்கையாக இருங்கள்.
• மிகச்சிறிய அலகைக் கருத்தில் கொள்ளவும்: கால அளவுகளைக் கணக்கிடும்போது, விரும்பிய துல்லியத்தைப் பெற மிகச்சிறிய அலகைக் குறிப்பிடவும்.
• யூனிட் சோதனைகளை எழுதுங்கள்: கால அளவு கணக்கீடுகள் துல்லியமானவை என்பதை உறுதிப்படுத்த உங்கள் குறியீட்டை முழுமையாகச் சோதிக்கவும்.

பொதுவான குறைபாடுகள்

• நேர மண்டலங்களைப் புறக்கணித்தல்: நேர மண்டலங்களுக்கு கணக்கு கொடுக்கத் தவறினால், குறிப்பாக வெவ்வேறு இடங்களில் உள்ள நிகழ்வுகளைக் கையாளும் போது, தவறான கால அளவு கணக்கீடுகளுக்கு வழிவகுக்கும்.
• மரபு டேட் ஆப்ஜெக்டைப் பயன்படுத்துதல்: மரபு Date ஆப்ஜெக்ட் அதன் வினோதங்கள் மற்றும் முரண்பாடுகளுக்கு பெயர் பெற்றது. மிகவும் நம்பகமான தேதி மற்றும் நேரக் கையாளுதலுக்கு டெம்பொரல் API ஐ விரும்பவும்.
• கால அளவுகளை இயல்பாக்காதது: கால அளவுகளை இயல்பாக்காதது ஒப்பீடுகள் மற்றும் கணக்கீடுகளை மிகவும் சிக்கலாக்கும்.
• தவறான ISO 8601 வடிவம்: தவறான ISO 8601 கால அளவு சரத்தைப் பயன்படுத்துவது பிழைகளை ஏற்படுத்தக்கூடும்.

வெவ்வேறு கலாச்சாரங்களில் உண்மையான பயன்பாட்டு நிகழ்வுகள்

நேர மண்டல வேறுபாடுகள் மற்றும் கலாச்சார வேறுபாடுகள் குறிப்பிடத்தக்க உலகளாவிய பயன்பாடுகளில் டெம்பொரல் API குறிப்பாக நன்மை பயக்கும். சில உதாரணங்கள் இங்கே:

• உலகளாவிய நிகழ்வு திட்டமிடல்: பகல் சேமிப்பு நேர மாற்றங்களைக் கணக்கில் எடுத்துக்கொண்டு, பல நேர மண்டலங்களில் நிகழ்வுகளைத் துல்லியமாகத் திட்டமிடுதல். உதாரணமாக, காலை 9:00 AM PST க்குத் தொடங்கும் ஒரு வெபினாரைத் திட்டமிடுதல் மற்றும் CET, JST மற்றும் AEDT போன்ற பல்வேறு நேர மண்டலங்களில் தொடர்புடைய தொடக்க நேரத்தைக் காட்டுதல்.
• சர்வதேச பயணத் திட்டமிடல்: தங்குமிடங்கள் மற்றும் நேர மண்டல மாற்றங்கள் உட்பட பயண கால அளவுகளைக் கணக்கிடுதல். பயணத்திட்டங்களை உருவாக்குவதற்கும் விமான அட்டவணைகளை நிர்வகிப்பதற்கும் இது பயனுள்ளதாக இருக்கும். உதாரணமாக, லண்டனில் தங்குமிடத்துடன் நியூயார்க்கிலிருந்து டோக்கியோவிற்கு மொத்த பயண நேரத்தைக் கணக்கிடுதல் மற்றும் நேர மண்டல வேறுபாடுகளுக்கு ஏற்ப சரிசெய்தல்.
• உலகளாவிய மின்வணிகம்: பயனரின் உள்ளூர் நேர மண்டலத்தில் மதிப்பிடப்பட்ட டெலிவரி நேரங்களைக் காட்டுதல். இதற்கு மூல நேர மண்டலம், கப்பல் கால அளவு மற்றும் இலக்கு நேர மண்டலம் ஆகியவற்றைக் கருத்தில் கொள்ள வேண்டும். உதாரணமாக, ஜெர்மனியில் உள்ள ஒரு கிடங்கிலிருந்து ஆஸ்திரேலியாவில் உள்ள ஒரு வாடிக்கையாளருக்கு அனுப்பப்பட்ட ஒரு பொருள், 7 நாட்களின் மதிப்பிடப்பட்ட டெலிவரி நேரத்துடன், வாடிக்கையாளரின் உள்ளூர் நேரத்தில் காட்டப்படும்.
• எல்லை தாண்டிய நிதி பரிவர்த்தனைகள்: வெவ்வேறு பிராந்தியங்களில் வட்டி திரட்டல் அல்லது கட்டண காலக்கெடுவை துல்லியமாகக் கணக்கிடுதல். இது பெரும்பாலும் ஒவ்வொரு நாட்டிலும் வெவ்வேறு வணிக நாட்கள் மற்றும் விடுமுறை நாட்களைக் கருத்தில் கொள்வதை உள்ளடக்குகிறது. உதாரணமாக, சிங்கப்பூர் பொது விடுமுறைகளை கணக்கில் எடுத்துக்கொண்டு, சிங்கப்பூரில் ஒரு கடனுக்கான வட்டி திரட்டலைக் கணக்கிடுதல்.
• பன்முக கலாச்சார காலண்டர் பயன்பாடுகள்: இஸ்லாமிய அல்லது ஹீப்ரு காலண்டர் போன்ற பல்வேறு காலண்டர் அமைப்புகளை ஆதரித்தல் மற்றும் இந்த காலண்டர்களை அடிப்படையாகக் கொண்ட நிகழ்வு கால அளவுகள் மற்றும் நினைவூட்டல்களைத் துல்லியமாகக் கணக்கிடுதல்.
• உலகளாவிய திட்ட மேலாண்மை: வெவ்வேறு வேலை அட்டவணைகள் மற்றும் நேர மண்டலங்களைக் கணக்கில் எடுத்துக்கொண்டு, விநியோகிக்கப்பட்ட அணிகளில் திட்ட பணி கால அளவுகள் மற்றும் காலக்கெடுவை கண்காணித்தல்.

முடிவு

Temporal.Duration என்பது JavaScript இல் நேர இடைவெளிகளுடன் வேலை செய்ய ஒரு வலுவான மற்றும் உள்ளுணர்வு வழியை வழங்குகிறது. அதன் அம்சங்கள் மற்றும் சிறந்த நடைமுறைகளைப் புரிந்துகொள்வதன் மூலம், உங்கள் பயன்பாடுகளில் துல்லியமான மற்றும் நம்பகமான கால அளவு கணக்கீடுகளை நீங்கள் நம்பிக்கையுடன் செய்யலாம். டெம்பொரல் API ஐ ஏற்றுக்கொள்வது தூய்மையான, அதிக பராமரிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கிறது மற்றும் மரபு தேதி மற்றும் நேர கையாளுதலுடன் தொடர்புடைய பிழைகளின் அபாயத்தைக் குறைக்கிறது.

டெம்பொரல் API இல் நீங்கள் ஆழமாகச் செல்லும்போது, அதன் திறன்களை முழுமையாகப் புரிந்துகொள்ள அதிகாரப்பூர்வ ஆவணத்தைப் பார்க்கவும், வெவ்வேறு காட்சிகளுடன் பரிசோதனை செய்யவும் நினைவில் கொள்ளுங்கள். அதன் நவீன வடிவமைப்பு மற்றும் விரிவான அம்சங்களுடன், டெம்பொரல் JavaScript இல் தேதிகள், நேரங்கள் மற்றும் கால அளவுகளை நாம் கையாளும் விதத்தில் புரட்சியை ஏற்படுத்த உள்ளது.