M

MLOG

മലയാളം

ജാവാസ്ക്രിപ്റ്റ് ടെമ്പറൽ എപിഐയെക്കുറിച്ചുള്ള ഒരു വിശദമായ ഗൈഡ്. വൈവിധ്യമാർന്ന അന്താരാഷ്ട്ര സാഹചര്യങ്ങളിൽ തീയതികളും സമയവും ഫലപ്രദമായി കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു ആധുനിക മാർഗ്ഗമാണിത്.

ജാവാസ്ക്രിപ്റ്റ് ടെമ്പറൽ എപിഐ: ആഗോള ഉപയോക്താക്കൾക്കായി ആധുനിക തീയതിയും സമയവും കൈകാര്യം ചെയ്യൽ

ജാവാസ്ക്രിപ്റ്റിന്റെ `Date` ഒബ്ജക്റ്റ് ഡെവലപ്പർമാർക്ക് വളരെക്കാലമായി ഒരു തലവേദനയാണ്. അതിന്റെ മാറ്റങ്ങൾ വരുത്താനുള്ള സ്വഭാവം (mutability), സ്ഥിരതയില്ലാത്ത എപിഐ, ടൈംസോൺ പിന്തുണയുടെ അഭാവം എന്നിവ Moment.js, date-fns പോലുള്ള നിരവധി ലൈബ്രറികൾക്ക് കാരണമായി. എന്നാൽ ഇപ്പോൾ, ടെമ്പറൽ എപിഐയിലൂടെ, മെച്ചപ്പെട്ട വ്യക്തതയോടും കൃത്യതയോടും കൂടി തീയതികളും സമയവും കൈകാര്യം ചെയ്യാൻ ജാവാസ്ക്രിപ്റ്റ് ഒരു ആധുനികവും ബിൽറ്റ്-ഇൻ ആയതുമായ പരിഹാരം നൽകുന്നു. ഈ ലേഖനം ടെമ്പറൽ എപിഐയെക്കുറിച്ചുള്ള സമഗ്രമായ ഒരു അവലോകനം നൽകുന്നു, അതിന്റെ സവിശേഷതകൾ, പ്രയോജനങ്ങൾ, വിവിധ അന്താരാഷ്ട്ര സാഹചര്യങ്ങളിലുള്ള ഉപയോഗം എന്നിവയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു.

എന്താണ് ടെമ്പറൽ എപിഐ?

`Date` ഒബ്ജക്റ്റിന്റെ പോരായ്മകൾ പരിഹരിക്കുന്നതിനായി രൂപകൽപ്പന ചെയ്ത ജാവാസ്ക്രിപ്റ്റിലെ ഒരു പുതിയ ഗ്ലോബൽ ഒബ്ജക്റ്റാണ് ടെമ്പറൽ എപിഐ. തീയതികൾ, സമയങ്ങൾ, സമയ മേഖലകൾ (time zones), കലണ്ടർ സംവിധാനങ്ങൾ എന്നിവയുമായി പ്രവർത്തിക്കാൻ ഇത് വ്യക്തവും മാറ്റങ്ങൾ വരുത്താനാവാത്തതുമായ (immutable) ഒരു എപിഐ നൽകുന്നു. യഥാർത്ഥ ലോക ഉപയോഗത്തിനും പ്രതീക്ഷകൾക്കും അനുസൃതമായി തീയതിയും സമയവും പ്രതിനിധീകരിക്കാൻ ഇത് ലക്ഷ്യമിടുന്നു, ഇത് അന്താരാഷ്ട്രവൽക്കരണം (internationalization) കൂടുതൽ എളുപ്പമാക്കുന്നു.

പ്രധാന സവിശേഷതകൾ:

അടിസ്ഥാന ടെമ്പറൽ ഒബ്ജക്റ്റുകൾ

ടെമ്പറൽ എപിഐ നിരവധി പുതിയ ഒബ്ജക്റ്റ് തരങ്ങൾ അവതരിപ്പിക്കുന്നു. അവയിൽ ചില പ്രധാനപ്പെട്ടവ താഴെ നൽകുന്നു:

തീയതികളുമായി പ്രവർത്തിക്കുന്നു

ഒരു `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

ടൈംസോണുകൾ

വിവിധ സ്ഥലങ്ങളിലുള്ള ഉപയോക്താക്കളുമായി ഇടപെടുന്ന ആപ്ലിക്കേഷനുകൾക്ക് ടൈംസോണുകൾ ശരിയായി കൈകാര്യം ചെയ്യേണ്ടത് അത്യാവശ്യമാണ്. ടെമ്പറൽ എപിഐ, `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

