JavaScript-ൽ എഴുതിയിരിക്കുന്ന ഏത് തരത്തിലുള്ള ആപ്ലിക്കേഷനും സമയങ്ങളോ തീയതികളോ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു. തുടക്കത്തിൽ, ഇത് അന്തർനിർമ്മിത തീയതി API-യിൽ പരിമിതപ്പെടുത്തിയിരുന്നു. ഈ API അടിസ്ഥാന പ്രവർത്തനം ഉൾക്കൊള്ളുന്നു, എന്നാൽ അതിന് ചെയ്യാൻ കഴിയുന്ന കാര്യങ്ങളിൽ പരിമിതമാണ്. Moment.js പോലുള്ള മൂന്നാം കക്ഷി ലൈബ്രറികളും പിന്നീട് അന്തർനിർമ്മിത API-കളായ Intl API-കളും പുതിയ ടെമ്പറൽ API-കളും സമയവും തീയതിയും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിന് വളരെയധികം വഴക്കം നൽകുന്നു. നിമിഷത്തിൻ്റെ ഉയർച്ചയും പതനവും.js Moment.js സമയങ്ങളും തീയതികളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള ശക്തമായ യൂട്ടിലിറ്റികളുള്ള ഒരു JavaScript ലൈബ്രറിയാണ്. ടൈം സോൺ കൃത്രിമത്വം പോലെയുള്ള അടിസ്ഥാന തീയതി API-ൽ നിന്ന് നഷ്ടമായ സവിശേഷതകൾ ഇതിൽ ഉൾപ്പെടുന്നു, കൂടാതെ പല സാധാരണ പ്രവർത്തനങ്ങളും ലളിതമാക്കുന്നു. തീയതികളും സമയങ്ങളും ഫോർമാറ്റ് ചെയ്യുന്നതിനുള്ള ഫംഗ്ഷനുകളും മൊമെൻ്റിൽ ഉൾപ്പെടുന്നു. വിവിധ ആപ്ലിക്കേഷനുകളിൽ വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്ന ഒരു ലൈബ്രറിയായി ഇത് മാറി. എന്നിരുന്നാലും, മൊമെൻ്റിനും പ്രശ്നങ്ങളുടെ പങ്ക് ഉണ്ടായിരുന്നു. ഇതൊരു വലിയ ലൈബ്രറിയാണ്, കൂടാതെ ആപ്ലിക്കേഷൻ്റെ ബണ്ടിൽ വലുപ്പത്തിൽ ഗണ്യമായി ചേർക്കാനും കഴിയും. ലൈബ്രറി ട്രീ കുലുക്കലിനെ പിന്തുണയ്ക്കാത്തതിനാൽ (ലൈബ്രറികളുടെ ഉപയോഗിക്കാത്ത ഭാഗങ്ങൾ നീക്കം ചെയ്യാൻ കഴിയുന്ന ആധുനിക ബണ്ട്ലറുകളുടെ സവിശേഷത), നിങ്ങൾ അതിൻ്റെ ഒന്നോ രണ്ടോ ഫംഗ്ഷനുകൾ മാത്രം ഉപയോഗിച്ചാൽ പോലും മൊമെൻ്റ് ലൈബ്രറി മുഴുവൻ ഉൾപ്പെടുത്തും. മൊമെൻ്റുമായി ബന്ധപ്പെട്ട മറ്റൊരു പ്രശ്നം, അത് സൃഷ്ടിക്കുന്ന വസ്തുക്കൾ മാറ്റാവുന്നവയാണ് എന്നതാണ്. ഒരു മൊമെൻ്റ് ഒബ്ജക്റ്റിൽ ചില ഫംഗ്ഷനുകൾ വിളിക്കുന്നത് പാർശ്വഫലങ്ങൾ ഉണ്ടാക്കുകയും ആ ഒബ്ജക്റ്റിൻ്റെ മൂല്യത്തെ പരിവർത്തനം ചെയ്യുകയും ചെയ്യുന്നു. ഇത് അപ്രതീക്ഷിതമായ പെരുമാറ്റത്തിനോ ബഗുകളിലേക്കോ നയിച്ചേക്കാം. 2020-ൽ, മൊമെൻ്റിൻ്റെ പരിപാലകർ ലൈബ്രറിയെ മെയിൻ്റനൻസ് മോഡിലേക്ക് മാറ്റാൻ തീരുമാനിച്ചു. പുതിയ ഫീച്ചർ ഡെവലപ്മെൻ്റ് ഒന്നും നടക്കുന്നില്ല, പുതിയ പ്രോജക്റ്റുകൾക്കായി ഇത് ഉപയോഗിക്കരുതെന്ന് പരിപാലിക്കുന്നവർ ശുപാർശ ചെയ്യുന്നു. ഡേറ്റ്-എഫ്എൻഎസ് പോലുള്ള മറ്റ് ജാവാസ്ക്രിപ്റ്റ് തീയതി ലൈബ്രറികളുണ്ട്, എന്നാൽ നഗരത്തിൽ ഒരു പുതിയ പ്ലേയർ ഉണ്ട്, ജാവാസ്ക്രിപ്റ്റിൽ നേരിട്ട് നിർമ്മിച്ച ഒരു എപിഐ: ടെമ്പറൽ. യഥാർത്ഥ തീയതി API-യുടെ ദ്വാരങ്ങൾ നിറയ്ക്കുകയും മൊമെൻ്റിലും മറ്റ് ലൈബ്രറികളിലും കാണുന്ന ചില പരിമിതികൾ പരിഹരിക്കുകയും ചെയ്യുന്ന ഒരു പുതിയ മാനദണ്ഡമാണിത്. എന്താണ് താൽക്കാലികം? ആധുനിക ജാവാസ്ക്രിപ്റ്റ് നിർവചിക്കുന്ന ECMAScript സ്റ്റാൻഡേർഡിലേക്ക് ചേർക്കുന്ന പുതിയ സമയവും തീയതിയും API ആണ് ടെമ്പറൽ. 20266 മാർച്ച് വരെ, ഇത് TC39 പ്രക്രിയയുടെ 4-ാം ഘട്ടത്തിൽ എത്തിയിരിക്കുന്നു (JavaScript ഭാഷയിലേക്കുള്ള നിർദ്ദേശങ്ങളും കൂട്ടിച്ചേർക്കലുകളും മേൽനോട്ടം വഹിക്കുന്ന സമിതി), ECMAScript സ്പെസിഫിക്കേഷൻ്റെ അടുത്ത പതിപ്പിൽ ഉൾപ്പെടുത്തും. ഇത് ഇതിനകം തന്നെ നിരവധി ബ്രൗസറുകളിൽ നടപ്പിലാക്കിയിട്ടുണ്ട്: Chrome 144+, Firefox 139+, Safari ഉടൻ പിന്തുടരുമെന്ന് പ്രതീക്ഷിക്കുന്നു. പിന്തുണയ്ക്കാത്ത ബ്രൗസറുകൾക്കും Node.js-നും ഒരു പോളിഫിൽ ലഭ്യമാണ്. ടെമ്പറൽ API ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നു, പൊതുവെ, സമയത്തിലെ നിമിഷങ്ങളെ പ്രതിനിധീകരിക്കുന്നു. ഇവ ഒരു നിശ്ചിത സമയമേഖലയിലെ മുഴുവൻ സമയ, തീയതി സ്റ്റാമ്പുകളാകാം, അല്ലെങ്കിൽ സമയ മേഖലയോ തീയതിയോ സംബന്ധിച്ച വിവരങ്ങളില്ലാതെ “വാൾ ക്ലോക്ക്” സമയത്തിൻ്റെ പൊതുവായ ഉദാഹരണമായിരിക്കാം. ടെമ്പറലിൻ്റെ ചില പ്രധാന സവിശേഷതകളിൽ ഇവ ഉൾപ്പെടുന്നു:
തീയതികൾ ഉള്ളതോ അല്ലാത്തതോ ആയ സമയങ്ങൾ. ഒരു താത്കാലിക ഒബ്ജക്റ്റിന് ഒരു നിർദ്ദിഷ്ട തീയതിയിലെ ഒരു നിർദ്ദിഷ്ട സമയത്തെ അല്ലെങ്കിൽ തീയതി വിവരങ്ങളില്ലാത്ത സമയത്തെ പ്രതിനിധീകരിക്കാൻ കഴിയും. സമയമില്ലാതെ ഒരു നിർദ്ദിഷ്ട തീയതിയും പ്രതിനിധീകരിക്കാം. ടൈം സോൺ സപ്പോർട്ട്. ടെമ്പറൽ ഒബ്ജക്റ്റുകൾ പൂർണ്ണമായി സമയ മേഖലയെ കുറിച്ച് ബോധവാന്മാരാണ്, അവ വ്യത്യസ്ത സമയ മേഖലകളിലുടനീളം പരിവർത്തനം ചെയ്യാവുന്നതാണ്. മൊമെൻ്റ് സമയ മേഖലകളെയും പിന്തുണയ്ക്കുന്നു, എന്നാൽ ഇതിന് അധിക മൊമെൻ്റ്-ടൈംസോൺ ലൈബ്രറി ആവശ്യമാണ്. മാറ്റമില്ലാത്തത്. ഒരു താൽക്കാലിക വസ്തു സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, അത് മാറ്റാൻ കഴിയില്ല. സമയ ഗണിതമോ സമയമേഖലയോ പരിവർത്തനങ്ങൾ അടിസ്ഥാന വസ്തുവിനെ പരിഷ്ക്കരിക്കില്ല. പകരം, അവർ ഒരു പുതിയ താൽക്കാലിക വസ്തുവിനെ സൃഷ്ടിക്കുന്നു. 1-അടിസ്ഥാന ഇൻഡക്സിംഗ്. മാസങ്ങൾ പൂജ്യം സൂചികയിലാണെന്നതാണ് തീയതി API (അതുപോലെ തന്നെ മൊമെൻ്റ്) ഉള്ള ബഗുകളുടെ ഒരു പൊതു ഉറവിടം. യഥാർത്ഥ ജീവിതത്തിൽ നാമെല്ലാവരും മനസ്സിലാക്കുന്നതുപോലെ, മാസം 1 എന്നതിനേക്കാൾ ജനുവരി മാസം 0 ആണെന്നാണ് ഇതിനർത്ഥം. 1-അടിസ്ഥാന സൂചിക ഉപയോഗിച്ച് താൽക്കാലികമായി ഇത് പരിഹരിക്കുന്നു - ജനുവരി മാസം 1 ആണ്. ഇത് ബ്രൗസറിലാണ് നിർമ്മിച്ചിരിക്കുന്നത്. ബ്രൗസറിലെ തന്നെ ടെമ്പറൽ ഒരു API ആയതിനാൽ, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ ബണ്ടിൽ വലുപ്പത്തിൽ ഇത് ഒന്നും ചേർക്കുന്നില്ല.
തീയതി API ഇല്ലാതാകുന്നില്ല എന്നതും ശ്രദ്ധിക്കേണ്ടതാണ്. ടെമ്പറൽ ഈ API അസാധുവാക്കുമ്പോൾ, അത് നീക്കം ചെയ്യുകയോ ഒഴിവാക്കുകയോ ചെയ്യുന്നില്ല. ബ്രൗസറുകൾ പെട്ടെന്ന് Date API നീക്കം ചെയ്താൽ പല ആപ്ലിക്കേഷനുകളും തകരും. എന്നിരുന്നാലും, മൊമെൻ്റ് ഇപ്പോൾ മെയിൻ്റനൻസ് മോഡിൽ ഒരു ലെഗസി പ്രോജക്റ്റായി കണക്കാക്കപ്പെടുന്നു എന്നതും ഓർക്കുക. ലേഖനത്തിൻ്റെ ബാക്കി ഭാഗങ്ങളിൽ, പുതിയ ടെമ്പറൽ API-ലേക്ക് മൊമെൻ്റ് അടിസ്ഥാനമാക്കിയുള്ള കോഡ് മൈഗ്രേറ്റ് ചെയ്യുന്നതിനുള്ള ചില "പാചകക്കുറിപ്പുകൾ" ഞങ്ങൾ നോക്കും. നമുക്ക് റീഫാക്ടറിംഗ് ആരംഭിക്കാം! തീയതിയും സമയവും ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നു തീയതികളും സമയങ്ങളും കൈകാര്യം ചെയ്യുന്നതിന് മുമ്പ്, അവയെ പ്രതിനിധീകരിക്കുന്ന ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. നിലവിലെ തീയതിയും സമയവും പ്രതിനിധീകരിക്കുന്ന ഒരു മൊമെൻ്റ് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ, മൊമെൻ്റ് ഫംഗ്ഷൻ ഉപയോഗിക്കുക. കോൺസ്റ്റ് ഇപ്പോൾ = നിമിഷം(); console.log(ഇപ്പോൾ); // നിമിഷം<2026-02-18T21:26:29-05:00>
ഈ ഒബ്ജക്റ്റ് ഇപ്പോൾ ഫോർമാറ്റ് ചെയ്യാനോ ആവശ്യാനുസരണം കൈകാര്യം ചെയ്യാനോ കഴിയും.
// യുടിസിയിലേക്ക് പരിവർത്തനം ചെയ്യുക //മുന്നറിയിപ്പ്: ഇത് മൊമെൻ്റ് ഒബ്ജക്റ്റിനെ മ്യൂട്ടേറ്റ് ചെയ്യുകയും യുടിസി മോഡിൽ ഇടുകയും ചെയ്യുന്നു! console.log(now.utc()); // നിമിഷം<2026-02-19T02:26:29Z>
// ഫോർമാറ്റ് ചെയ്ത ഒരു സ്ട്രിംഗ് പ്രിൻ്റ് ചെയ്യുക - അത് ഇപ്പോൾ UTC സമയമാണ് ഉപയോഗിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കുക console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // 02/19/2026 02:27:07 am
മൊമെൻ്റിനെക്കുറിച്ച് ഓർമ്മിക്കേണ്ട പ്രധാന കാര്യം, ഒരു മൊമെൻ്റ് ഒബ്ജക്റ്റിൽ എല്ലായ്പ്പോഴും സമയത്തെയും തീയതിയെയും കുറിച്ചുള്ള വിവരങ്ങൾ ഉൾപ്പെടുന്നു എന്നതാണ്. നിങ്ങൾക്ക് സമയ വിവരങ്ങളുമായി മാത്രം പ്രവർത്തിക്കണമെങ്കിൽ, ഇത് സാധാരണയായി നല്ലതാണ്, പക്ഷേ ഇത് ഡേലൈറ്റ് സേവിംഗ് സമയം അല്ലെങ്കിൽ അധിവർഷങ്ങൾ പോലുള്ള സാഹചര്യങ്ങളിൽ അപ്രതീക്ഷിതമായ പെരുമാറ്റത്തിന് കാരണമാകും, ഇവിടെ തീയതി സമയ കണക്കുകൂട്ടലുകളിൽ സ്വാധീനം ചെലുത്തും. ടെമ്പറൽ കൂടുതൽ വഴക്കമുള്ളതാണ്. ഒരു Temporal.Instant ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നതിലൂടെ നിങ്ങൾക്ക് നിലവിലെ തീയതിയും സമയവും പ്രതിനിധീകരിക്കുന്ന ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാനാകും. "യുഗം" (1970 ജനുവരി 1-ന് അർദ്ധരാത്രി UTC) മുതലുള്ള സമയം നിർവ്വചിച്ച സമയത്തെ ഇത് പ്രതിനിധീകരിക്കുന്നു. നാനോ സെക്കൻഡ് ലെവൽ കൃത്യതയോടെ ടെമ്പറലിന് ഈ തൽക്ഷണം റഫറൻസ് ചെയ്യാൻ കഴിയും. const now = Temporal.Now.instant();
// യുഗം മുതൽ അസംസ്കൃത നാനോ സെക്കൻഡുകൾ കാണുക console.log(now.epochNanoseconds); // 1771466342612000000n
// യുടിസി ഫോർമാറ്റ് console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// ഒരു പ്രത്യേക സമയ മേഖലയ്ക്കുള്ള ഫോർമാറ്റ് console.log(now.toString({timeZone: 'America/New_York'})); // 2026-02-18T20:56:57.905-05:00
ടെമ്പറൽ. സ്റ്റാറ്റിക് രീതി ഉപയോഗിച്ച് ഒരു നിശ്ചിത സമയത്തിനും തീയതിക്കും വേണ്ടി തൽക്ഷണ ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കാനും കഴിയും.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// പ്രാദേശിക സമയ മേഖലയിൽ തൽക്ഷണം ഫോർമാറ്റ് ചെയ്യുക. ഇത് നിയന്ത്രിക്കുന്നത് മാത്രമാണെന്ന കാര്യം ശ്രദ്ധിക്കുക // ഫോർമാറ്റിംഗ് - moment.utc ചെയ്യുന്നതുപോലെ ഇത് ഒബ്ജക്റ്റിനെ പരിവർത്തനം ചെയ്യുന്നില്ല. console.log(myInstant.toString({timeZone: 'America/New_York'})); // 2026-02-18T21:10:00-05:00
നിങ്ങൾക്ക് മറ്റ് തരത്തിലുള്ള താൽക്കാലിക ഒബ്ജക്റ്റുകളും സൃഷ്ടിക്കാം, ഇനിപ്പറയുന്നവ ഉൾപ്പെടെ:
Temporal.PlainDate: സമയ വിവരങ്ങളില്ലാത്ത ഒരു തീയതി. Temporal.PlainTime: തീയതി വിവരങ്ങളില്ലാത്ത സമയം. Temporal.ZonedDateTime: ഒരു നിർദ്ദിഷ്ട സമയമേഖലയിലെ ഒരു തീയതിയും സമയവും.
ഇവയിൽ ഓരോന്നിനും തീയതി കൂടാതെ/അല്ലെങ്കിൽ സമയം വ്യക്തമാക്കുന്ന ഒബ്ജക്റ്റ് അല്ലെങ്കിൽ പാഴ്സ് ചെയ്യാനുള്ള തീയതി സ്ട്രിംഗ് ഉപയോഗിച്ച് വിളിക്കാവുന്ന ഒരു രീതിയുണ്ട്. // ഒരു തീയതി മാത്രം const today = Temporal.PlainDate.from({ വർഷം: 2026, മാസം: 2, // ശ്രദ്ധിക്കുക ഞങ്ങൾ ഫെബ്രുവരിയിൽ 2 ഉപയോഗിക്കുന്നു ദിവസം: 18 }); console.log(today.toString()); // 2026-02-18
//ഒരു സമയം മാത്രം const lunchTime = Temporal.PlainTime.from({ മണിക്കൂർ: 12 }); console.log(lunchTime.toString()); // 12:00:00
// യുഎസ് ഈസ്റ്റേൺ ടൈം സോണിലെ ഒരു തീയതിയും സമയവും const dueAt = Temporal.ZonedDateTime.from({ സമയമേഖല: 'അമേരിക്ക/ന്യൂയോർക്ക്', വർഷം: 2026, മാസം: 3, ദിവസം: 1, മണിക്കൂർ: 12, മിനിറ്റ്: 0, രണ്ടാമത്തേത്: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
പാഴ്സിംഗ് തീയതിയും സമയവും സംബന്ധിച്ച വിവരങ്ങളുടെ പ്രോഗ്രമാറ്റിക് സൃഷ്ടി ഞങ്ങൾ കവർ ചെയ്തു. ഇനി നമുക്ക് പാഴ്സിംഗ് നോക്കാം. ബിൽറ്റ്-ഇൻ ടെമ്പറൽ API-യെക്കാൾ മൊമെൻ്റ് കൂടുതൽ വഴക്കമുള്ള ഒരു മേഖലയാണ് പാഴ്സിംഗ്. നിങ്ങൾക്ക് ഒരു തീയതി സ്ട്രിംഗ് മൊമെൻ്റ് ഫംഗ്ഷനിലേക്ക് പാസുചെയ്യുന്നതിലൂടെ പാഴ്സ് ചെയ്യാം. ഒരൊറ്റ ആർഗ്യുമെൻ്റ് ഉപയോഗിച്ച്, മൊമെൻ്റ് ഒരു ISO തീയതി സ്ട്രിംഗ് പ്രതീക്ഷിക്കുന്നു, എന്നാൽ നിങ്ങൾ ഉപയോഗിക്കുന്ന തീയതി ഫോർമാറ്റ് വ്യക്തമാക്കുന്ന രണ്ടാമത്തെ ആർഗ്യുമെൻ്റ് നൽകുകയാണെങ്കിൽ നിങ്ങൾക്ക് ഇതര ഫോർമാറ്റുകൾ ഉപയോഗിക്കാം.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // നിമിഷം<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // നിമിഷം<2026-02-21T09:00:00-05:00>
പഴയ പതിപ്പുകളിൽ, ഏകപക്ഷീയമായി ഫോർമാറ്റ് ചെയ്ത ഏതെങ്കിലും തീയതി സ്ട്രിംഗിനെ പാഴ്സ് ചെയ്യാൻ മൊമെൻ്റ് മികച്ച ഊഹം ഉണ്ടാക്കും. ഇത് പ്രവചനാതീതമായ ഫലങ്ങളിലേക്ക് നയിച്ചേക്കാം. ഉദാഹരണത്തിന്, 02-03-2026 ഫെബ്രുവരി 2 അല്ലെങ്കിൽ മാർച്ച് 3? ഇക്കാരണത്താൽ, ഐഎസ്ഒ ഫോർമാറ്റ് ചെയ്ത തീയതി സ്ട്രിംഗ് ഇല്ലാതെയാണ് മൊമെൻ്റിൻ്റെ പുതിയ പതിപ്പുകൾ വിളിക്കുന്നതെങ്കിൽ (ആവശ്യമായ ഫോർമാറ്റിലുള്ള രണ്ടാമത്തെ ആർഗ്യുമെൻ്റ് നൽകിയിട്ടില്ലെങ്കിൽ) ഒരു പ്രമുഖ ഒഴിവാക്കൽ മുന്നറിയിപ്പ് പ്രദർശിപ്പിക്കുന്നു. പ്രത്യേകമായി ഫോർമാറ്റ് ചെയ്ത തീയതി സ്ട്രിംഗ് മാത്രമേ ടെമ്പറൽ പാഴ്സ് ചെയ്യുകയുള്ളൂ. സ്ട്രിംഗ് ISO 8601 ഫോർമാറ്റ് അല്ലെങ്കിൽ അതിൻ്റെ വിപുലീകരണമായ RFC 9557 അനുസരിച്ചായിരിക്കണം. അനുസരിക്കാത്ത തീയതി സ്ട്രിംഗ് ഒരു രീതിയിലേക്ക് കൈമാറുകയാണെങ്കിൽ, ടെമ്പറൽ ഒരു RangeError എറിയും.
// ഒരു RFC 9557 തീയതി സ്ട്രിംഗ് ഉപയോഗിക്കുന്നു const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({timeZone: 'America/New_York'})); // 2026-02-21T09:00:00-05:00
// ഒരു അജ്ഞാത തീയതി സ്ട്രിംഗ് ഉപയോഗിക്കുന്നു const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: താൽക്കാലിക പിശക്: വർഷ മൂല്യം പാഴ്സ് ചെയ്യുമ്പോൾ അക്ഷരം അസാധുവാണ്.
തീയതി സ്ട്രിംഗിൻ്റെ കൃത്യമായ ആവശ്യകതകൾ നിങ്ങൾ ഏത് തരത്തിലുള്ള ടെമ്പറൽ ഒബ്ജക്റ്റാണ് സൃഷ്ടിക്കുന്നത് എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. മുകളിലെ ഉദാഹരണത്തിൽ, Temporal.Instant-ന് ഒരു പൂർണ്ണ ISO ആവശ്യമാണ്8601 അല്ലെങ്കിൽ RFC 9557 തീയതി സ്ട്രിംഗ് ഒരു സമയ മേഖല ഓഫ്സെറ്റ് ഉപയോഗിച്ച് തീയതിയും സമയവും വ്യക്തമാക്കുന്നു, എന്നാൽ നിങ്ങൾക്ക് തീയതി ഫോർമാറ്റിൻ്റെ ഒരു ഉപസെറ്റ് ഉപയോഗിച്ച് PlainDate അല്ലെങ്കിൽ PlainTime ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കാനും കഴിയും. const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
ഈ സ്ട്രിംഗുകൾ ഇപ്പോഴും പ്രതീക്ഷിക്കുന്ന ഫോർമാറ്റിന് അനുസൃതമായിരിക്കണം, അല്ലെങ്കിൽ ഒരു പിശക് സംഭവിക്കും.
// അനുസൃതമല്ലാത്ത സമയ സ്ട്രിംഗുകൾ ഉപയോഗിക്കുന്നു. ഇവയെല്ലാം ഒരു RangeError എറിയും. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
പ്രോ ടിപ്പ്: ഐഎസ്ഒ ഇതര സ്ട്രിംഗുകൾ കൈകാര്യം ചെയ്യുന്നത് താൽക്കാലികം വിശ്വാസ്യതയ്ക്ക് മുൻഗണന നൽകുന്നതിനാൽ, 02-01-2026 പോലെയുള്ള ഒരു സ്ട്രിംഗിൻ്റെ ഫോർമാറ്റ് ഊഹിക്കാൻ ഇത് ശ്രമിക്കില്ല. നിങ്ങളുടെ ഡാറ്റാ ഉറവിടം അത്തരം സ്ട്രിംഗുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, ടെമ്പറലിനൊപ്പം ഉപയോഗിക്കാൻ ശ്രമിക്കുന്നതിന് മുമ്പ് മൂല്യങ്ങൾ 2026-02-01 പോലെയുള്ള ഒരു ISO സ്ട്രിംഗിലേക്ക് പുനഃക്രമീകരിക്കുന്നതിന് നിങ്ങൾ കുറച്ച് സ്ട്രിംഗ് കൃത്രിമത്വം നടത്തേണ്ടതുണ്ട്.
ഫോർമാറ്റിംഗ് നിങ്ങൾക്ക് ഒരു നിമിഷമോ താൽക്കാലികമോ ആയ ഒബ്ജക്റ്റ് ലഭിച്ചുകഴിഞ്ഞാൽ, ഒരു ഘട്ടത്തിൽ അത് ഫോർമാറ്റ് ചെയ്ത സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. നിമിഷം കുറച്ചുകൂടി തീവ്രമായ ഒരു സന്ദർഭമാണിത്. ആവശ്യമുള്ള തീയതി ഫോർമാറ്റ് വിവരിക്കുന്ന ടോക്കണുകളുടെ ഒരു സ്ട്രിംഗ് ഉപയോഗിച്ച് നിങ്ങൾ ഒബ്ജക്റ്റിൻ്റെ ഫോർമാറ്റ് രീതിയെ വിളിക്കുന്നു. കോൺസ്റ്റ് തീയതി = നിമിഷം ();
console.log(date.format('MM/DD/YYYY')); // 02/22/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // ഫെബ്രുവരി 22, 2026, 8:18:30 pm
മറുവശത്ത്, ടെമ്പറൽ നിങ്ങളോട് കുറച്ചുകൂടി വാചാലനായിരിക്കണമെന്ന് ആവശ്യപ്പെടുന്നു. തൽക്ഷണം പോലെയുള്ള ടെമ്പറൽ ഒബ്ജക്റ്റുകൾക്ക്, ഒരു ഒബ്ജക്റ്റിൻ്റെ പ്രോപ്പർട്ടികളായി വ്യക്തമാക്കിയ വിവിധ ഫോർമാറ്റിംഗ് ഓപ്ഷനുകൾ സ്വീകരിക്കുന്ന ഒരു toLocaleString രീതിയുണ്ട്.
കോൺസ്റ്റ് തീയതി = Temporal.Now.instant();
// ആർഗ്യുമെൻ്റുകളൊന്നുമില്ലാതെ, നിലവിലെ ഭാഷയുടെ സ്ഥിരസ്ഥിതി ഫോർമാറ്റ് ഞങ്ങൾക്ക് ലഭിക്കും console.log(date.toLocaleString()); // 2/22/2026, 8:23:36 PM (en-US ൻ്റെ ഒരു ലൊക്കേൽ അനുമാനിക്കുന്നു)
// ഒരു ഇഷ്ടാനുസൃത ഫോർമാറ്റ് സ്ട്രിംഗ് സൃഷ്ടിക്കാൻ ഫോർമാറ്റിംഗ് ഓപ്ഷനുകൾ പാസ്സാക്കുക console.log(date.toLocaleString('en-US', { മാസം: 'നീണ്ട', ദിവസം: 'സംഖ്യാ', വർഷം: 'സംഖ്യാ', മണിക്കൂർ: '2-അക്ക', മിനിറ്റ്: '2-അക്ക' })); // ഫെബ്രുവരി 22, 2026 8:23 PM
// ഫോർമാറ്റ് സ്ട്രിംഗിൽ നിങ്ങൾക്ക് ആവശ്യമുള്ള ഫീൽഡുകൾ മാത്രം നൽകുക console.log(date.toLocaleString('en-US', { മാസം: 'ഹ്രസ്വ', ദിവസം: 'സംഖ്യാ' })); //ഫെബ്രുവരി 22
താൽകാലിക തീയതി ഫോർമാറ്റിംഗ് യഥാർത്ഥത്തിൽ Intl.DateTimeFormat API ഉപയോഗിക്കുന്നു (ഇത് ആധുനിക ബ്രൗസറുകളിൽ ഇതിനകം തന്നെ ലഭ്യമാണ്) ഹുഡിന് കീഴിൽ. നിങ്ങളുടെ ഇഷ്ടാനുസൃത ഫോർമാറ്റിംഗ് ഓപ്ഷനുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് പുനരുപയോഗിക്കാവുന്ന ഒരു DateTimeFormat ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാം, തുടർന്ന് അതിൻ്റെ ഫോർമാറ്റ് രീതിയിലേക്ക് ടെമ്പറൽ ഒബ്ജക്റ്റുകൾ കൈമാറാം. ഇക്കാരണത്താൽ, മൊമെൻ്റ് പോലെയുള്ള ഇഷ്ടാനുസൃത തീയതി ഫോർമാറ്റുകളെ ഇത് പിന്തുണയ്ക്കുന്നില്ല. നിങ്ങൾക്ക് 'Q1 2026' അല്ലെങ്കിൽ മറ്റ് പ്രത്യേക ഫോർമാറ്റിംഗ് പോലെയുള്ള എന്തെങ്കിലും ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ചില ഇഷ്ടാനുസൃത തീയതി ഫോർമാറ്റിംഗ് കോഡ് ആവശ്യമായി വന്നേക്കാം അല്ലെങ്കിൽ ഒരു മൂന്നാം കക്ഷി ലൈബ്രറിയിലേക്ക് എത്തിച്ചേരാം. const formatter = പുതിയ Intl.DateTimeFormat('en-US', { മാസം: '2-അക്ക', ദിവസം: '2-അക്ക', വർഷം: 'സംഖ്യാ' });
കോൺസ്റ്റ് തീയതി = Temporal.Now.instant(); console.log(formatter.format(date)); // 02/22/2026
മൊമെൻ്റിൻ്റെ ഫോർമാറ്റിംഗ് ടോക്കണുകൾ എഴുതാൻ ലളിതമാണ്, പക്ഷേ അവ പ്രാദേശിക സൗഹൃദമല്ല. ഫോർമാറ്റ് സ്ട്രിംഗുകൾ "ഹാർഡ് കോഡ്" മാസം/ദിവസ ഓർഡർ പോലെയുള്ള കാര്യങ്ങൾ. ഒരു കോൺഫിഗറേഷൻ ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനം, ടെമ്പറൽ ചെയ്യുന്നതുപോലെ, അത് ഏത് ലൊക്കേലിലേക്കും സ്വയമേവ പൊരുത്തപ്പെടുകയും ശരിയായ ഫോർമാറ്റ് ഉപയോഗിക്കുകയും ചെയ്യും എന്നതാണ്. കോൺസ്റ്റ് തീയതി = Temporal.Now.instant();
const formatOptions = { മാസം: 'സംഖ്യാ', ദിവസം: 'സംഖ്യാ', വർഷം: 'സംഖ്യാ' };
console.log(date.toLocaleString('en-US', formatOptions)); // 2/22/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
തീയതി കണക്കുകൂട്ടലുകൾ പല ആപ്ലിക്കേഷനുകളിലും, നിങ്ങൾ ഒരു തീയതിയിൽ ചില കണക്കുകൂട്ടലുകൾ പൂർത്തിയാക്കേണ്ടതുണ്ട്. സമയത്തിൻ്റെ യൂണിറ്റുകൾ (ദിവസങ്ങൾ, മണിക്കൂറുകൾ, സെക്കൻഡുകൾ മുതലായവ) ചേർക്കാനോ കുറയ്ക്കാനോ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് നിലവിലെ തീയതി ഉണ്ടെങ്കിൽ, ഇപ്പോൾ മുതൽ 1 ആഴ്ചയ്ക്കുള്ള തീയതി ഉപയോക്താവിനെ കാണിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. മൊമെൻ്റ് ഒബ്ജക്റ്റുകൾക്ക് ഈ പ്രവർത്തനങ്ങൾ നടത്തുന്ന കൂട്ടിച്ചേർക്കലും കുറയ്ക്കലും പോലുള്ള രീതികളുണ്ട്. ഈ ഫംഗ്ഷനുകൾ ഒരു മൂല്യവും ഒരു യൂണിറ്റും എടുക്കുന്നു, ഉദാഹരണത്തിന്: add(7, 'day'). മൊമെൻ്റും ടെമ്പറലും തമ്മിലുള്ള വളരെ പ്രധാനപ്പെട്ട ഒരു വ്യത്യാസം, ഈ തീയതി കണക്കുകൂട്ടലുകൾ നടത്തുമ്പോൾ, അന്തർലീനമായ ഒബ്ജക്റ്റ് പരിഷ്കരിക്കപ്പെടുകയും അതിൻ്റെ യഥാർത്ഥ മൂല്യം നഷ്ടപ്പെടുകയും ചെയ്യുന്നു എന്നതാണ്. കോൺസ്റ്റ് ഇപ്പോൾ = നിമിഷം();
console.log(ഇപ്പോൾ); // നിമിഷം<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log(NextWeek); // നിമിഷം<2026-03-03T20:08:36-05:00>
// Gotcha - യഥാർത്ഥ ഒബ്ജക്റ്റ് പരിവർത്തനം ചെയ്തു console.log(ഇപ്പോൾ); // നിമിഷം<2026-03-03T20:08:36-05:00>
യഥാർത്ഥ തീയതി നഷ്ടപ്പെടാതിരിക്കാൻ, ഒരു പകർപ്പ് സൃഷ്ടിക്കാൻ നിങ്ങൾക്ക് മൊമെൻ്റ് ഒബ്ജക്റ്റിൽ ക്ലോൺ വിളിക്കാം. const ഇപ്പോൾ= നിമിഷം (); const nextWeek = now.clone().add(7, 'days');
console.log(ഇപ്പോൾ); // നിമിഷം<2026-02-24T20:12:55-05:00>
console.log(NextWeek); // നിമിഷം<2026-03-03T20:12:55-05:00>
മറുവശത്ത്, താൽക്കാലിക വസ്തുക്കൾ മാറ്റമില്ലാത്തവയാണ്. നിങ്ങൾ ഒരു തൽക്ഷണം, പ്ലെയിൻ ഡേറ്റ് തുടങ്ങിയ ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, ആ വസ്തുവിൻ്റെ മൂല്യം ഒരിക്കലും മാറില്ല. താൽക്കാലിക വസ്തുക്കൾക്ക് കൂട്ടിച്ചേർക്കലും കുറയ്ക്കലും രീതികളുണ്ട്. ഏത് ഒബ്ജക്റ്റ് തരങ്ങളിലേക്ക് ഏത് സമയ യൂണിറ്റുകൾ ചേർക്കാം എന്നതിനെ കുറിച്ച് ടെമ്പറൽ അൽപ്പം ശ്രദ്ധാലുവാണ്. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു തൽക്ഷണത്തിലേക്ക് ദിവസങ്ങൾ ചേർക്കാൻ കഴിയില്ല:
const now = Temporal.Now.instant(); const nextWeek = now.add({days: 7 }); // RangeError: താൽക്കാലിക പിശക്: ഏറ്റവും വലിയ യൂണിറ്റ് തീയതി യൂണിറ്റ് ആയിരിക്കരുത്
കാരണം, തൽക്ഷണ ഒബ്ജക്റ്റുകൾ യുടിസിയിൽ ഒരു നിശ്ചിത സമയത്തെ പ്രതിനിധീകരിക്കുന്നു, അവ കലണ്ടർ-അജ്ഞ്ഞേയവാദികളാണ്. ഡേലൈറ്റ് സേവിംഗ് ടൈം പോലുള്ള സമയ മേഖല നിയമങ്ങളെ അടിസ്ഥാനമാക്കി ഒരു ദിവസത്തിൻ്റെ ദൈർഘ്യം മാറാം എന്നതിനാൽ, ഈ കണക്കുകൂട്ടൽ തൽക്ഷണം ലഭ്യമല്ല. എന്നിരുന്നാലും, PlainDateTime പോലുള്ള മറ്റ് തരത്തിലുള്ള ഒബ്ജക്റ്റുകളിൽ നിങ്ങൾക്ക് ഈ പ്രവർത്തനം നടത്താനാകും: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({days: 7 });
// യഥാർത്ഥ PlainDateTime മാറ്റമില്ലാതെ തുടരുന്നു എന്നത് ശ്രദ്ധിക്കുക console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
console.log(nextWeek.toLocaleString()); // 3/3/2026, 8:23:59 PM
രണ്ട് മൊമെൻ്റ് അല്ലെങ്കിൽ ടെമ്പറൽ ഒബ്ജക്റ്റുകൾക്കിടയിൽ എത്ര സമയം ഉണ്ടെന്നും നിങ്ങൾക്ക് കണക്കാക്കാം. മൊമെൻ്റിൻ്റെ ഡിഫ് ഫംഗ്ഷൻ ഉപയോഗിച്ച്, നിങ്ങൾ ഗ്രാനുലാരിറ്റിക്കായി ഒരു യൂണിറ്റ് നൽകേണ്ടതുണ്ട്, അല്ലാത്തപക്ഷം അത് മില്ലിസെക്കൻഡിലെ വ്യത്യാസം നൽകും. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date2.diff(date1)); // 91800000
console.log(date2.diff(date1, 'days')); // 1
ഒരു ടെമ്പറൽ ഒബ്ജക്റ്റ് ഉപയോഗിച്ച് ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് മറ്റൊരു ടെമ്പറൽ ഒബ്ജക്റ്റ് അതിൻ്റെ മുമ്പോ ശേഷമോ രീതികളിലേക്ക് കൈമാറാൻ കഴിയും. ഇത് സമയവ്യത്യാസത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയ ഒരു താൽക്കാലിക. ദൈർഘ്യമുള്ള ഒബ്ജക്റ്റിന് വ്യത്യാസത്തിൻ്റെ ഓരോ ഘടകത്തിനും പ്രോപ്പർട്ടികൾ ഉണ്ട്, കൂടാതെ സമയ വ്യത്യാസത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു ISO 8601 ദൈർഘ്യ സ്ട്രിംഗും സൃഷ്ടിക്കാനാകും.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
//ഏറ്റവും വലിയ യൂണിറ്റ് പ്രതിനിധീകരിക്കാനുള്ള സമയത്തിൻ്റെ ഏറ്റവും വലിയ യൂണിറ്റ് വ്യക്തമാക്കുന്നു // കാലാവധി കണക്കുകൂട്ടലിൽ കോൺസ്റ്റ് വ്യത്യാസം = തീയതി2.മുതൽ (തീയതി1, {ഏറ്റവും വലിയ യൂണിറ്റ്: 'ദിവസം'});
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 ദൈർഘ്യ സ്ട്രിംഗ്: 1 ദിവസം, 1 മണിക്കൂർ, 30 മിനിറ്റ്)
തീയതികളും സമയങ്ങളും താരതമ്യം ചെയ്യുന്നു മൊമെൻ്റും ടെമ്പറലും രണ്ടും തീയതികളും സമയവും താരതമ്യം ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു, മറ്റൊന്നിന് മുമ്പായി വരുന്നത് നിർണ്ണയിക്കുക, എന്നാൽ API-യുമായി വ്യത്യസ്ത സമീപനങ്ങൾ സ്വീകരിക്കുക. മൊമെൻ്റ് രണ്ട് മൊമെൻ്റ് ഒബ്ജക്റ്റുകൾ താരതമ്യം ചെയ്യാൻ isBefore, isAfter, isSame തുടങ്ങിയ രീതികൾ നൽകുന്നു. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); //ശരി
ഒരേ തരത്തിലുള്ള രണ്ട് ഒബ്ജക്റ്റുകൾ തമ്മിലുള്ള താരതമ്യം നടത്താൻ ടെമ്പറൽ ഒരു സ്റ്റാറ്റിക് താരതമ്യ രീതി ഉപയോഗിക്കുന്നു. ആദ്യ തീയതി രണ്ടാമത്തേതിന് മുമ്പായി വന്നാൽ -1, തുല്യമാണെങ്കിൽ 0 അല്ലെങ്കിൽ രണ്ടാമത്തേതിന് ശേഷം ആദ്യ തീയതി വന്നാൽ 1 എന്നിവ നൽകുന്നു. രണ്ട് പ്ലെയിൻ ഡേറ്റ് ഒബ്ജക്റ്റുകൾ എങ്ങനെ താരതമ്യം ചെയ്യാമെന്ന് ഇനിപ്പറയുന്ന ഉദാഹരണം കാണിക്കുന്നു. Temporal.PlainDate.compare-ലേക്കുള്ള രണ്ട് ആർഗ്യുമെൻ്റുകളും PlainDate ഒബ്ജക്റ്റുകളായിരിക്കണം.
const date1 = Temporal.PlainDate.from({വർഷം: 2026, മാസം: 2, ദിവസം: 24}); const date2 = Temporal.PlainDate.from({വർഷം: 2026, മാസം: 3, ദിവസം: 24});
// date1 തീയതി 2-ന് മുമ്പ് വരുന്നു, അതിനാൽ -1 console.log(Temporal.PlainDate.compare(date1, date2));
// വ്യത്യസ്ത തരത്തിലുള്ള രണ്ട് ഒബ്ജക്റ്റുകൾ താരതമ്യം ചെയ്യാൻ ശ്രമിച്ചാൽ പിശക് console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // ടൈപ്പ് പിശക്: താൽക്കാലിക പിശക്: അസാധുവായ പ്ലെയിൻ ഡേറ്റ് ഫീൽഡുകൾ നൽകി.
പ്രത്യേകിച്ചും, ഇത് താൽക്കാലിക വസ്തുക്കളുടെ ഒരു നിരയെ കാലക്രമത്തിൽ അടുക്കുന്നത് എളുപ്പമാക്കുന്നു. // Temporal.PlainDate ഒബ്ജക്റ്റുകളുടെ ഒരു നിര കോൺസ്റ്റ് തീയതികൾ = [ ... ];
// Comparator ഫംഗ്ഷനായി Temporal.PlainDate.compare ഉപയോഗിക്കുക dates.sort(Temporal.PlainDate.compare);
സമയ മേഖല പരിവർത്തനങ്ങൾ കോർ മൊമെൻ്റ് ലൈബ്രറി സമയ മേഖല പരിവർത്തനങ്ങളെ പിന്തുണയ്ക്കുന്നില്ല. നിങ്ങൾക്ക് ഈ പ്രവർത്തനം ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾ മൊമെൻ്റ്-ടൈംസോൺ പാക്കേജും ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. ഈ പാക്കേജ് ട്രീ-ഷെക്കബിൾ അല്ല, അതിനാൽ നിങ്ങളുടെ ബണ്ടിൽ വലുപ്പത്തിൽ ഗണ്യമായി ചേർക്കാൻ കഴിയും. നിങ്ങൾ മൊമെൻ്റ്-ടൈം സോൺ ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ, tz രീതി ഉപയോഗിച്ച് നിങ്ങൾക്ക് മൊമെൻ്റ് ഒബ്ജക്റ്റുകളെ വ്യത്യസ്ത സമയ മേഖലകളിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയും. മറ്റ് മൊമെൻ്റ് ഓപ്പറേഷനുകൾ പോലെ, ഇത് അണ്ടർലയിങ്ങിനെ പരിവർത്തനം ചെയ്യുന്നുവസ്തു. // യുഎസ് കിഴക്കൻ സമയം അനുമാനിക്കുന്നു കോൺസ്റ്റ് ഇപ്പോൾ = നിമിഷം(); console.log(ഇപ്പോൾ); // നിമിഷം<2026-02-28T20:08:20-05:00>
// പസഫിക് സമയത്തിലേക്ക് പരിവർത്തനം ചെയ്യുക. // യഥാർത്ഥ കിഴക്കൻ സമയം നഷ്ടപ്പെട്ടു. now.tz('അമേരിക്ക/ലോസ്_ആഞ്ചലസ്'); console.log(ഇപ്പോൾ); // നിമിഷം<2026-02-28T17:08:20-08:00>
ഒരു Temporal.ZonedDateTime ഒബ്ജക്റ്റ് ഉപയോഗിക്കുമ്പോൾ സമയമേഖലാ പ്രവർത്തനക്ഷമത ടെമ്പറൽ API-യിൽ നിർമ്മിച്ചിരിക്കുന്നു. ഈ ഒബ്ജക്റ്റുകളിൽ ഒരു withTimeZone രീതി ഉൾപ്പെടുന്നു, അത് സമയത്തിൻ്റെ അതേ നിമിഷത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു പുതിയ ZonedDateTime നൽകുന്നു, എന്നാൽ നിർദ്ദിഷ്ട സമയ മേഖലയിൽ. // വീണ്ടും, യുഎസ് ഈസ്റ്റേൺ സമയം അനുമാനിക്കുന്നു const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
// പസഫിക് സമയത്തിലേക്ക് പരിവർത്തനം ചെയ്യുക const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 2/28/2026, 5:12:02 PM PST
// യഥാർത്ഥ വസ്തുവിന് മാറ്റമില്ല console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
ശ്രദ്ധിക്കുക: toLocaleString നൽകുന്ന ഫോർമാറ്റ് ചെയ്ത മൂല്യങ്ങൾ, പേര് സൂചിപ്പിക്കുന്നത് പോലെ, ലോക്കലിനെ ആശ്രയിച്ചിരിക്കുന്നു. സാമ്പിൾ കോഡ് വികസിപ്പിച്ചെടുത്തത് en-US ലൊക്കേലിലാണ്, അതിനാൽ ഫോർമാറ്റ് ഇതുപോലെയാണ്: 2/28/2026, 5:12:02 PM PST. മറ്റൊരു പ്രദേശത്ത്, ഇത് വ്യത്യസ്തമായിരിക്കാം. ഉദാഹരണത്തിന്, en-GB ലൊക്കേലിൽ, നിങ്ങൾക്ക് 28/2/2026, 17:12:02 GMT-8 പോലെയുള്ള എന്തെങ്കിലും ലഭിക്കും. ഒരു യഥാർത്ഥ ലോക പുനർനിർമ്മാണം സമയ മേഖലകളിലുടനീളം ഇവൻ്റുകൾ ഷെഡ്യൂൾ ചെയ്യുന്നതിനായി ഞങ്ങൾ ഒരു ആപ്പ് നിർമ്മിക്കുകയാണെന്ന് കരുതുക. ഈ ആപ്പിൻ്റെ ഭാഗമാണ് getEventTimes, ഇത് ഇവൻ്റിൻ്റെ സമയവും തീയതിയും, ഒരു പ്രാദേശിക സമയ മേഖല, ഒരു ടാർഗെറ്റ് സമയ മേഖല എന്നിവയെ പ്രതിനിധീകരിക്കുന്ന ഒരു ISO 8601 സ്ട്രിംഗ് എടുക്കുന്നു. രണ്ട് സമയ മേഖലകളിലും ഇവൻ്റിനായി ഫംഗ്ഷൻ ഫോർമാറ്റ് ചെയ്ത സമയവും തീയതിയും സൃഷ്ടിക്കുന്നു. പ്രവർത്തനത്തിന് സാധുവായ സമയം/തീയതി സ്ട്രിംഗ് അല്ലാത്ത ഒരു ഇൻപുട്ട് സ്ട്രിംഗ് നൽകിയാൽ, അത് ഒരു പിശക് സൃഷ്ടിക്കും. മൊമെൻ്റ് (മൊമെൻ്റ്-ടൈംസോൺ പാക്കേജിൻ്റെ ഉപയോഗവും ആവശ്യമാണ്) ഉപയോഗിച്ച് യഥാർത്ഥ നടപ്പിലാക്കൽ ഇതാ.
മൊമെൻ്റ്-ടൈംസോണിൽ നിന്ന് നിമിഷം ഇറക്കുമതി ചെയ്യുക;
ഫംഗ്ഷൻ getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. ഉപയോക്താവിൻ്റെ സമയ മേഖലയിൽ പ്രാരംഭ നിമിഷം സൃഷ്ടിക്കുക const eventTime = moment.tz( inputString, moment.ISO_8601, // ഒരു ISO 8601 സ്ട്രിംഗ് പ്രതീക്ഷിക്കുക ശരി, // കർശനമായ പാഴ്സിംഗ് userTimeZone );
// inputString ഒരു സാധുവായ തീയതിയെ പ്രതിനിധീകരിക്കുന്നില്ലെങ്കിൽ ഒരു പിശക് എറിയുക എങ്കിൽ (!eventTime.isValid()) { പുതിയ പിശക് ('അസാധുവായ തീയതി/സമയ ഇൻപുട്ട്'); }
// 2. ലക്ഷ്യ സമയം കണക്കാക്കുക // ക്രിട്ടിക്കൽ: നമ്മൾ ക്ലോൺ ചെയ്യണം, അല്ലെങ്കിൽ 'ഇവൻ്റ് ടൈം' എന്നെന്നേക്കുമായി മാറുന്നു! const targetTime = eventTime.clone().tz(targetTimeZone);
മടങ്ങുക { പ്രാദേശികം: eventTime.format(timeFormat), ലക്ഷ്യം: targetTime.format(timeFormat), }; }
കോൺസ്റ്റ് ഷെഡ്യൂൾ = getEventTimes( '2026-03-05T15:00-05:00', 'അമേരിക്ക/ന്യൂയോർക്ക്', 'യൂറോപ്പ്/ലണ്ടൻ', );
console.log(schedule.local); // മാർച്ച് 5, 2026, 3:00:00 pm EST
console.log(schedule.target); // മാർച്ച് 5, 2026, 8:00:00 pm GMT
ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ ISO 8601-ൻ്റെ പ്രതീക്ഷിക്കുന്ന തീയതി ഫോർമാറ്റ് ഉപയോഗിക്കുന്നു, അത് മൊമെൻ്റിൽ സഹായകമായി നിർമ്മിച്ചിരിക്കുന്നു. ഞങ്ങൾ കർശനമായ പാഴ്സിംഗും ഉപയോഗിക്കുന്നു, അതിനർത്ഥം ഫോർമാറ്റുമായി പൊരുത്തപ്പെടാത്ത ഒരു തീയതി സ്ട്രിംഗ് ഉപയോഗിച്ച് മൊമെൻ്റ് ഊഹിക്കാൻ ശ്രമിക്കില്ല എന്നാണ്. ഒരു നോൺ-ഐഎസ്ഒ തീയതി സ്ട്രിംഗ് കടന്നുപോകുകയാണെങ്കിൽ, അത് ഒരു അസാധുവായ തീയതി ഒബ്ജക്റ്റിന് കാരണമാകും, ഞങ്ങൾ ഒരു പിശക് എറിയുന്നു. ടെമ്പറൽ നടപ്പിലാക്കൽ സമാനമായി കാണപ്പെടുന്നു, പക്ഷേ ചില പ്രധാന വ്യത്യാസങ്ങളുണ്ട്.
ഫംഗ്ഷൻ getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. ഇൻപുട്ട് നേരിട്ട് ഒരു തൽക്ഷണത്തിലേക്ക് പാഴ്സ് ചെയ്യുക, തുടർന്ന് സൃഷ്ടിക്കുക // ഉപയോക്താവിൻ്റെ സോണിലെ ഒരു ZonedDateTime. കോൺസ്റ്റ് തൽക്ഷണം = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. ടാർഗെറ്റ് സോണിലേക്ക് പരിവർത്തനം ചെയ്യുക // ഇത് ഒരു പുതിയ ഒബ്ജക്റ്റ് സ്വയമേവ നൽകുന്നു; 'eventTime' സുരക്ഷിതമാണ്. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Intl (ബിൽറ്റ്-ഇൻ) ഉപയോഗിച്ച് ഫോർമാറ്റ് ചെയ്യുക കോൺസ്റ്റ് ഓപ്ഷനുകൾ = { വർഷം: 'സംഖ്യാ', മാസം: 'ഹ്രസ്വ', ദിവസം: 'സംഖ്യാ', മണിക്കൂർ: 'സംഖ്യാ', മിനിറ്റ്: '2-അക്ക', രണ്ടാമത്തേത്: '2-അക്ക', timeZoneName: 'ഹ്രസ്വ' };
മടങ്ങുക { പ്രാദേശികം: eventTime.toLocaleString(navigator.language, ഓപ്ഷനുകൾ), ലക്ഷ്യം: targetTime.toLocaleString(navigator.language, ഓപ്ഷനുകൾ) }; }
കോൺസ്റ്റ് ഷെഡ്യൂൾ = getEventTimes( '2026-03-05T15:00-05:00', 'അമേരിക്ക/ന്യൂയോർക്ക്', 'യൂറോപ്പ്/ലണ്ടൻ', );
console.log(schedule.local); // മാർച്ച് 5, 2026, 3:00:00 PM EST
console.log(schedule.target); // മാർച്ച് 5, 2026, 8:00:00 PM GMT
മൊമെൻ്റ് ഉപയോഗിച്ച്, ഫലമായുണ്ടാകുന്ന തീയതി സ്ട്രിംഗുകൾക്കായി ഞങ്ങൾ ഒരു ഫോർമാറ്റ് സ്ട്രിംഗ് വ്യക്തമായി വ്യക്തമാക്കേണ്ടതുണ്ട്. ഉപയോക്താവിൻ്റെ ലൊക്കേഷനോ പ്രദേശമോ പരിഗണിക്കാതെ തന്നെ, ഇവൻ്റ് സമയം എല്ലായ്പ്പോഴും 2026 മാർച്ച് 5, 3:00:00 ആയി ഫോർമാറ്റ് ചെയ്യപ്പെടും.pm EST. കൂടാതെ, ഞങ്ങൾ ഒരു അപവാദം വ്യക്തമായി ഇടേണ്ടതില്ല. Temporal.Instant.from എന്നതിലേക്ക് ഒരു അസാധുവായ സ്ട്രിംഗ് കൈമാറുകയാണെങ്കിൽ, Temporal നമുക്കുവേണ്ടി ഒഴിവാക്കും. ശ്രദ്ധിക്കേണ്ട ഒരു കാര്യം, കർശനമായ പാഴ്സിംഗ് ഉപയോഗിച്ച് പോലും, മൊമെൻ്റ് പതിപ്പ് കൂടുതൽ മൃദുവാണ്. ടെമ്പറലിന് സ്ട്രിംഗിൻ്റെ അറ്റത്തുള്ള സമയ മേഖല ഓഫ്സെറ്റ് ആവശ്യമാണ്. ഞങ്ങൾ navigator.language ഉപയോഗിക്കുന്നതിനാൽ, ഒരു Node.js പരിതസ്ഥിതിയിൽ നാവിഗേറ്റർ നിർവചിച്ചിട്ടില്ലാത്തതിനാൽ, ഈ കോഡ് ഒരു ബ്രൗസർ പരിതസ്ഥിതിയിൽ മാത്രമേ പ്രവർത്തിക്കൂ എന്നതും നിങ്ങൾ ശ്രദ്ധിക്കേണ്ടതാണ്. താൽക്കാലിക നടപ്പാക്കൽ ബ്രൗസറിൻ്റെ നിലവിലെ ലൊക്കേൽ (navigator.language) ഉപയോഗിക്കുന്നു, അതിനാൽ ഉപയോക്താവിന് അവരുടെ പ്രാദേശിക സമയ ഫോർമാറ്റിൽ ഇവൻ്റ് സമയങ്ങൾ സ്വയമേവ ഫോർമാറ്റ് ചെയ്യും. en-US ലൊക്കേലിൽ, ഇത് 2026 മാർച്ച് 5, 3:00:00 pm EST ആണ്. എന്നിരുന്നാലും, ഉപയോക്താവ് ലണ്ടനിലാണെങ്കിൽ, ഉദാഹരണത്തിന്, ഇവൻ്റ് സമയം 5 മാർച്ച് 2026, 15:00:00 GMT-5 ആയി ഫോർമാറ്റ് ചെയ്യപ്പെടും. സംഗ്രഹം
ആക്ഷൻ Moment.js താൽക്കാലിക നിലവിലെ സമയം നിമിഷം() Temporal.Now.zonedDateTimeISO() പാഴ്സിംഗ് ഐഎസ്ഒ നിമിഷം(str) Temporal.Instant.from(str) സമയം ചേർക്കുക .ചേർക്കുക(7, 'ദിവസം') (മ്യൂട്ടേറ്റ്സ്) .ചേർക്കുക({ദിവസം: 7 }) (പുതിയ ഒബ്ജക്റ്റ്) വ്യത്യാസം .diff(മറ്റുള്ളവ, 'മണിക്കൂറുകൾ') .മുതൽ(മറ്റ്).മണിക്കൂർ സമയ മേഖല .tz('മേഖല/പേര്') .withTimeZone('സോൺ/പേര്')
ഒറ്റനോട്ടത്തിൽ, വ്യത്യാസം അൽപ്പം വ്യത്യസ്തമായിരിക്കാം (താൽക്കാലികവും, ചിലപ്പോൾ കൂടുതൽ വാചാലവും കൂടുതൽ കർശനവുമാണ്) വാക്യഘടന, എന്നാൽ Moment.js-ൽ ടെമ്പറൽ ഉപയോഗിക്കുന്നതിന് നിരവധി പ്രധാന ഗുണങ്ങളുണ്ട്:
കൂടുതൽ വ്യക്തമായിരിക്കുക എന്നതിനർത്ഥം കുറച്ച് ആശ്ചര്യങ്ങളും ഉദ്ദേശിക്കാത്ത ബഗുകളും. നിമിഷം കൂടുതൽ സൗമ്യമായി തോന്നാം, പക്ഷേ അതിൽ "ഊഹങ്ങൾ" ഉൾപ്പെടുന്നു, അത് ചിലപ്പോൾ തെറ്റായ തീയതികൾക്ക് കാരണമായേക്കാം. നിങ്ങൾ ടെമ്പറലിന് അസാധുവായ എന്തെങ്കിലും നൽകിയാൽ, അത് ഒരു പിശക് സൃഷ്ടിക്കുന്നു. കോഡ് പ്രവർത്തിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു സാധുവായ തീയതി ലഭിച്ചിട്ടുണ്ടെന്ന് നിങ്ങൾക്കറിയാം. മൊമെൻ്റിന് ആപ്ലിക്കേഷൻ്റെ ബണ്ടിലിലേക്ക് കാര്യമായ വലുപ്പം ചേർക്കാൻ കഴിയും, പ്രത്യേകിച്ചും നിങ്ങൾ മൊമെൻ്റ്-ടൈംസോൺ പാക്കേജ് ഉപയോഗിക്കുകയാണെങ്കിൽ. ടെമ്പറൽ ഒന്നും ചേർക്കുന്നില്ല (നിങ്ങളുടെ ടാർഗെറ്റ് ബ്രൗസറുകളിൽ അത് അയച്ചുകഴിഞ്ഞാൽ). തീയതി പരിവർത്തനങ്ങളും പ്രവർത്തനങ്ങളും നടത്തുമ്പോൾ നിങ്ങൾക്ക് ഒരിക്കലും ഡാറ്റ നഷ്ടപ്പെടുകയോ പുനരാലേഖനം ചെയ്യുകയോ ചെയ്യില്ലെന്ന ആത്മവിശ്വാസം മാറ്റമില്ലാത്തത് നൽകുന്നു. നിങ്ങളുടെ ആവശ്യകതകളെ ആശ്രയിച്ച് സമയത്തിൻ്റെ വ്യത്യസ്ത പ്രാതിനിധ്യങ്ങൾ (തൽക്ഷണം, പ്ലെയിൻഡേറ്റ് ടൈം, സോൺഡേറ്റ് ടൈം), ഇവിടെ മൊമെൻ്റ് എല്ലായ്പ്പോഴും ഒരു യുടിസി ടൈംസ്റ്റാമ്പിന് ചുറ്റും ഒരു റാപ്പറാണ്. തീയതി ഫോർമാറ്റിംഗിനായി Temporal Intl API-കൾ ഉപയോഗിക്കുന്നു, അതായത് ടോക്കണുകൾ വ്യക്തമായി വ്യക്തമാക്കാതെ തന്നെ നിങ്ങൾക്ക് ലോക്കൽ-അവേർ ഫോർമാറ്റിംഗ് നടത്താം.
പോളിഫില്ലിനെക്കുറിച്ചുള്ള കുറിപ്പുകൾ നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, @js-temporal/polyfill എന്ന പേരിൽ ഒരു npm പാക്കേജായി വിതരണം ചെയ്യുന്ന ഒരു താൽക്കാലിക പോളിഫിൽ ലഭ്യമാണ്. നിങ്ങൾക്ക് ഇന്ന് ടെമ്പറൽ ഉപയോഗിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, ഇതുവരെ API ഷിപ്പ് ചെയ്തിട്ടില്ലാത്ത Safari പോലുള്ള ബ്രൗസറുകളെ പിന്തുണയ്ക്കാൻ നിങ്ങൾക്ക് ഈ പോളിഫിൽ ആവശ്യമാണ്. ഇതിലെ മോശം വാർത്ത, ഇത് നിങ്ങളുടെ ബണ്ടിൽ വലുപ്പത്തിൽ ചേർക്കും എന്നതാണ്. ഇത് ഇപ്പോഴും നിമിഷത്തെക്കാളും മൊമെൻ്റ്-ടൈംസോണിനെക്കാളും വളരെ കുറച്ച് ചേർക്കുന്നു എന്നതാണ് നല്ല വാർത്ത. npm പാക്കേജ് വലുപ്പങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ അവതരിപ്പിക്കുന്ന ഒരു വെബ്സൈറ്റായ Bundlephobia.com റിപ്പോർട്ട് ചെയ്ത ബണ്ടിൽ വലുപ്പങ്ങളുടെ ഒരു താരതമ്യം ഇതാ (ബണ്ടിൽഫോബിയ വിശകലനം കാണാൻ ഓരോ പാക്കേജിൻ്റെ പേരിലും ക്ലിക്കുചെയ്യുക):
പാക്കേജ് ചെറുതാക്കിയത് മിനിഫൈഡ് & ജിസിപ്പ് ചെയ്തു @js-ടെമ്പറൽ/പോളിഫിൽ 154.1 കെ.ബി 44.1 കെ.ബി നിമിഷം 294.4 കെ.ബി 75.4 കെ.ബി നിമിഷ-സമയമേഖല 1 എം.ബി 114.2 കെ.ബി
പോളിഫില്ലിന് ചരിത്രപരമായി മെമ്മറി ഉപയോഗവുമായി ബന്ധപ്പെട്ട് ചില പ്രകടന പ്രശ്നങ്ങളുണ്ട്, എഴുതുമ്പോൾ, അത് ആൽഫ അവസ്ഥയിലാണെന്ന് കണക്കാക്കുന്നു. ഇക്കാരണത്താൽ, അത് കൂടുതൽ പക്വത പ്രാപിക്കുന്നത് വരെ ഉൽപ്പാദനത്തിൽ ഉപയോഗിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കില്ല. മറ്റൊരു നല്ല വാർത്ത, പോളിഫിൽ കൂടുതൽ കാലം വേണ്ടിവരില്ല എന്നതാണ് (നിങ്ങൾ പഴയ ബ്രൗസറുകൾ പിന്തുണയ്ക്കേണ്ടതില്ലെങ്കിൽ, തീർച്ചയായും). എഴുതുമ്പോൾ, Chrome, Edge, Firefox എന്നിവയിൽ ടെമ്പറൽ ഷിപ്പ് ചെയ്തിട്ടുണ്ട്. ഏറ്റവും പുതിയ ടെക്നോളജി പ്രിവ്യൂവിൽ റൺടൈം ഫ്ലാഗ് സഹിതം ലഭ്യമാണെന്ന് തോന്നുമെങ്കിലും, സഫാരിയിൽ ഇത് ഇതുവരെ തയ്യാറായിട്ടില്ല.
