ஜாவாஸ்கிரிப்ட் டெம்போரல் API-க்கான ஒரு ஆழமான வழிகாட்டி, இது பல்வேறு சர்வதேச சூழல்களில் தேதிகளையும் நேரங்களையும் திறம்பட கையாள்வதற்கான ஒரு நவீன தீர்வாகும்.
ஜாவாஸ்கிரிப்ட் டெம்போரல் API: உலகளாவிய பார்வையாளர்களுக்கான நவீன தேதி மற்றும் நேரக் கையாளுதல்
ஜாவாஸ்கிரிப்டின் `Date` ஆப்ஜெக்ட் நீண்ட காலமாக டெவலப்பர்களுக்கு ஒரு விரக்தியின் ஆதாரமாக இருந்து வருகிறது. அதன் மாற்றியமைக்கக்கூடிய தன்மை, சீரற்ற API மற்றும் மோசமான நேர மண்டல ஆதரவு போன்றவை Moment.js மற்றும் date-fns போன்ற பல லைப்ரரிகள் அந்த இடைவெளிகளை நிரப்ப வழிவகுத்தன. இப்போது, டெம்போரல் API உடன், ஜாவாஸ்கிரிப்ட் மேம்பட்ட தெளிவு மற்றும் துல்லியத்துடன் தேதிகளையும் நேரங்களையும் கையாள்வதற்கான ஒரு நவீன, உள்ளமைக்கப்பட்ட தீர்வை வழங்குகிறது. இந்தக் கட்டுரை டெம்போரல் API-யின் ஒரு விரிவான கண்ணோட்டத்தை வழங்குகிறது, அதன் அம்சங்கள், நன்மைகள் மற்றும் பல்வேறு சர்வதேச சூழல்களில் அதன் பயன்பாடு ஆகியவற்றில் கவனம் செலுத்துகிறது.
டெம்போரல் API என்றால் என்ன?
டெம்போரல் API என்பது ஜாவாஸ்கிரிப்டில் ஒரு புதிய, குளோபல் ஆப்ஜெக்ட் ஆகும், இது `Date` ஆப்ஜெக்ட்டின் குறைபாடுகளை நிவர்த்தி செய்ய வடிவமைக்கப்பட்டுள்ளது. இது தேதிகள், நேரங்கள், நேர மண்டலங்கள் மற்றும் காலண்டர் அமைப்புகளுடன் வேலை செய்வதற்கு ஒரு சுத்தமான, மாற்ற முடியாத (immutable) API-ஐ வழங்குகிறது. முக்கியமாக, இது நிஜ உலகப் பயன்பாடு மற்றும் எதிர்பார்ப்புகளுடன் மிகவும் நெருக்கமாகப் பொருந்தக்கூடிய வகையில் தேதி மற்றும் நேரக் கருத்துக்களைப் பிரதிநிதித்துவப்படுத்துவதை நோக்கமாகக் கொண்டுள்ளது, இது பன்னாட்டுமயமாக்கலை மிகவும் எளிதாக்குகிறது.
முக்கிய அம்சங்கள்:
- மாறாத்தன்மை (Immutability): டெம்போரல் ஆப்ஜெக்ட்கள் மாறாதவை, அதாவது நாட்கள் அல்லது மாதங்களைச் சேர்ப்பது போன்ற செயல்பாடுகள் அசல் ஆப்ஜெக்ட்டை மாற்றுவதற்குப் பதிலாக புதிய ஆப்ஜெக்ட்களை உருவாக்குகின்றன. இது பிழைகளின் பொதுவான மூலத்தை நீக்கி, கோடை எளிதாகப் புரிந்துகொள்ள வைக்கிறது.
- தெளிவான API: டெம்போரல் பொதுவான தேதி மற்றும் நேர செயல்பாடுகளுக்கு ஒரு நிலையான மற்றும் உள்ளுணர்வுடன் கூடிய API-ஐ வழங்குகிறது.
- நேர மண்டல ஆதரவு: டெம்போரல் நேர மண்டலங்களுக்கு வலுவான ஆதரவைக் கொண்டுள்ளது, பழைய `Date` ஆப்ஜெக்ட்டின் சிக்கல்கள் இல்லாமல் வெவ்வேறு இடங்களில் தேதிகள் மற்றும் நேரங்களுடன் வேலை செய்ய உங்களை அனுமதிக்கிறது. இது IANA நேர மண்டல தரவுத்தளத்தைப் பயன்படுத்துகிறது, துல்லியமான மற்றும் புதுப்பித்த தகவலை உறுதி செய்கிறது.
- காலண்டர் அமைப்புகள்: கிரிகோரியன் காலண்டருக்கு அப்பால், டெம்போரல் மாற்று காலண்டர் அமைப்புகளை ஆதரிக்கிறது, இது பல்வேறு கலாச்சாரங்கள் மற்றும் பிராந்தியங்களின் தேவைகளைப் பூர்த்தி செய்கிறது.
- மேம்படுத்தப்பட்ட துல்லியம்: டெம்போரல் நானோநொடி துல்லியத்தை வழங்குகிறது, இது மில்லிநொடி அடிப்படையிலான `Date` ஆப்ஜெக்ட்டின் வரம்புகளை நிவர்த்தி செய்கிறது.
அடிப்படை டெம்போரல் ஆப்ஜெக்ட்கள்
டெம்போரல் API பல புதிய ஆப்ஜெக்ட் வகைகளை அறிமுகப்படுத்துகிறது. இதோ சில முக்கிய ஆப்ஜெக்ட்கள்:
- `Temporal.PlainDate`: நேர மண்டலம் இல்லாமல் ஒரு தேதியை (ஆண்டு, மாதம், நாள்) குறிக்கிறது.
- `Temporal.PlainTime`: தேதி அல்லது நேர மண்டலம் இல்லாமல் ஒரு நேரத்தை (மணி, நிமிடம், நொடி, மில்லிநொடி, மைக்ரோநொடி, நானோநொடி) குறிக்கிறது.
- `Temporal.PlainDateTime`: நேர மண்டலம் இல்லாமல் ஒரு தேதி மற்றும் நேரத்தைக் குறிக்கிறது.
- `Temporal.ZonedDateTime`: ஒரு குறிப்பிட்ட நேர மண்டலத்துடன் கூடிய தேதி மற்றும் நேரத்தைக் குறிக்கிறது.
- `Temporal.Instant`: யூனிக்ஸ் எப்போக்கிலிருந்து (ஜனவரி 1, 1970 UTC) நானோநொடிகளில் அளவிடப்பட்ட ஒரு குறிப்பிட்ட நேரத்தைக் குறிக்கிறது.
- `Temporal.TimeZone`: ஒரு நேர மண்டலத்தைக் குறிக்கிறது.
- `Temporal.Duration`: ஒரு கால அளவைக் குறிக்கிறது (எ.கா., 2 மணிநேரம், 30 நிமிடங்கள்).
- `Temporal.YearMonth`: ஒரு ஆண்டு மற்றும் மாதத்தைக் குறிக்கிறது.
- `Temporal.MonthDay`: ஒரு மாதம் மற்றும் நாளைக் குறிக்கிறது.
தேதிகளுடன் வேலை செய்தல்
ஒரு `Temporal.PlainDate`-ஐ உருவாக்குதல்
ஒரு `Temporal.PlainDate`-ஐ உருவாக்க, நீங்கள் கன்ஸ்ட்ரக்டரைப் பயன்படுத்தலாம்:
const plainDate = new Temporal.PlainDate(2024, 10, 27); // Year, Month (1-12), Day
console.log(plainDate.toString()); // Output: 2024-10-27நீங்கள் `from` மெத்தடையும் பயன்படுத்தலாம், இது ISO 8601 வடிவத்தில் ஒரு ஸ்டிரிங்கை ஏற்றுக்கொள்கிறது:
const plainDateFromString = Temporal.PlainDate.from('2024-10-27');
console.log(plainDateFromString.toString()); // Output: 2024-10-27தேதி கூறுகளைப் பெறுதல்
நீங்கள் `year`, `month`, மற்றும் `day` போன்ற பண்புகளைப் பயன்படுத்தி தனிப்பட்ட தேதி கூறுகளை அணுகலாம்:
console.log(plainDate.year); // Output: 2024
console.log(plainDate.month); // Output: 10
console.log(plainDate.day); // Output: 27தேதி கணக்கீடு
நாட்கள், வாரங்கள், மாதங்கள் அல்லது வருடங்களைச் சேர்க்க அல்லது கழிக்க, `plus` மற்றும் `minus` மெத்தடுகளைப் பயன்படுத்தவும். இந்த மெத்தடுகள் ஒரு புதிய `Temporal.PlainDate` ஆப்ஜெக்ட்டைத் தரும்:
const nextWeek = plainDate.plus({ days: 7 });
console.log(nextWeek.toString()); // Output: 2024-11-03
const lastMonth = plainDate.minus({ months: 1 });
console.log(lastMonth.toString()); // Output: 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)); // Output: -1 (date1 is earlier than date2)நேரங்களுடன் வேலை செய்தல்
ஒரு `Temporal.PlainTime`-ஐ உருவாக்குதல்
ஒரு `Temporal.PlainTime`-ஐ உருவாக்க, கன்ஸ்ட்ரக்டரைப் பயன்படுத்தவும்:
const plainTime = new Temporal.PlainTime(10, 30, 0); // Hour, Minute, Second
console.log(plainTime.toString()); // Output: 10:30:00அல்லது ISO 8601 நேர ஸ்டிரிங்குடன் `from` மெத்தடைப் பயன்படுத்தவும்:
const plainTimeFromString = Temporal.PlainTime.from('10:30:00');
console.log(plainTimeFromString.toString()); // Output: 10:30:00நேரக் கூறுகளைப் பெறுதல்
console.log(plainTime.hour); // Output: 10
console.log(plainTime.minute); // Output: 30
console.log(plainTime.second); // Output: 0நேரக் கணக்கீடு
const later = plainTime.plus({ minutes: 15 });
console.log(later.toString()); // Output: 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()); // Output: 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()); // Output: 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()); // Output: 2024-10-27T10:30:00-07:00[America/Los_Angeles] (The offset will depend on DST rules)
மாற்றாக, `Instant`-லிருந்து `Temporal.ZonedDateTime`-ஐ உருவாக்கவும்.
const instant = Temporal.Instant.fromEpochSeconds(1666866600); // Example timestamp
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO(timeZone); // Timezone like 'America/Los_Angeles'
console.log(zonedDateTimeFromInstant.toString());நேர மண்டலங்களுக்கு இடையில் மாற்றுதல்
நீங்கள் `withTimeZone` மெத்தடைப் பயன்படுத்தி ஒரு `Temporal.ZonedDateTime`-ஐ வேறு நேர மண்டலத்திற்கு மாற்றலாம்:
const newTimeZone = 'Europe/London';
const zonedDateTimeInLondon = zonedDateTime.withTimeZone(newTimeZone);
console.log(zonedDateTimeInLondon.toString()); // Output: 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); // Output: -07:00 (Depending on DST rules)துல்லியமான கணக்கீடுகளுக்கு சரியான IANA நேர மண்டல அடையாளங்காட்டிகளைப் பயன்படுத்துவது அவசியம். இந்த அடையாளங்காட்டிகள் பகல்நேர சேமிப்பு நேரம் மற்றும் நேர மண்டல எல்லைகளில் ஏற்படும் மாற்றங்களைப் பிரதிபலிக்கும் வகையில் தொடர்ந்து பராமரிக்கப்பட்டு புதுப்பிக்கப்படுகின்றன.
கால அளவுகள் (Durations)
`Temporal.Duration` ஆப்ஜெக்ட் ஒரு கால அளவைக் குறிக்கிறது. இது தேதிகள் மற்றும் நேரங்களில் இருந்து கூட்ட அல்லது கழிக்கப் பயன்படுகிறது.
ஒரு `Temporal.Duration`-ஐ உருவாக்குதல்
நீங்கள் கன்ஸ்ட்ரக்டரைப் பயன்படுத்தி, வருடங்கள், மாதங்கள், நாட்கள், மணிநேரம், நிமிடங்கள், வினாடிகள், மில்லி விநாடிகள், மைக்ரோ விநாடிகள் மற்றும் நானோ விநாடிகளைக் குறிப்பிடுவதன் மூலம் ஒரு `Temporal.Duration`-ஐ உருவாக்கலாம்:
const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8, 9); // Years, Months, Days, Hours, Minutes, Seconds, Milliseconds, Microseconds, Nanoseconds
console.log(duration.toString()); // Output: P1Y2M3DT4H5M6.007008009Sஅல்லது ஒரு ISO 8601 கால அளவு ஸ்டிரிங்கைப் பயன்படுத்துவதன் மூலம்:
const durationFromString = Temporal.Duration.from('P1Y2M3DT4H5M6S');
console.log(durationFromString.toString()); // Output: P1Y2M3DT4H5M6Sதேதிகள் மற்றும் நேரங்களில் கால அளவுகளைச் சேர்த்தல்
const plainDate = new Temporal.PlainDate(2024, 10, 27);
const duration = new Temporal.Duration(0, 0, 7); // 7 days
const newDate = plainDate.plus(duration);
console.log(newDate.toString()); // Output: 2024-11-03ஒரு மாதத்தில் அல்லது வருடத்தில் உள்ள நாட்களின் எண்ணிக்கை மாறுபடும் என்பதால், மாதங்கள் அல்லது வருடங்களைக் கொண்ட கால அளவுகளை தேதிகளில் சேர்க்கும்போது கவனமாக இருக்க வேண்டும்.
காலண்டர் அமைப்புகள்
டெம்போரல் API கிரிகோரியன் காலண்டருக்கு அப்பால் வெவ்வேறு காலண்டர் அமைப்புகளை ஆதரிக்கிறது. பல்வேறு கலாச்சாரச் சூழல்களில் தேதிகளைக் கையாள வேண்டிய பயன்பாடுகளுக்கு இது மிகவும் முக்கியமானது. ஆதரவு இன்னும் வளர்ந்து கொண்டிருந்தாலும், இது எதிர்கால விரிவாக்கத்திற்கு ஒரு அடித்தளத்தை வழங்குகிறது.
மாற்றுக் காலண்டர்களைப் பயன்படுத்துதல்
ஒரு குறிப்பிட்ட காலண்டரைப் பயன்படுத்த, டெம்போரல் ஆப்ஜெக்ட்களை உருவாக்கும்போது அதை நீங்கள் குறிப்பிடலாம்:
const hebrewDate = new Temporal.PlainDate(5785, 1, 1, { calendar: 'hebrew' });
console.log(hebrewDate.toString()); // The specific output may vary depending on the implementation and formatting. Requires polyfill in many environments as of writing this.முக்கியம்: கிரிகோரியன் அல்லாத காலண்டர்களுக்கான ஆதரவுக்கு பாலிஃபில்கள் அல்லது குறிப்பிட்ட உலாவி/சூழல் ஆதரவு தேவைப்படலாம். சமீபத்திய தகவல்களுக்கு டெம்போரல் 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)); // Output: October 27, 2024
const formatterGerman = new Intl.DateTimeFormat('de-DE', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatterGerman.format(plainDate)); // Output: 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)); // Output: October 27, 2024, 10:30 AM PDT (The time zone abbreviation depends on DST rules)பன்னாட்டுமயமாக்கலுக்கான சிறந்த நடைமுறைகள்
உலகளாவிய சூழலில் தேதிகள் மற்றும் நேரங்களுடன் பணிபுரியும்போது, பின்வரும் சிறந்த நடைமுறைகளைக் கவனத்தில் கொள்ளுங்கள்:
- IANA நேர மண்டல அடையாளங்காட்டிகளைப் பயன்படுத்தவும்: துல்லியமான நேர மண்டலக் கையாளுதலுக்கு எப்போதும் IANA நேர மண்டல அடையாளங்காட்டிகளை (எ.கா., `America/Los_Angeles`, `Europe/London`) பயன்படுத்தவும்.
- பகல்நேர சேமிப்பு நேரத்தைப் பற்றி அறிந்திருங்கள்: பகல்நேர சேமிப்பு நேரம் (DST) நேர மண்டல ஆஃப்செட்களைப் பாதிக்கலாம். டெம்போரல் API தானாகவே DST மாற்றங்களைக் கையாளுகிறது.
- வடிவமைப்பிற்கு `Intl.DateTimeFormat`-ஐப் பயன்படுத்தவும்: பயனரின் லோகேலுக்கு ஏற்ப தேதிகள் மற்றும் நேரங்களை வடிவமைக்க `Intl.DateTimeFormat` ஆப்ஜெக்ட்டைப் பயன்படுத்தவும்.
- காலண்டர் அமைப்புகளைக் கருத்தில் கொள்ளுங்கள்: உங்கள் பயன்பாடு வெவ்வேறு கலாச்சாரச் சூழல்களில் உள்ள பயனர்களை ஆதரிக்க வேண்டும் என்றால், மாற்று காலண்டர் அமைப்புகளைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
- தேதிகள் மற்றும் நேரங்களை UTC-இல் சேமிக்கவும்: தரவுத்தளத்தில் தேதிகள் மற்றும் நேரங்களைச் சேமிக்கும்போது, நேர மண்டலச் சிக்கல்களைத் தவிர்க்க அவற்றை UTC-இல் (ஒருங்கிணைந்த உலக நேரம்) சேமிப்பதே சிறந்த நடைமுறை. பின்னர், காட்சி நோக்கங்களுக்காக உள்ளூர் நேரத்திற்கு மாற்றவும். டெம்போரல் UTC-க்கு மற்றும் அதிலிருந்து மாற்றுவதற்கான மெத்தடுகளை வழங்குகிறது.
- முழுமையாகச் சோதிக்கவும்: உங்கள் பயன்பாடு அனைத்துப் பயனர்களுக்கும் சரியாகச் செயல்படுவதை உறுதிசெய்ய, வெவ்வேறு நேர மண்டலங்கள், லோகேல்கள் மற்றும் காலண்டர் அமைப்புகளுடன் சோதிக்கவும்.
டெம்போரல் API-ஐ பழைய Date ஆப்ஜெக்ட்டுடன் ஒப்பிடுதல்
பழைய `Date` ஆப்ஜெக்ட்டுடன் ஒப்பிடும்போது டெம்போரல் API-யின் முக்கிய வேறுபாடுகள் மற்றும் நன்மைகளை முன்னிலைப்படுத்தும் ஒரு அட்டவணை இங்கே:
| அம்சம் | பழைய `Date` ஆப்ஜெக்ட் | டெம்போரல் API |
|---|---|---|
| மாறும் தன்மை (Mutability) | மாறக்கூடியது (அசல் ஆப்ஜெக்ட்டை மாற்றியமைக்கிறது) | மாறாதது (புதிய ஆப்ஜெக்ட்களைத் தருகிறது) |
| நேர மண்டல ஆதரவு | வரையறுக்கப்பட்ட மற்றும் பெரும்பாலும் சிக்கலானது | IANA நேர மண்டல தரவுத்தளத்தின் அடிப்படையில் வலுவான மற்றும் துல்லியமானது |
| API | சீரற்றது மற்றும் பயன்படுத்த கடினமானது | தெளிவான, நிலையான மற்றும் உள்ளுணர்வுடன் கூடியது |
| துல்லியம் | மில்லிநொடி | நானோநொடி |
| காலண்டர் அமைப்புகள் | கிரிகோரியனுக்கு மட்டும் வரையறுக்கப்பட்டுள்ளது | மாற்று காலண்டர் அமைப்புகளை ஆதரிக்கிறது (வளர்ந்து வரும் ஆதரவுடன்) |
| பன்னாட்டுமயமாக்கல் | வலுவான பன்னாட்டுமயமாக்கலுக்கு வெளிப்புற லைப்ரரிகள் தேவை | உள்ளமைக்கப்பட்ட ஆதரவு மற்றும் `Intl.DateTimeFormat` உடன் தடையற்ற ஒருங்கிணைப்பு |
உலாவி ஆதரவு மற்றும் பாலிஃபில்கள்
ஒரு ஒப்பீட்டளவில் புதிய API என்பதால், டெம்போரல் API-க்கான உலாவி ஆதரவு இன்னும் வளர்ந்து வருகிறது. எந்த உலாவிகள் மற்றும் சூழல்கள் இதை இயல்பாக ஆதரிக்கின்றன என்பதைப் பார்க்க, சமீபத்திய உலாவி இணக்கத்தன்மை அட்டவணைகளை (எ.கா., MDN Web Docs-இல்) சரிபார்க்கவும். பழைய உலாவிகள் அல்லது இயல்புநிலை ஆதரவு இல்லாத சூழல்களுக்கு, டெம்போரல் API செயல்பாட்டை வழங்க பாலிஃபில்களைப் பயன்படுத்தலாம். பொருத்தமான விருப்பங்களைக் கண்டுபிடிக்க இணையத்தில் "Temporal API polyfill" என்று தேடவும்.
முடிவுரை
ஜாவாஸ்கிரிப்ட் டெம்போரல் API, ஜாவாஸ்கிரிப்டில் தேதிகள் மற்றும் நேரங்களைக் கையாள்வதில் ஒரு குறிப்பிடத்தக்க முன்னேற்றத்தைக் குறிக்கிறது. அதன் மாறாத்தன்மை, தெளிவான API, வலுவான நேர மண்டல ஆதரவு மற்றும் காலண்டர் அமைப்பு திறன்கள் ஆகியவை பல்வேறு சர்வதேச சூழல்களில் தேதிகள் மற்றும் நேரங்களுடன் துல்லியமாகவும் நம்பகத்தன்மையுடனும் பணியாற்ற வேண்டிய பயன்பாடுகளை உருவாக்கும் டெவலப்பர்களுக்கு ஒரு சக்திவாய்ந்த கருவியாக அமைகிறது. உலாவி ஆதரவு இன்னும் வளர்ந்து கொண்டிருந்தாலும், டெம்போரல் API-யின் நன்மைகள் புதிய திட்டங்களுக்கு அதைக் கற்றுக்கொள்வதற்கும் ஏற்றுக்கொள்வதற்கும் மதிப்புள்ளதாக ஆக்குகின்றன. டெம்போரல் API-ஐ ஏற்றுக்கொள்வதன் மூலமும், பன்னாட்டுமயமாக்கலுக்கான சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலமும், உலகெங்கிலும் உள்ள பயனர்களுக்கு தடையற்ற மற்றும் துல்லியமான தேதி மற்றும் நேர அனுபவத்தை வழங்கும் பயன்பாடுகளை நீங்கள் உருவாக்கலாம்.