ഒരു മാസത്തിലെയോ വർഷത്തിലെയോ ദിവസങ്ങളുടെ എണ്ണം വ്യത്യാസപ്പെടാവുന്നതിനാൽ, മാസങ്ങളോ വർഷങ്ങളോ ഉൾപ്പെടുന്ന കാലാവധികൾ തീയതികളിൽ ചേർക്കുമ്പോൾ ശ്രദ്ധാപൂർവ്വം പരിഗണിക്കേണ്ടതുണ്ട്.

കലണ്ടർ സംവിധാനങ്ങൾ

ടെമ്പറൽ എപിഐ ഗ്രിഗോറിയൻ കലണ്ടറിനപ്പുറം വ്യത്യസ്ത കലണ്ടർ സംവിധാനങ്ങളെ പിന്തുണയ്ക്കുന്നു. വിവിധ സാംസ്കാരിക പശ്ചാത്തലങ്ങളിൽ തീയതികൾ കൈകാര്യം ചെയ്യേണ്ട ആപ്ലിക്കേഷനുകൾക്ക് ഇത് നിർണായകമാണ്. പിന്തുണ ഇപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുകയാണെങ്കിലും, ഭാവിയിലെ വിപുലീകരണത്തിന് ഇത് ഒരു അടിത്തറ നൽകുന്നു.

മറ്റ് കലണ്ടറുകൾ ഉപയോഗിക്കുന്നു

ഒരു പ്രത്യേക കലണ്ടർ ഉപയോഗിക്കുന്നതിന്, ടെമ്പറൽ ഒബ്ജക്റ്റുകൾ നിർമ്മിക്കുമ്പോൾ നിങ്ങൾക്ക് അത് വ്യക്തമാക്കാൻ കഴിയും:

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.

പ്രധാനമായി: ഗ്രിഗോറിയൻ ഇതര കലണ്ടറുകൾക്കുള്ള പിന്തുണയ്ക്ക് പോളിഫില്ലുകളോ പ്രത്യേക ബ്രൗസർ/എൻവയോൺമെന്റ് പിന്തുണയോ ആവശ്യമായി വന്നേക്കാം. ഏറ്റവും പുതിയ വിവരങ്ങൾക്കായി ടെമ്പറൽ എപിഐ ഡോക്യുമെന്റേഷനും ബ്രൗസർ കോംപാറ്റിബിലിറ്റി ടേബിളുകളും പരിശോധിക്കുക.

തീയതിയും സമയവും ഫോർമാറ്റ് ചെയ്യുന്നു

