JavaScript හි ලියා ඇති ඕනෑම ආකාරයක යෙදුමක් යම් ධාරිතාවකින් වේලාවන් හෝ දිනයන් සමඟ ක්රියා කරයි. මුලදී, මෙය ගොඩනඟන ලද Date API වෙත සීමා විය. මෙම API මූලික ක්රියාකාරීත්වය ඇතුළත් වේ, නමුත් එයට කළ හැකි දේ තරමක් සීමිතය. Moment.js වැනි තුන්වන පාර්ශ්ව පුස්තකාල, සහ පසුව Intl API සහ නව Temporal API වැනි ගොඩනඟන ලද API, වේලාවන් සහ දිනයන් සමඟ වැඩ කිරීමට වඩා විශාල නම්යශීලී බවක් එක් කරයි. Moment.js හි නැගීම සහ වැටීම Moment.js යනු වේලාවන් සහ දිනයන් සමඟ වැඩ කිරීම සඳහා බලවත් උපයෝගිතා සහිත JavaScript පුස්තකාලයකි. එහි කාල කලාප හැසිරවීම වැනි මූලික Date API වෙතින් නැතිවූ විශේෂාංග ඇතුළත් වන අතර බොහෝ පොදු මෙහෙයුම් සරල කරයි. Moment දින සහ වේලාවන් හැඩතල ගැන්වීම සඳහා කාර්යයන් ද ඇතුළත් වේ. එය විවිධ යෙදුම්වල බහුලව භාවිතා වන පුස්තකාලයක් බවට පත් විය. කෙසේ වෙතත්, Moment ද එහි ගැටළු වල කොටසක් විය. එය විශාල පුස්තකාලයක් වන අතර, යෙදුමක මිටි ප්රමාණයට සැලකිය යුතු ලෙස එකතු කළ හැක. පුස්තකාලය ගස් සෙලවීමට සහය නොදක්වන නිසා (පුස්තකාලවල භාවිතයට නොගත් කොටස් ඉවත් කළ හැකි නවීන බණ්ඩලර්වල විශේෂාංගයක්), ඔබ එහි කාර්යයන් එකක් හෝ දෙකක් පමණක් භාවිතා කළත් මුළු මොහොත පුස්තකාලයම ඇතුළත් වේ. Moment සමඟ ඇති තවත් ගැටළුවක් වන්නේ එය නිර්මාණය කරන වස්තූන් විකෘති වීමයි. Moment object එකක් මත ඇතැම් ශ්රිත ඇමතීමෙන් අතුරු ආබාධ ඇති වන අතර එම වස්තුවේ අගය විකෘති කරයි. මෙය අනපේක්ෂිත හැසිරීම් හෝ දෝෂ වලට හේතු විය හැක. 2020 දී, Moment හි නඩත්තු කරන්නන් පුස්තකාලය නඩත්තු මාදිලියට දැමීමට තීරණය කළහ. නව විශේෂාංග සංවර්ධනයක් සිදු නොවන අතර, නව ව්යාපෘති සඳහා එය භාවිතා කිරීමට එරෙහිව නඩත්තු කරන්නන් නිර්දේශ කරයි. date-fns වැනි වෙනත් ජාවාස්ක්රිප්ට් දින පුස්තකාල ඇත, නමුත් නගරයේ නව ක්රීඩකයෙක් ඇත, API සෘජුවම JavaScript: Temporal වෙත ගොඩනගා ඇත. එය මුල් Date API හි සිදුරු පුරවන නව ප්රමිතියක් මෙන්ම Moment සහ අනෙකුත් පුස්තකාලවල ඇති සමහර සීමාවන් විසඳයි. තාවකාලික යනු කුමක්ද? Temporal යනු නවීන ජාවාස්ක්රිප්ට් නිර්වචනය කරන ECMAScript ප්රමිතියට එකතු කරන නව වේලාව සහ දිනයකි. 20266 මාර්තු වන විට, එය TC39 ක්රියාවලියේ 4 වන අදියර වෙත ළඟා වී ඇත (ජාවාස්ක්රිප්ට් භාෂාවට යෝජනා සහ එකතු කිරීම් අධීක්ෂණය කරන කමිටුව), සහ ECMAScript පිරිවිතරයේ ඊළඟ අනුවාදයට ඇතුළත් වනු ඇත. එය දැනටමත් බ්රව්සර් කිහිපයක ක්රියාත්මක කර ඇත: Chrome 144+ සහ Firefox 139+, Safari ළඟදීම අනුගමනය කිරීමට බලාපොරොත්තු වේ. සහාය නොදක්වන බ්රවුසර සහ Node.js සඳහාද බහු පිරවුමක් තිබේ. Temporal API සාමාන්යයෙන් කාලයෙහි අවස්ථා නියෝජනය කරන වස්තූන් නිර්මාණය කරයි. මේවා දී ඇති කාල කලාපයක පූර්ණ කාලීන සහ දින මුද්දර විය හැකිය, නැතහොත් ඒවා කිසිදු කාල කලාපයක් හෝ දින තොරතුරක් නොමැතිව “බිත්ති ඔරලෝසු” වේලාවේ සාමාන්ය අවස්ථාවක් විය හැකිය. Temporal හි ප්රධාන ලක්ෂණ සමහරක් ඇතුළත් වේ:
දිනයන් සහිත හෝ රහිත වේලාවන්. තාවකාලික වස්තුවකට නිශ්චිත දිනයක නිශ්චිත වේලාවක් හෝ දින තොරතුරක් නොමැති වේලාවක් නියෝජනය කළ හැක. නිශ්චිත දිනයක්, වේලාවක් නොමැතිව, ද නිරූපණය කළ හැකිය. කාල කලාප සහාය.කාලික වස්තු සම්පූර්ණයෙන්ම වේලා කලාපය දැනුවත් වන අතර විවිධ කාල කලාප හරහා පරිවර්තනය කළ හැක. Moment වේලා කලාප සඳහාද සහය දක්වයි, නමුත් එයට අමතර මොහොත-කාල කලාප පුස්තකාලය අවශ්ය වේ. වෙනස් නොවන බව. තාවකාලික වස්තුවක් නිර්මාණය කළ පසු එය වෙනස් කළ නොහැක. කාල ගණිතමය හෝ වේලා කලාප පරිවර්තනයන් යටින් පවතින වස්තුව වෙනස් නොකරයි. ඒ වෙනුවට, ඔවුන් නව තාවකාලික වස්තුවක් ජනනය කරයි. 1-පාදක සුචිගත කිරීම. Date API (මෙන්ම Moment සමඟ) දෝෂ වල පොදු මූලාශ්රයක් වන්නේ මාස ශුන්ය සුචිගත කර තිබීමයි. මෙයින් අදහස් කරන්නේ සැබෑ ජීවිතයේ අප සියල්ලන්ම තේරුම් ගන්නා පරිදි ජනවාරි 1 මාසයට වඩා 0 මාසය බවයි. 1-පාදක සුචිගත කිරීම භාවිතයෙන් මෙය තාවකාලික නිවැරදි කරයි - ජනවාරි මාසය 1 වේ. එය බ්රවුසරය තුළ ගොඩනගා ඇත. Temporal යනු බ්රවුසරයේම API එකක් වන බැවින්, එය ඔබගේ යෙදුමේ මිටි ප්රමාණයට කිසිවක් එක් නොකරයි.
Date API පහව නොයන බව ද සටහන් කිරීම වැදගත්ය. Tempor විසින් මෙම API අභිබවා යන අතර, එය ඉවත් කිරීම හෝ අත්හැරීම සිදු නොවේ. බ්රව්සර් හදිසියේම Date API ඉවත් කළහොත් බොහෝ යෙදුම් කැඩී යයි. කෙසේ වෙතත්, Moment දැන් නඩත්තු මාදිලියේ උරුම ව්යාපෘතියක් ලෙස සලකනු ලබන බව ද මතක තබා ගන්න. ලිපියේ ඉතිරි කොටසෙහි, අපි Moment-පාදක කේතය නව තාවකාලික API වෙත සංක්රමණය කිරීම සඳහා සමහර "වට්ටෝරු" දෙස බලමු. අපි නැවත සකස් කිරීම ආරම්භ කරමු! දිනය සහ වේලාව වස්තු නිර්මාණය කිරීම අපට දිනයන් සහ වේලාවන් හැසිරවීමට පෙර, ඒවා නියෝජනය කරන වස්තූන් නිර්මාණය කළ යුතුය. වත්මන් දිනය සහ වේලාව නියෝජනය කරන Moment වස්තුවක් සෑදීමට, moment ශ්රිතය භාවිතා කරන්න. const now = moment(); console.log(දැන්); // මොහොත<2026-02-18T21:26:29-05:00>
මෙම වස්තුව දැන් අවශ්ය පරිදි හැඩතල ගැන්වීමට හෝ හැසිරවීමට හැකිය.
// UTC බවට පරිවර්තනය කරන්න //අනතුරු ඇඟවීම: මෙය මොහොත වස්තුව විකෘති කර UTC මාදිලියේ තබයි! 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 පෙ.ව
Moment ගැන මතක තබා ගත යුතු ප්රධාන දෙය නම් Moment වස්තුවක සෑම විටම වේලාව සහ දිනය පිළිබඳ තොරතුරු ඇතුළත් වීමයි. ඔබට කාල තොරතුරු සමඟ පමණක් වැඩ කිරීමට අවශ්ය නම්, මෙය සාමාන්යයෙන් හොඳයි, නමුත් එය දිවා ආලෝකය ඉතිරි කිරීමේ කාලය හෝ අධික වර්ෂ වැනි අවස්ථාවන්හිදී අනපේක්ෂිත හැසිරීමක් ඇති කළ හැකිය, එහිදී දිනය කාල ගණනය කිරීම් කෙරෙහි බලපෑමක් ඇති කළ හැකිය. තාවකාලික වඩාත් නම්යශීලී වේ. Temporal.Instant object එකක් නිර්මාණය කිරීමෙන් ඔබට වත්මන් දිනය සහ වේලාව නියෝජනය කරන වස්තුවක් සෑදිය හැක. මෙය "යුගය" (1970 ජනවාරි 1 දින මධ්යම රාත්රියේ යූටීසී) සිට කාලය විසින් අර්ථ දක්වා ඇති කාල ලක්ෂ්යයක් නියෝජනය කරයි. Temporal හට නැනෝ තත්පර මට්ටමේ නිරවද්යතාවයකින් මෙම ක්ෂණිකව සඳහන් කළ හැක. const now = Temporal.Now.instant();
// යුගයේ සිට අමු නැනෝ තත්පර බලන්න console.log(now.epochNanoseconds); // 1771466342612000000n
// UTC සඳහා ආකෘතිය 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
Temporal.Instant objects නිශ්චිත කාලයක් සහ දිනයක් සඳහා ස්ථිතික ක්රමය භාවිතයෙන්ද නිර්මාණය කළ හැක.
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({ timeZone: 'America/New_York', වසර: 2026, මාසය: 3, දිනය: 1, පැය: 12, මිනිත්තුව: 0, දෙවන: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
විග්රහ කිරීම අපි දිනය සහ වේලාව පිළිබඳ තොරතුරු ක්රමලේඛනගත නිර්මාණය ආවරණය කර ඇත. දැන් අපි බලමු විග්රහ කිරීම. විග්රහ කිරීම යනු බිල්ට්-ඉන් Temporal API වලට වඩා Moment නම්යශීලී වන එක් ප්රදේශයකි. ඔබට දින තන්තුවක් මොහොත ශ්රිතයට යැවීමෙන් විග්රහ කළ හැක. තනි තර්කයක් සමඟ, Moment 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>
පැරණි අනුවාද වල, Moment ඕනෑම අත්තනෝමතික ලෙස හැඩතල ගැන්වූ දින තන්තුවක් විග්රහ කිරීමට හොඳම අනුමාන කරයි. මෙය අනපේක්ෂිත ප්රතිඵල ඇති විය හැක. උදාහරණයක් ලෙස, 02-03-2026 පෙබරවාරි 2 හෝ මාර්තු 3 ද? මෙම හේතුව නිසා, Moment හි නවතම අනුවාද ISO ආකෘතිගත දින තන්තුවකින් තොරව එය කැඳවනු ලැබුවහොත් (අවශ්ය ආකෘතිය සමඟ දෙවන තර්කය ද ලබා දී නොමැති නම්) කැපී පෙනෙන අවප්රමාණය අනතුරු ඇඟවීමක් පෙන්වයි. Temporal විසින් විග්රහ කරනු ලබන්නේ නිශ්චිතව ෆෝමැට් කරන ලද දින තන්තුවක් පමණි. තන්තුව ISO 8601 ආකෘතියට හෝ එහි දිගුව වන RFC 9557 සමඟ අනුකූල විය යුතුය. අනුකූල නොවන දින තන්තුවක් වෙතින් ක්රමයකට ගියහොත්, Temporal විසින් 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');
හිතවත් ඉඟිය: ISO නොවන තන්තු හැසිරවීම Temporal විශ්වසනීයත්වයට ප්රමුඛත්වය දෙන නිසා, එය 02-01-2026 වැනි තන්තුවක ආකෘතිය අනුමාන කිරීමට උත්සාහ නොකරයි. ඔබගේ දත්ත මූලාශ්රය එවැනි තන්තු භාවිතා කරන්නේ නම්, එය Temporal සමඟ භාවිතා කිරීමට උත්සාහ කිරීමට පෙර 2026-02-01 වැනි ISO තන්තුවකට අගයන් ප්රතිසංවිධානය කිරීමට ඔබට යම් තන්තු හැසිරවීමක් කිරීමට අවශ්ය වනු ඇත.
හැඩතල ගැන්වීම ඔබට මොහොතක් හෝ තාවකාලික වස්තුවක් ලැබුණු පසු, ඔබට එය යම් අවස්ථාවක දී ආකෘතිගත තන්තුවකට පරිවර්තනය කිරීමට අවශ්ය වනු ඇත. මෙය Moment ටිකක් වැඩි වන අවස්ථාවකි. ඔබට අවශ්ය දින ආකෘතිය විස්තර කරන ටෝකන මාලාවක් සමඟ වස්තුවේ ආකෘති ක්රමය අමතන්න. const දිනය = මොහොත ();
console.log(date.format('MM/DD/YYYY')); // 02/22/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 2026 පෙබරවාරි 22, ප.ව. 8:18:30
අනෙක් අතට, Temporal ඔබට තව ටිකක් වාචික විය යුතුය. Instant වැනි තාවකාලික වස්තූන් සතුව toLocaleString ක්රමයක් ඇති අතර එය වස්තුවක ගුණාංග ලෙස දක්වා ඇති විවිධ හැඩතල ගැන්වීම් විකල්ප පිළිගනී.
const දිනය = Temporal.Now.instant();
// තර්ක නොමැතිව, අපි වත්මන් පෙදෙසිය සඳහා පෙරනිමි ආකෘතිය ලබා ගනිමු console.log(date.toLocaleString()); // 2/22/2026, 8:23:36 ප.ව (එන්-එක්සත් ජනපදයේ ප්රදේශයක් උපකල්පනය කරමින්)
// අභිරුචි ආකෘති තන්තුවක් උත්පාදනය කිරීමට හැඩතල ගැන්වීමේ විකල්ප සමත් කරන්න console.log(date.toLocaleString('en-US', {) මාසය: 'දිගු', දවස: 'සංඛ්යා', වර්ෂය: 'සංඛ්යා', පැය: 'ඉලක්කම්-2', මිනිත්තුව: 'ඉලක්කම්-2' })); // පෙබරවාරි 22, 2026 8:23 ප.ව
// ඔබට අවශ්ය ක්ෂේත්ර පමණක් ආකෘති තන්තුවෙන් පසු කරන්න console.log(date.toLocaleString('en-US', {) මාසය: 'කෙටි', දවස: 'සංඛ්යා' })); //පෙබරවාරි 22
තාවකාලික දින හැඩතල ගැන්වීම ඇත්ත වශයෙන්ම Intl.DateTimeFormat API (දැනටමත් නවීන බ්රව්සර්වල පහසුවෙන් ලබා ගත හැක) තොප්පිය යටතේ භාවිතා කරයි. එයින් අදහස් වන්නේ ඔබට ඔබේ අභිරුචි හැඩතල ගැන්වීමේ විකල්ප සමඟ නැවත භාවිත කළ හැකි DateTimeFormat වස්තුවක් සෑදිය හැකි අතර, පසුව එහි ආකෘති ක්රමයට තාවකාලික වස්තු ලබා දිය හැක. මේ නිසා, එය Moment වැනි අභිරුචි දින ආකෘති සඳහා සහය නොදක්වයි. ඔබට 'Q1 2026' හෝ වෙනත් විශේෂිත හැඩතල ගැන්වීම් වැනි දෙයක් අවශ්ය නම්, ඔබට යම් අභිරුචි දින හැඩතල ගැන්වීමේ කේතයක් හෝ තෙවන පාර්ශවීය පුස්තකාලයක් සඳහා ළඟා වීමට අවශ්ය විය හැක. const formatter = නව Intl.DateTimeFormat('en-US', { මාසය: 'ඉලක්කම්-2', දවස: 'ඉලක්කම්-2', වර්ෂය: 'සංඛ්යා' });
const දිනය = Temporal.Now.instant(); console.log(formatter.format(date)); // 02/22/2026
Moment හි හැඩතල ගැන්වීමේ ටෝකන ලිවීමට වඩා සරල ය, නමුත් ඒවා දේශීය-හිතකාමී නොවේ. ආකෘතිය තන්තු "දෘඪ කේතය" මාසය/දින ඇණවුම වැනි දේවල්. Temporal මෙන් වින්යාස වස්තුවක් භාවිතා කිරීමේ වාසිය නම්, එය ඕනෑම ස්ථානයකට ස්වයංක්රීයව අනුවර්තනය වී නිවැරදි ආකෘතිය භාවිතා කිරීමයි. const දිනය = 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ක දිනය පරිශීලකයාට පෙන්වීමට අවශ්ය විය හැක. Moment objects සතුව මෙම මෙහෙයුම් සිදු කරන එකතු කිරීම සහ අඩු කිරීම වැනි ක්රම තිබේ. මෙම කාර්යයන් අගයක් සහ ඒකකයක් ගනී, උදාහරණයක් ලෙස: add(7, 'day'). කෙසේ වෙතත්, Moment සහ Temporal අතර ඉතා වැදගත් වෙනසක් නම්, මෙම දින ගණනය කිරීම් සිදු කරන විට, යටින් පවතින වස්තුව වෙනස් කර එහි මුල් අගය නැති වී යාමයි. const now = moment();
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>
මුල් දිනය අහිමි වීම වළක්වා ගැනීමට, ඔබට පිටපතක් සෑදීමට Moment object මත ක්ලෝනය ඇමතීමට හැකිය. 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>
අනෙක් අතට, තාවකාලික වස්තූන් වෙනස් කළ නොහැකි ය. ඔබ Instant, PlainDate වැනි වස්තුවක් නිර්මාණය කළ පසු, එම වස්තුවේ අගය කිසිදා වෙනස් නොවේ. තාවකාලික වස්තූන්ට එකතු කිරීමේ සහ අඩු කිරීමේ ක්රම ද ඇත. Temporal යනු කුමන වස්තු වර්ග වලට කුමන කාල ඒකක එකතු කළ හැකිද යන්න ගැන ටිකක් විමසිලිමත් වේ. උදාහරණයක් ලෙස, ඔබට ක්ෂණිකවකට දින එකතු කළ නොහැක:
const now = Temporal.Now.instant(); const nextWeek = now.add({day: 7 }); // RangeError: තාවකාලික දෝෂය: විශාලතම ඒකකය දින ඒකකයක් විය නොහැක
මක්නිසාද යත්, ක්ෂණික වස්තු UTC හි නිශ්චිත කාල සීමාවක් නියෝජනය කරන අතර දින දර්ශන-අඥෙයවාදී වේ. දිවා ආලෝකය ඉතිරි කිරීමේ කාලය වැනි කාල කලාප රීති මත පදනම්ව දිනක දිග වෙනස් විය හැකි නිසා, මෙම ගණනය ක්ෂණිකව ලබා ගත නොහැක. කෙසේ වෙතත්, ඔබට මෙම මෙහෙයුම PlainDateTime වැනි වෙනත් ආකාරයේ වස්තූන් මත සිදු කළ හැක: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 ප.ව
const nextWeek = now.add({day: 7 });
// මුල් PlainDateTime නොවෙනස්ව පවතින බව සලකන්න console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 ප.ව
console.log(nextWeek.toLocaleString()); // 3/3/2026, 8:23:59 ප.ව
Moment හෝ Temporal වස්තු දෙකක් අතර කාලය කොපමණදැයි ඔබට ගණනය කළ හැක. Moment's diff ශ්රිතය සමඟින්, ඔබ කැටිති සඳහා ඒකකයක් සැපයිය යුතුය, එසේ නොමැතිනම් එය මිලි තත්පර වල වෙනස ලබා දෙනු ඇත. 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
තාවකාලික වස්තුවක් සමඟ මෙය සිදු කිරීම සඳහා, ඔබට වෙනත් තාවකාලික වස්තුවක් එහි දක්වා හෝ පසුව ක්රම වෙත මාරු කළ හැකිය. මෙය කාල වෙනස පිළිබඳ තොරතුරු අඩංගු Temporal.Duration වස්තුවක් ලබා දෙයි. කාල පරාසය වස්තුවට වෙනසෙහි එක් එක් සංරචක සඳහා ගුණ ඇති අතර, කාල වෙනස නියෝජනය කරන ISO 8601 කාල සීමාවක් ද ජනනය කළ හැක.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// විශාලතම ඒකකය නියෝජනය කිරීමට විශාලතම කාල ඒකකය නියම කරයි // කාල සීමාව ගණනය කිරීමේදී const diff = දිනය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)
දින සහ වේලාවන් සංසන්දනය කිරීම Moment සහ Temporal යන දෙකම ඔබට දින සහ වේලාවන් සංසන්දනය කර අනෙකට පෙර එන්නේ කුමක්ද යන්න තීරණය කිරීමට ඉඩ සලසයි, නමුත් API සමඟ විවිධ ප්රවේශයන් ගන්න. Moment Moment වස්තූන් දෙකක් සංසන්දනය කිරීම සඳහා isBefore, isAfter සහ isSame වැනි ක්රම සපයයි. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // ඇත්ත
එකම වර්ගයේ වස්තු දෙකක් අතර සංසන්දනය කිරීම සඳහා Temporal ස්ථිතික සංසන්දන ක්රමයක් භාවිතා කරයි. පළමු දිනය දෙවැන්නට පෙර පැමිණේ නම් -1, ඒවා සමාන නම් 0, හෝ පළමු දිනය දෙවැන්නෙන් පසුව පැමිණේ නම් 1 ලබා දෙයි. පහත උදාහරණය PlainDate වස්තු දෙකක් සංසන්දනය කරන ආකාරය පෙන්වයි. Temporal.PlainDate.compare සඳහා වන තර්ක දෙකම PlainDate වස්තු විය යුතුය.
const date1 = Temporal.PlainDate.from({වසර: 2026, මාසය: 2, දිනය: 24}); const date2 = Temporal.PlainDate.from({වසර: 2026, මාසය: 3, දිනය: 24});
// date1 එන්නේ date2ට කලින්, ඉතින් -1 console.log(Temporal.PlainDate.compare(date1, date2));
// අපි විවිධ වර්ගවල වස්තු දෙකක් සංසන්දනය කිරීමට උත්සාහ කළහොත් දෝෂයකි console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: තාවකාලික දෝෂය: වලංගු නොවන PlainDate ක්ෂේත්ර සපයා ඇත.
විශේෂයෙන්ම, මෙය තාවකාලික වස්තූන් පෙළක් කාලානුක්රමිකව වර්ග කිරීම පහසු කරයි. // Temporal.PlainDate වස්තු මාලාවක් const දිනයන් = [ ... ];
// Comparator කාර්යය ලෙස Temporal.PlainDate.compare භාවිතා කරන්න dates.sort(Temporal.PlainDate.compare);
වේලා කලාප පරිවර්තනය Core Moment පුස්තකාලය වේලා කලාප පරිවර්තනය සඳහා සහය නොදක්වයි. ඔබට මෙම ක්රියාකාරීත්වය අවශ්ය නම්, ඔබ moment-timezone පැකේජය ද ස්ථාපනය කළ යුතුය. මෙම පැකේජය ගස සෙලවිය නොහැකි අතර, එම නිසා ඔබේ මිටි ප්රමාණයට සැලකිය යුතු ලෙස එකතු කළ හැක. ඔබ moment-timezone ස්ථාපනය කළ පසු, ඔබට tz ක්රමය සමඟ Moment objects විවිධ කාල කලාපවලට පරිවර්තනය කළ හැක. අනෙකුත් Moment මෙහෙයුම් වලදී මෙන්, මෙය යටින් පවතින දේ විකෘති කරයිවස්තුව. // එක්සත් ජනපදයේ නැගෙනහිර වේලාව උපකල්පනය කිරීම const now = moment(); console.log(දැන්); // මොහොත<2026-02-28T20:08:20-05:00>
// පැසිෆික් වේලාවට පරිවර්තනය කරන්න. // මුල් පෙරදිග කාලය නැති වී යයි. now.tz('America/Los_Angeles'); console.log(දැන්); // මොහොත<2026-02-28T17:08:20-08:00>
Temporal.ZonedDateTime වස්තුවක් භාවිතා කරන විට කාල කලාප ක්රියාකාරිත්වය Temporal 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 වැනි දෙයක් ලැබෙනු ඇත. සැබෑ ලෝක ප්රතිනිර්මාණය කිරීමක් අපි කාල කලාප හරහා සිදුවීම් කාලසටහන්ගත කිරීම සඳහා යෙදුමක් ගොඩනඟනවා යැයි සිතමු. මෙම යෙදුමේ කොටසක් සිදුවීමේ වේලාව සහ දිනය, දේශීය වේලා කලාපයක් සහ ඉලක්ක කාල කලාපයක් නියෝජනය කරන ISO 8601 තන්තුවක් ගන්නා getEventTimes ශ්රිතයකි. ශ්රිතය කාල කලාප දෙකෙහිම සිදුවීම සඳහා ආකෘතිගත වේලාව සහ දින තන්තු නිර්මාණය කරයි. ශ්රිතයට වලංගු වේලාව/දින තන්තුවක් නොවන ආදාන තන්තුවක් ලබා දුන්නේ නම්, එය දෝෂයක් ඇති කරයි. Moment භාවිතා කරමින් මුල් ක්රියාත්මක කිරීම මෙන්න (Moment-timezone පැකේජය භාවිතා කිරීමද අවශ්ය වේ).
'moment-timezone' වෙතින් මොහොත ආයාත කරන්න;
ශ්රිතය 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), }; }
const කාලසටහන = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_York', 'යුරෝපය/ලන්ඩන්', );
console.log(schedule.local); // මාර්තු 5, 2026, 3:00:00 pm EST
console.log(schedule.target); // මාර්තු 5, 2026, 8:00:00 GMT
මෙම උදාහරණයේ දී, අපි ISO 8601 හි අපේක්ෂිත දින ආකෘතියක් භාවිතා කරමින් සිටිමු, එය Moment තුළට උපකාරී වේ. අපි දැඩි විග්රහයක් ද භාවිතා කරමින් සිටිමු, එයින් අදහස් වන්නේ Moment ආකෘතියට නොගැලපෙන දින තන්තුවකින් අනුමාන කිරීමට උත්සාහ නොකරන බවයි. ISO නොවන දින තන්තුවක් සම්මත කළහොත්, එය වලංගු නොවන දින වස්තුවක් ඇති කරයි, අපි දෝෂයක් ඇති කරමු. තාවකාලික ක්රියාත්මක කිරීම සමාන බව පෙනේ, නමුත් ප්රධාන වෙනස්කම් කිහිපයක් ඇත.
ශ්රිතය getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. ආදානය කෙලින්ම ක්ෂණිකව විග්රහ කරන්න, ඉන්පසු සාදන්න // පරිශීලක කලාපයේ ZonedDateTime. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. ඉලක්ක කලාපයට පරිවර්තනය කරන්න // මෙය ස්වයංක්රීයව නව වස්තුවක් ලබා දෙයි; 'eventTime' ආරක්ෂිතයි. const targetTime = EventTime.withTimeZone(targetTimeZone);
// 3. Intl (බිල්ට්-ඉන්) භාවිතයෙන් හැඩතල ගැන්වීම const විකල්ප = { වර්ෂය: 'සංඛ්යා', මාසය: 'කෙටි', දවස: 'සංඛ්යා', පැය: 'සංඛ්යා', මිනිත්තුව: 'ඉලක්කම්-2', දෙවන: 'ඉලක්කම්-2', timeZoneName: 'කෙටි' };
ආපසු { දේශීය: eventTime.toLocaleString(navigator.language, විකල්ප), ඉලක්කය: targetTime.toLocaleString(navigator.language, විකල්ප) }; }
const කාලසටහන = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_York', 'යුරෝපය/ලන්ඩන්', );
console.log(schedule.local); // මාර්තු 5, 2026, 3:00:00 PM EST
console.log(schedule.target); // මාර්තු 5, 2026, 8:00:00 PM GMT
Moment සමඟින්, අපට ලැබෙන දින තන්තු සඳහා ආකෘති තන්තුවක් පැහැදිලිව සඳහන් කළ යුතුය. පරිශීලකයාගේ ස්ථානය හෝ ස්ථානය කුමක් වුවත්, සිදුවීම් වේලාවන් සැම විටම 2026 මාර්තු 5, 3:00:00 ලෙස හැඩතල ගන්වනු ලැබේ.pm EST. එසේම, අපි පැහැදිලිවම ව්යතිරේකයක් විසි කළ යුතු නැත. අවලංගු තන්තුවක් Temporal.Instant.from වෙත ගියහොත්, Temporal විසින් අප වෙනුවෙන් ව්යතිරේකය දමනු ඇත. සැලකිල්ලට ගත යුතු එක් දෙයක් නම්, දැඩි විග්රහ කිරීම් සමඟ වුවද, Moment අනුවාදය තවමත් වඩාත් ලිහිල් බව ය. Temporal ට තන්තුව අවසානයේ කාල කලාපය ඕෆ්සෙට් කිරීම අවශ්ය වේ. අපි navigator.language භාවිතා කරන බැවින්, Navigator Node.js පරිසරයක අර්ථ දක්වා නොමැති බැවින්, මෙම කේතය බ්රවුසර පරිසරයක පමණක් ක්රියාත්මක වන බව ඔබ සටහන් කර ගත යුතුය. තාවකාලික ක්රියාත්මක කිරීම බ්රවුසරයේ වත්මන් පෙදෙසිය (navigator.language) භාවිත කරයි, එම නිසා පරිශීලකයා ස්වයන්ක්රියව ඔවුන්ගේ දේශීය කාල ආකෘතියෙන් සිදුවීම් වේලාවන් හැඩගස්වනු ඇත. එන්-එක්සත් ජනපදයේ, මෙය 2026 මාර්තු 5, ප.ව. 3:00:00 EST වේ. කෙසේ වෙතත්, පරිශීලකයා ලන්ඩනයේ සිටී නම්, උදාහරණයක් ලෙස, සිදුවීම් වේලාවන් 2026 මාර්තු 5, 15:00:00 GMT-5 ලෙස හැඩතල ගන්වනු ලැබේ. සාරාංශය
ක්රියාව Moment.js තාවකාලික වත්මන් කාලය මොහොත () Temporal.Now.zonedDateTimeISO() ISO විග්රහ කිරීම මොහොත (str) Temporal.Instant.from(str) කාලය එකතු කරන්න .එකතු කරන්න(7, 'දින') (විකෘති) .එකතු කරන්න ({දින: 7 }) (නව වස්තුව) වෙනස .diff(වෙනත්, 'පැය') .සිට(වෙනත්).පැය වේලා කලාපය .tz('කලාපය/නම') .WithTimeZone('කලාපය/නම')
මුලින්ම බැලූ බැල්මට, වෙනස තරමක් වෙනස් විය හැකිය (සහ තාවකාලික, සමහර විට වඩාත් වාචික සහ වඩාත් දැඩි) වාක්ය ඛණ්ඩය, නමුත් Moment.js හරහා Temporal භාවිතා කිරීමේ ප්රධාන වාසි කිහිපයක් තිබේ:
වඩාත් පැහැදිලි වීම යනු විස්මයන් සහ අනපේක්ෂිත දෝෂ අඩු වීමයි. මොහොත වඩාත් ලිහිල් බවක් පෙනෙන්නට ඇත, නමුත් එයට "අනුමාන කිරීම්" ඇතුළත් වේ, එය සමහර විට වැරදි දිනයන් ඇති කළ හැකිය. ඔබ Temporal වලංගු නොවන දෙයක් ලබා දෙන්නේ නම්, එය දෝෂයක් ඇති කරයි. කේතය ක්රියාත්මක වන්නේ නම්, ඔබට වලංගු දිනයක් ඇති බව ඔබ දන්නවා. Moment යෙදුමේ බණ්ඩලයට සැලකිය යුතු ප්රමාණයක් එක් කළ හැක, විශේෂයෙන් ඔබ මොහොත-කාල කලාප පැකේජය භාවිතා කරන්නේ නම්. Temporal කිසිවක් එකතු නොකරයි (එය ඔබගේ ඉලක්ක බ්රවුසරයට නැව්ගත කළ පසු). දින පරිවර්තන සහ මෙහෙයුම් සිදු කරන විට ඔබට කිසිදා දත්ත අහිමි නොවන හෝ උඩින් ලියන්නේ නැති බවට විචලනය ඔබට විශ්වාසය ලබා දෙයි. Moment සෑම විටම UTC වේලා මුද්දරයක් වටා එතීම වන ඔබේ අවශ්යතා මත පදනම්ව කාලයෙහි විවිධ නිරූපණයන් (ක්ෂණික, PlainDateTime, ZonedDateTime). Temporal විසින් දින හැඩතල ගැන්වීම සඳහා Intl API භාවිතා කරයි, එයින් අදහස් වන්නේ ඔබට පැහැදිලිවම ටෝකන නියම කිරීමකින් තොරව ස්ථානීය-දැනුවත් හැඩතල ගැන්වීමක් තිබිය හැකි බවයි.
Polyfill පිළිබඳ සටහන් කලින් සඳහන් කළ පරිදි, @js-temporal/polyfill නමින් npm පැකේජයක් ලෙස බෙදා හරින ලද Temporal polyfill එකක් තිබේ. ඔබට අද Temporal භාවිත කිරීමට අවශ්ය නම්, තවමත් API නැව්ගත කර නොමැති Safari වැනි බ්රවුසර සඳහා සහය දැක්වීමට ඔබට මෙම polyfill අවශ්ය වේ. මෙහි ඇති නරක ආරංචිය නම් එය ඔබගේ බණ්ඩල් ප්රමාණයට එකතු වීමයි. ශුභාරංචිය නම්, එය තවමත් මොහොත හෝ මොහොත-කාල කලාපයට වඩා සැලකිය යුතු ලෙස අඩුවෙන් එකතු කරයි. npm පැකේජ ප්රමාණයන් පිළිබඳ තොරතුරු ඉදිරිපත් කරන වෙබ් අඩවියක් වන Bundlephobia.com විසින් වාර්තා කරන ලද බණ්ඩල් ප්රමාණයේ සැසඳීමක් මෙන්න (Bundlephobia විශ්ලේෂණය බැලීමට එක් එක් පැකේජ නාමය මත ක්ලික් කරන්න):
පැකේජය කුඩා කර ඇත minified & gzipped @js-temporal/polyfill 154.1 kB 44.1 kB මොහොත 294.4 kB 75.4 kB මොහොත-වේලා කලාපය 1 MB 114.2 kB
පොලිෆිල් හි ඓතිහාසිකව මතක භාවිතය වටා සමහර කාර්ය සාධන ගැටළු ඇති අතර, ලියන අවස්ථාව වන විට එය ඇල්ෆා තත්වයක පවතින බව සැලකේ. මේ නිසා, එය වඩාත් පරිණත තත්වයට පත් වන තෙක් නිෂ්පාදනයේ දී එය භාවිතා කිරීමට ඔබට අවශ්ය නොවනු ඇත. අනෙක් ශුභාරංචිය නම්, බලාපොරොත්තු වන පරිදි පොලිෆිල් වැඩි කාලයක් අවශ්ය නොවනු ඇත (ඔබට පැරණි බ්රව්සර් සඳහා සහය දැක්වීමට අවශ්ය නම් මිස). ලියන අවස්ථාව වන විට, Temporal Chrome, Edge, සහ Firefox හි නැව්ගත කර ඇත. නවතම තාක්ෂණ පෙරදසුනෙහි ධාවන කාල ධජයක් සමඟින් එය ලබා ගත හැකි බව පෙනුනද, එය තවමත් සෆාරි තුළ සම්පූර්ණයෙන්ම සූදානම් නැත.