ടെമ്പറൽ എപിഐ തീയതി-സമയ പ്രവർത്തനങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുമ്പോൾ, ഫോർമാറ്റിംഗ് സാധാരണയായി `Intl.DateTimeFormat` ഒബ്ജക്റ്റാണ് കൈകാര്യം ചെയ്യുന്നത്, ഇത് ഇന്റർനാഷണലൈസേഷൻ എപിഐയുടെ ഭാഗമാണ്. ടെമ്പറൽ ഒബ്ജക്റ്റുകൾ `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)

അന്താരാഷ്ട്രവൽക്കരണത്തിനുള്ള മികച്ച രീതികൾ

ആഗോള പശ്ചാത്തലത്തിൽ തീയതികളും സമയവും കൈകാര്യം ചെയ്യുമ്പോൾ, താഴെ പറയുന്ന മികച്ച രീതികൾ മനസ്സിൽ വയ്ക്കുക:

ടെമ്പറൽ എപിഐയും പഴയ Date ഒബ്ജക്റ്റും തമ്മിലുള്ള താരതമ്യം

ടെമ്പറൽ എപിഐയും പഴയ `Date` ഒബ്ജക്റ്റും തമ്മിലുള്ള പ്രധാന വ്യത്യാസങ്ങളും ഗുണങ്ങളും വ്യക്തമാക്കുന്ന ഒരു പട്ടിക താഴെ നൽകുന്നു:

സവിശേഷത പഴയ `Date` ഒബ്ജക്റ്റ് ടെമ്പറൽ എപിഐ
മാറ്റം വരുത്താനുള്ള കഴിവ് (Mutability) മാറ്റാൻ കഴിയുന്നത് (യഥാർത്ഥ ഒബ്ജക്റ്റിനെ മാറ്റുന്നു) മാറ്റാൻ കഴിയാത്തത് (പുതിയ ഒബ്ജക്റ്റുകൾ നൽകുന്നു)
ടൈംസോൺ പിന്തുണ പരിമിതവും പലപ്പോഴും പ്രശ്നമുള്ളതും IANA ടൈംസോൺ ഡാറ്റാബേസ് അടിസ്ഥാനമാക്കി ശക്തവും കൃത്യവും
എപിഐ സ്ഥിരതയില്ലാത്തതും ഉപയോഗിക്കാൻ പ്രയാസമുള്ളതും വ്യക്തവും സ്ഥിരതയുള്ളതും ലളിതവും
കൃത്യത മില്ലിസെക്കൻഡ് നാനോസെക്കൻഡ്
കലണ്ടർ സംവിധാനങ്ങൾ ഗ്രിഗോറിയനിൽ പരിമിതപ്പെടുത്തിയിരിക്കുന്നു മറ്റ് കലണ്ടർ സംവിധാനങ്ങളെ പിന്തുണയ്ക്കുന്നു (പിന്തുണ വികസിച്ചുകൊണ്ടിരിക്കുന്നു)
അന്താരാഷ്ട്രവൽക്കരണം ശക്തമായ അന്താരാഷ്ട്രവൽക്കരണത്തിനായി ബാഹ്യ ലൈബ്രറികൾ ആവശ്യമാണ് `Intl.DateTimeFormat`-മായി ഇൻ-ബിൽറ്റ് പിന്തുണയും തടസ്സമില്ലാത്ത സംയോജനവും

ബ്രൗസർ പിന്തുണയും പോളിഫില്ലുകളും

ഒരു പുതിയ എപിഐ ആയതുകൊണ്ട്, ടെമ്പറൽ എപിഐക്കുള്ള ബ്രൗസർ പിന്തുണ ഇപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുകയാണ്. ഏതൊക്കെ ബ്രൗസറുകളും എൻവയോൺമെന്റുകളും ഇതിനെ സ്വാഭാവികമായി പിന്തുണയ്ക്കുന്നുവെന്ന് കാണാൻ ഏറ്റവും പുതിയ ബ്രൗസർ കോംപാറ്റിബിലിറ്റി ടേബിളുകൾ (ഉദാ. MDN വെബ് ഡോക്സിൽ) പരിശോധിക്കുക. പഴയ ബ്രൗസറുകൾക്കോ നേറ്റീവ് പിന്തുണയില്ലാത്ത എൻവയോൺമെന്റുകൾക്കോ വേണ്ടി, ടെമ്പറൽ എപിഐയുടെ പ്രവർത്തനം നൽകുന്നതിന് നിങ്ങൾക്ക് പോളിഫില്ലുകൾ ഉപയോഗിക്കാം. അനുയോജ്യമായ ഓപ്ഷനുകൾ കണ്ടെത്താൻ വെബിൽ "Temporal API polyfill" എന്ന് തിരയുക.

ഉപസംഹാരം

ജാവാസ്ക്രിപ്റ്റിൽ തീയതികളും സമയവും കൈകാര്യം ചെയ്യുന്നതിൽ ഒരു സുപ്രധാന ചുവടുവെപ്പാണ് ടെമ്പറൽ എപിഐ. അതിന്റെ മാറ്റാൻ കഴിയാത്ത സ്വഭാവം, വ്യക്തമായ എപിഐ, ശക്തമായ ടൈംസോൺ പിന്തുണ, കലണ്ടർ സിസ്റ്റം കഴിവുകൾ എന്നിവ വിവിധ അന്താരാഷ്ട്ര പശ്ചാത്തലങ്ങളിൽ കൃത്യമായും വിശ്വസനീയമായും തീയതികളും സമയവും ഉപയോഗിക്കേണ്ട ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്ന ഡെവലപ്പർമാർക്ക് ഒരു ശക്തമായ ഉപകരണമാക്കി മാറ്റുന്നു. ബ്രൗസർ പിന്തുണ ഇപ്പോഴും വികസിച്ചുകൊണ്ടിരിക്കുകയാണെങ്കിലും, ടെമ്പറൽ എപിഐയുടെ പ്രയോജനങ്ങൾ പുതിയ പ്രോജക്റ്റുകൾക്കായി പഠിക്കുന്നതിനും സ്വീകരിക്കുന്നതിനും യോഗ്യമാക്കുന്നു. ടെമ്പറൽ എപിഐ സ്വീകരിക്കുന്നതിലൂടെയും അന്താരാഷ്ട്രവൽക്കരണത്തിന്റെ മികച്ച രീതികൾ പിന്തുടരുന്നതിലൂടെയും, ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കൾക്ക് തടസ്സമില്ലാത്തതും കൃത്യവുമായ തീയതി-സമയ അനുഭവം നൽകുന്ന ആപ്ലിക്കേഷനുകൾ നിങ്ങൾക്ക് നിർമ്മിക്കാൻ കഴിയും.

കൂടുതലായി പഠിക്കാൻ