ஜாவாஸ்கிரிப்ட்டில் எழுதப்பட்ட எந்த வகையான பயன்பாடும் சில திறன்களில் நேரங்கள் அல்லது தேதிகளுடன் வேலை செய்கிறது. தொடக்கத்தில், இது உள்ளமைக்கப்பட்ட தேதி APIக்கு மட்டுப்படுத்தப்பட்டது. இந்த API அடிப்படை செயல்பாட்டை உள்ளடக்கியது, ஆனால் அது என்ன செய்ய முடியும் என்பதில் மிகவும் குறைவாக உள்ளது. Moment.js போன்ற மூன்றாம் தரப்பு நூலகங்களும், பின்னர் Intl APIகள் மற்றும் புதிய தற்காலிக API போன்ற உள்ளமைக்கப்பட்ட APIகளும், நேரம் மற்றும் தேதிகளுடன் வேலை செய்வதற்கு அதிக நெகிழ்வுத்தன்மையைச் சேர்க்கின்றன. தருணத்தின் எழுச்சி மற்றும் வீழ்ச்சி.js Moment.js என்பது ஜாவாஸ்கிரிப்ட் நூலகமாகும், இது நேரம் மற்றும் தேதிகளுடன் வேலை செய்வதற்கான சக்திவாய்ந்த பயன்பாடுகளைக் கொண்டுள்ளது. இது நேர மண்டல கையாளுதல் போன்ற அடிப்படை தேதி API இலிருந்து விடுபட்ட அம்சங்களை உள்ளடக்கியது மற்றும் பல பொதுவான செயல்பாடுகளை எளிதாக்குகிறது. தருணம் தேதிகள் மற்றும் நேரங்களை வடிவமைப்பதற்கான செயல்பாடுகளையும் உள்ளடக்கியது. இது பல்வேறு பயன்பாடுகளில் பரவலாகப் பயன்படுத்தப்படும் நூலகமாக மாறியது. இருப்பினும், மொமண்ட் பிரச்சினைகளிலும் அதன் பங்கு இருந்தது. இது ஒரு பெரிய நூலகமாகும், மேலும் பயன்பாட்டின் மூட்டை அளவுக்கு கணிசமாக சேர்க்கலாம். நூலகம் மரத்தை அசைப்பதை ஆதரிக்காததால் (நூலகங்களின் பயன்படுத்தப்படாத பகுதிகளை அகற்றக்கூடிய நவீன தொகுப்புகளின் அம்சம்), நீங்கள் அதன் செயல்பாடுகளில் ஒன்று அல்லது இரண்டு மட்டுமே பயன்படுத்தினாலும், முழு தருண நூலகமும் சேர்க்கப்படும். கணத்தின் மற்றொரு சிக்கல் என்னவென்றால், அது உருவாக்கும் பொருள்கள் மாறக்கூடியவை. ஒரு கணம் பொருளில் சில செயல்பாடுகளை அழைப்பது பக்க விளைவுகளை ஏற்படுத்துகிறது மற்றும் அந்த பொருளின் மதிப்பை மாற்றுகிறது. இது எதிர்பாராத நடத்தை அல்லது பிழைகளுக்கு வழிவகுக்கும். 2020 ஆம் ஆண்டில், மொமென்ட் பராமரிப்பாளர்கள் நூலகத்தை பராமரிப்பு முறையில் வைக்க முடிவு செய்தனர். புதிய அம்ச மேம்பாடு எதுவும் செய்யப்படவில்லை, மேலும் புதிய திட்டங்களுக்கு இதைப் பயன்படுத்துவதற்கு எதிராக பராமரிப்பாளர்கள் பரிந்துரைக்கின்றனர். டேட்-எஃப்என்எஸ் போன்ற பிற ஜாவாஸ்கிரிப்ட் தேதி நூலகங்கள் உள்ளன, ஆனால் நகரத்தில் ஒரு புதிய பிளேயர் உள்ளது, ஒரு ஏபிஐ நேரடியாக ஜாவாஸ்கிரிப்டில் கட்டமைக்கப்பட்டுள்ளது: டெம்போரல். இது ஒரு புதிய தரநிலையாகும், இது அசல் தேதி API இன் துளைகளை நிரப்புகிறது மற்றும் கணம் மற்றும் பிற நூலகங்களில் காணப்படும் சில வரம்புகளைத் தீர்க்கிறது. தற்காலிகம் என்றால் என்ன? டெம்போரல் என்பது ECMAScript தரத்தில் சேர்க்கப்படும் புதிய நேரம் மற்றும் தேதி API ஆகும், இது நவீன ஜாவாஸ்கிரிப்டை வரையறுக்கிறது. மார்ச் 20266 நிலவரப்படி, இது TC39 செயல்முறையின் 4 ஆம் கட்டத்தை எட்டியுள்ளது (ஜாவாஸ்கிரிப்ட் மொழிக்கான முன்மொழிவுகள் மற்றும் சேர்த்தல்களைக் கண்காணிக்கும் குழு), மேலும் ECMAScript விவரக்குறிப்பின் அடுத்த பதிப்பில் சேர்க்கப்படும். இது ஏற்கனவே பல உலாவிகளில் செயல்படுத்தப்பட்டுள்ளது: Chrome 144+ மற்றும் Firefox 139+, Safari விரைவில் பின்பற்றப்படும் என எதிர்பார்க்கப்படுகிறது. ஆதரிக்கப்படாத உலாவிகள் மற்றும் Node.js ஆகியவற்றிற்கும் பாலிஃபில் கிடைக்கிறது. தற்காலிக API ஆனது, பொதுவாக, நேரத்தின் தருணங்களைக் குறிக்கும் பொருள்களை உருவாக்குகிறது. இவை கொடுக்கப்பட்ட நேர மண்டலத்தில் முழுநேர மற்றும் தேதி முத்திரைகளாக இருக்கலாம் அல்லது நேர மண்டலம் அல்லது தேதித் தகவல் இல்லாமல் "சுவர் கடிகாரம்" நேரத்தின் பொதுவான நிகழ்வாக இருக்கலாம். டெம்போரலின் சில முக்கிய அம்சங்கள் பின்வருமாறு:
தேதிகளுடன் அல்லது இல்லாத நேரங்கள். ஒரு தற்காலிக பொருள் ஒரு குறிப்பிட்ட தேதியில் ஒரு குறிப்பிட்ட நேரத்தை அல்லது எந்த தேதி தகவலும் இல்லாத நேரத்தை குறிக்கும். ஒரு குறிப்பிட்ட தேதி, நேரம் இல்லாமல், குறிப்பிடப்படலாம். நேர மண்டல ஆதரவு. டெம்போரல் பொருள்கள் முழு நேர மண்டலம் தெரியும் மற்றும் வெவ்வேறு நேர மண்டலங்களில் மாற்றப்படலாம். கணம் நேர மண்டலங்களையும் ஆதரிக்கிறது, ஆனால் அதற்கு கூடுதல் தருண நேர மண்டல நூலகம் தேவைப்படுகிறது. மாறாத தன்மை. ஒரு தற்காலிக பொருள் உருவாக்கப்பட்டவுடன், அதை மாற்ற முடியாது. நேர எண்கணிதம் அல்லது நேர மண்டல மாற்றங்கள் அடிப்படை பொருளை மாற்றாது. மாறாக, அவை புதிய தற்காலிக பொருளை உருவாக்குகின்றன. 1-அடிப்படையிலான அட்டவணைப்படுத்தல்.தேதி API (அத்துடன் தருணத்துடன்) உள்ள பிழைகளின் பொதுவான ஆதாரம் மாதங்கள் பூஜ்ஜிய-குறியீடு ஆகும். அதாவது, நிஜ வாழ்க்கையில் நாம் அனைவரும் புரிந்துகொள்வது போல், ஜனவரி மாதம் 1 ஐ விட, மாதம் 0 ஆகும். 1-அடிப்படையிலான அட்டவணையைப் பயன்படுத்தி தற்காலிகமானது இதை சரிசெய்கிறது - ஜனவரி மாதம் 1. இது உலாவியில் கட்டமைக்கப்பட்டுள்ளது. டெம்போரல் என்பது பிரவுசரில் உள்ள API என்பதால், இது உங்கள் பயன்பாட்டின் தொகுப்பு அளவில் எதையும் சேர்க்காது.
தேதி API மறைந்துவிடவில்லை என்பதையும் கவனத்தில் கொள்ள வேண்டும். டெம்பரல் இந்த API ஐ மாற்றியமைக்கும் போது, இது அகற்றப்படவில்லை அல்லது நிராகரிக்கப்படவில்லை. உலாவிகள் திடீரென்று தேதி API ஐ அகற்றினால் பல பயன்பாடுகள் உடைந்து விடும். இருப்பினும், மொமன்ட் இப்போது பராமரிப்பு முறையில் ஒரு மரபு திட்டமாக கருதப்படுகிறது என்பதையும் நினைவில் கொள்ளுங்கள். மீதமுள்ள கட்டுரையில், புதிய தற்காலிக API க்கு மொமன்ட் அடிப்படையிலான குறியீட்டை மாற்றுவதற்கான சில "சமையல்களை" பார்ப்போம். மறுசீரமைப்பைத் தொடங்குவோம்! தேதி மற்றும் நேர பொருள்களை உருவாக்குதல் தேதிகளையும் நேரத்தையும் கையாளும் முன், அவற்றைக் குறிக்கும் பொருட்களை உருவாக்க வேண்டும். தற்போதைய தேதி மற்றும் நேரத்தைக் குறிக்கும் தருணப் பொருளை உருவாக்க, கணம் செயல்பாட்டைப் பயன்படுத்தவும். இப்போது நிலை = கணம்(); 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 காலை
கணம் பற்றி நினைவில் கொள்ள வேண்டிய முக்கிய விஷயம் என்னவென்றால், ஒரு கணம் பொருள் எப்போதும் நேரம் மற்றும் தேதி பற்றிய தகவல்களை உள்ளடக்கியது. நீங்கள் நேரத் தகவலுடன் மட்டுமே வேலை செய்ய வேண்டும் என்றால், இது பொதுவாக நன்றாக இருக்கும், ஆனால் இது பகல் சேமிப்பு நேரம் அல்லது லீப் ஆண்டுகள் போன்ற சூழ்நிலைகளில் எதிர்பாராத நடத்தையை ஏற்படுத்தலாம், அங்கு தேதியானது நேரக் கணக்கீடுகளில் தாக்கத்தை ஏற்படுத்தும். தற்காலிகமானது மிகவும் நெகிழ்வானது. Temporal.Instant object ஐ உருவாக்குவதன் மூலம் தற்போதைய தேதி மற்றும் நேரத்தை குறிக்கும் ஒரு பொருளை நீங்கள் உருவாக்கலாம். இது "சகாப்தம்" (ஜனவரி 1, 1970 அன்று நள்ளிரவு UTC) காலத்தால் வரையறுக்கப்பட்ட நேரப் புள்ளியைக் குறிக்கிறது. நானோ வினாடி-நிலை துல்லியத்துடன் டெம்போரல் இந்த உடனடி நேரத்தைக் குறிப்பிடலாம். இப்போது நிலை = 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
தற்காலிகப் பொருள்கள். ஒரு குறிப்பிட்ட நேரம் மற்றும் தேதியில் இருந்து நிலையான முறையைப் பயன்படுத்தி உருவாக்கலாம்.
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: ஒரு குறிப்பிட்ட நேர மண்டலத்தில் ஒரு தேதி மற்றும் நேரம்.
இவை ஒவ்வொன்றும் தேதி மற்றும்/அல்லது நேரத்தைக் குறிப்பிடும் பொருளுடன் அழைக்கப்படும் ஒரு முறையிலிருந்து அல்லது பாகுபடுத்துவதற்கான தேதி சரத்தைக் கொண்டுள்ளது. //ஒரு தேதி இன்றைய நிலை = 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[அமெரிக்கா/நியூயார்க்]
பாகுபடுத்துதல் தேதி மற்றும் நேரத் தகவலின் நிரல் உருவாக்கத்தை நாங்கள் உள்ளடக்கியுள்ளோம். இப்போது பாகுபடுத்துவதைப் பார்ப்போம். பாகுபடுத்துதல் என்பது உள்ளமைக்கப்பட்ட டெம்போரல் ஏபிஐயை விட தருணம் மிகவும் நெகிழ்வான பகுதியாகும். தருணச் செயல்பாட்டிற்கு அனுப்புவதன் மூலம் தேதி சரத்தை அலசலாம். ஒற்றை வாதத்துடன், மொமன்ட் ஒரு 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 வடிவமைக்கப்பட்ட தேதி சரம் இல்லாமல் அழைக்கப்பட்டால் (விரும்பிய வடிவத்துடன் இரண்டாவது வாதமும் கொடுக்கப்படாவிட்டால்) ஒரு முக்கிய தேய்மான எச்சரிக்கையைக் காண்பிக்கும். டெம்போரல் குறிப்பாக வடிவமைக்கப்பட்ட தேதி சரத்தை மட்டுமே பாகுபடுத்தும். சரமானது 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 அல்லாத சரங்களைக் கையாளுதல், ஏனெனில் டெம்போரல் நம்பகத்தன்மைக்கு முன்னுரிமை அளிப்பதால், 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
மறுபுறம், டெம்போரல் நீங்கள் இன்னும் கொஞ்சம் வாய்மொழியாக இருக்க வேண்டும். இன்ஸ்டன்ட் போன்ற தற்காலிக பொருள்கள், ஒரு பொருளின் பண்புகளாகக் குறிப்பிடப்பட்ட பல்வேறு வடிவமைப்பு விருப்பங்களை ஏற்கும் 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 மணிக்கு
// வடிவமைப்பு சரத்தில் நீங்கள் விரும்பும் புலங்களை மட்டும் அனுப்பவும் console.log(date.toLocaleString('en-US', {) மாதம்: 'குறுகிய', நாள்: 'எண்' })); //பிப். 22
தற்காலிக தேதி வடிவமைப்பு உண்மையில் Intl.DateTimeFormat API ஐப் பயன்படுத்துகிறது (இது நவீன உலாவிகளில் ஏற்கனவே கிடைக்கிறது) ஹூட்டின் கீழ். அதாவது, உங்கள் தனிப்பயன் வடிவமைப்பு விருப்பங்கள் மூலம் மீண்டும் பயன்படுத்தக்கூடிய DateTimeFormat பொருளை உருவாக்கலாம், அதன் பிறகு தற்காலிக பொருட்களை அதன் வடிவமைப்பு முறைக்கு அனுப்பலாம். இதன் காரணமாக, Moment போன்ற தனிப்பயன் தேதி வடிவங்களை இது ஆதரிக்காது. உங்களுக்கு '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, 'days'). இருப்பினும், கணத்திற்கும் தற்காலிகத்திற்கும் இடையிலான ஒரு மிக முக்கியமான வேறுபாடு என்னவென்றால், இந்த தேதி கணக்கீடுகளைச் செய்யும்போது, அடிப்படையான பொருள் மாற்றப்பட்டு அதன் அசல் மதிப்பு இழக்கப்படுகிறது. இப்போது நிலை = கணம்();
console.log(இப்போது); // தருணம்<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log(அடுத்த வாரம்); // தருணம்<2026-03-03T20:08:36-05:00>
// கோட்சா - அசல் பொருள் மாற்றப்பட்டது console.log(இப்போது); // தருணம்<2026-03-03T20:08:36-05:00>
அசல் தேதியை இழப்பதைத் தவிர்க்க, நகலை உருவாக்க மொமென்ட் ஆப்ஜெக்ட்டில் குளோனை அழைக்கலாம். இப்போது தொடர்ந்து= கணம் (); const nextWeek = now.clone().add(7, 'days');
console.log(இப்போது); // தருணம்<2026-02-24T20:12:55-05:00>
console.log(அடுத்த வாரம்); // தருணம்<2026-03-03T20:12:55-05:00>
மறுபுறம், தற்காலிக பொருள்கள் மாறாதவை. இன்ஸ்டண்ட், ப்ளைன்டேட் மற்றும் பல போன்ற ஒரு பொருளை நீங்கள் உருவாக்கியவுடன், அந்த பொருளின் மதிப்பு மாறாது. தற்காலிகப் பொருள்கள் கூடுதல் மற்றும் கழித்தல் முறைகளைக் கொண்டுள்ளன. எந்தெந்த பொருள் வகைகளில் எந்த நேர அலகுகளை சேர்க்கலாம் என்பது பற்றி டெம்போரல் கொஞ்சம் தேர்ந்தது. எடுத்துக்காட்டாக, ஒரு நொடியில் நாட்களைச் சேர்க்க முடியாது:
இப்போது நிலை = Temporal.Now.instant(); const nextWeek = now.add({நாட்கள்: 7 }); // RangeError: தற்காலிகப் பிழை: மிகப்பெரிய அலகு தேதி அலகாக இருக்க முடியாது
ஏனென்றால், உடனடிப் பொருள்கள் UTC இல் ஒரு குறிப்பிட்ட நேரத்தைக் குறிக்கின்றன மற்றும் அவை காலண்டர்-அஞ்ஞானம். பகல்நேர சேமிப்பு நேரம் போன்ற நேர மண்டல விதிகளின் அடிப்படையில் ஒரு நாளின் நீளம் மாறக்கூடும் என்பதால், இந்தக் கணக்கீடு ஒரு நொடியில் கிடைக்காது. இருப்பினும், PlainDateTime போன்ற பிற வகையான பொருள்களில் இந்தச் செயல்பாட்டைச் செய்யலாம்: இப்போது நிலை = Temporal.Now.plainDateTimeISO(); console.log( now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({நாட்கள்: 7 });
// அசல் PlainDateTime மாறாமல் உள்ளது என்பதை நினைவில் கொள்ளவும் console.log( now.toLocaleString()); // 2/24/2026, 8:23:59 PM
console.log(nextWeek.toLocaleString()); // 3/3/2026, 8:23:59 PM
இரண்டு கணம் அல்லது தற்காலிக பொருள்களுக்கு இடையே எவ்வளவு நேரம் இருக்கிறது என்பதையும் நீங்கள் கணக்கிடலாம். Moment’s diff செயல்பாட்டின் மூலம், நீங்கள் கிரானுலாரிட்டிக்கு ஒரு யூனிட்டை வழங்க வேண்டும், இல்லையெனில் அது மில்லி விநாடிகளில் வித்தியாசத்தை வழங்கும். நிலையான தேதி1 = தருணம்('2026-02-21T09:00:00'); நிலையான தேதி2 = தருணம்('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 உடன் வெவ்வேறு அணுகுமுறைகளை எடுக்கவும். Moment ஆனது இரண்டு கணப் பொருட்களை ஒப்பிடுவதற்கு isBefore, isAfter மற்றும் isSame போன்ற முறைகளை வழங்குகிறது. நிலையான தேதி1 = தருணம்('2026-02-21T09:00:00'); நிலையான தேதி2 = தருணம்('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); //உண்மை
ஒரே மாதிரியான இரண்டு பொருள்களுக்கு இடையே ஒப்பீடு செய்ய டெம்போரல் ஒரு நிலையான ஒப்பீட்டு முறையைப் பயன்படுத்துகிறது. முதல் தேதி இரண்டாவது தேதிக்கு முன் வந்தால் -1, சமமாக இருந்தால் 0, அல்லது இரண்டாவது தேதிக்குப் பிறகு முதல் தேதி வந்தால் 1 என்று வழங்கும். இரண்டு PlainDate பொருட்களை எவ்வாறு ஒப்பிடுவது என்பதை பின்வரும் எடுத்துக்காட்டு காட்டுகிறது. Temporal.PlainDate.compareக்கான இரண்டு வாதங்களும் PlainDate பொருள்களாக இருக்க வேண்டும்.
const date1 = Temporal.PlainDate.from({வருடம்: 2026, மாதம்: 2, நாள்: 24}); const date2 = Temporal.PlainDate.from({வருடம்: 2026, மாதம்: 3, நாள்: 24});
// தேதி1 என்பது தேதி2க்கு முன் வருகிறது, எனவே -1 console.log(Temporal.PlainDate.compare(date1, date2));
// வெவ்வேறு வகையான இரண்டு பொருட்களை ஒப்பிட முயற்சித்தால் பிழை console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // வகைப் பிழை: தற்காலிகப் பிழை: தவறான PlainDate புலங்கள் வழங்கப்பட்டுள்ளன.
குறிப்பாக, இது தற்காலிக பொருள்களின் வரிசையை காலவரிசைப்படி வரிசைப்படுத்துவதை எளிதாக்குகிறது. // Temporal.PlainDate பொருள்களின் வரிசை நிலையான தேதிகள் = [... ];
// 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 இல் கட்டமைக்கப்படுகிறது. இந்த ஆப்ஜெக்ட்கள், குறிப்பிட்ட நேர மண்டலத்தில் அதே தருணத்தைக் குறிக்கும் புதிய ZonedDateTimeஐ வழங்கும் withTimeZone முறையை உள்ளடக்கியது. // மீண்டும், அமெரிக்க கிழக்கு நேரத்தை அனுமானிக்கிறேன் இப்போது நிலை = Temporal.Now.zonedDateTimeISO(); console.log( now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
// பசிபிக் நேரத்திற்கு மாற்றவும் கான்ஸ்ட் நவ்பசிபிக் = 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 சரத்தை எதிர்பார்க்கலாம் உண்மை, // கண்டிப்பான பாகுபடுத்தல் பயனர் நேர மண்டலம் );
// 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 EST
console.log(schedule.target); // மார்ச் 5, 2026, 8:00:00 pm GMT
இந்த எடுத்துக்காட்டில், ஐஎஸ்ஓ 8601 இன் எதிர்பார்க்கப்படும் தேதி வடிவமைப்பைப் பயன்படுத்துகிறோம், இது தருணத்தில் உதவியாக கட்டமைக்கப்பட்டுள்ளது. நாங்கள் கடுமையான பாகுபடுத்தலையும் பயன்படுத்துகிறோம், அதாவது வடிவத்துடன் பொருந்தாத தேதி சரத்தை கணம் யூகிக்க முயற்சிக்காது. ISO அல்லாத தேதி சரம் அனுப்பப்பட்டால், அது தவறான தேதிப் பொருளை ஏற்படுத்தும், மேலும் நாங்கள் பிழையை எறிவோம். தற்காலிக செயலாக்கம் ஒத்ததாகத் தெரிகிறது, ஆனால் சில முக்கிய வேறுபாடுகள் உள்ளன.
செயல்பாடு getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. உள்ளீட்டை நேரடியாக ஒரு உடனடியில் அலசவும், பின்னர் உருவாக்கவும் // பயனரின் மண்டலத்தில் ஒரு ZonedDateTime. கான்ஸ்ட் உடனடி = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. இலக்கு மண்டலத்திற்கு மாற்றவும் // இது தானாகவே ஒரு புதிய பொருளைத் தருகிறது; 'நிகழ்வு நேரம்' பாதுகாப்பானது. 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
கணம் மூலம், விளைந்த தேதி சரங்களுக்கான வடிவமைப்பு சரத்தை நாம் வெளிப்படையாகக் குறிப்பிட வேண்டும். பயனரின் இருப்பிடம் அல்லது இடம் எதுவாக இருந்தாலும், நிகழ்வு நேரங்கள் எப்போதும் மார்ச் 5, 2026, 3:00:00 என வடிவமைக்கப்படும்pm EST. மேலும், நாம் வெளிப்படையாக விதிவிலக்கு கொடுக்க வேண்டியதில்லை. ஒரு தவறான சரம் Temporal.Instant.from க்கு அனுப்பப்பட்டால், Temporal நமக்கு விதிவிலக்கு அளிக்கும். கவனிக்க வேண்டிய ஒரு விஷயம் என்னவென்றால், கடுமையான பாகுபடுத்தலுடன் கூட, கணம் பதிப்பு இன்னும் மென்மையானது. Temporal க்கு சரத்தின் முடிவில் நேர மண்டல ஆஃப்செட் தேவை. நாங்கள் navigator.language ஐப் பயன்படுத்துவதால், Node.js சூழலில் நேவிகேட்டர் வரையறுக்கப்படாததால், இந்தக் குறியீடு உலாவி சூழலில் மட்டுமே இயங்கும் என்பதையும் நீங்கள் கவனிக்க வேண்டும். தற்காலிக செயலாக்கமானது உலாவியின் தற்போதைய மொழியைப் பயன்படுத்துகிறது (navigator.language), எனவே பயனர் தானாகவே நிகழ்வின் நேரத்தை அவர்களின் உள்ளூர் நேர வடிவமைப்பில் வடிவமைத்துக்கொள்வார். en-US லோகேலில், இது மார்ச் 5, 2026, பிற்பகல் 3:00:00 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 இல் டெம்போரலைப் பயன்படுத்துவதில் பல முக்கிய நன்மைகள் உள்ளன:
மிகவும் வெளிப்படையாக இருப்பது என்பது குறைவான ஆச்சரியங்கள் மற்றும் திட்டமிடப்படாத பிழைகள் என்பதாகும். கணம் மிகவும் மென்மையானதாகத் தோன்றலாம், ஆனால் இது "யூகத்தை" உள்ளடக்கியது, இது சில நேரங்களில் தவறான தேதிகளை விளைவிக்கலாம். டெம்பரல் ஏதாவது தவறானதாகக் கொடுத்தால், அது பிழையை ஏற்படுத்தும். குறியீடு இயங்கினால், சரியான தேதியைப் பெற்றுள்ளீர்கள் என்பது உங்களுக்குத் தெரியும். மொமன்ட் பயன்பாட்டின் தொகுப்பில் குறிப்பிடத்தக்க அளவைச் சேர்க்கலாம், குறிப்பாக நீங்கள் தருண நேர மண்டல தொகுப்பைப் பயன்படுத்தினால். டெம்போரல் எதையும் சேர்க்காது (உங்கள் இலக்கு உலாவிகளில் அனுப்பப்பட்டவுடன்). தேதி மாற்றங்கள் மற்றும் செயல்பாடுகளைச் செய்யும்போது நீங்கள் ஒருபோதும் தரவை இழக்க மாட்டீர்கள் அல்லது மேலெழுத மாட்டீர்கள் என்ற நம்பிக்கையை மாறாத தன்மை உங்களுக்கு வழங்குகிறது. உங்கள் தேவைகளைப் பொறுத்து நேரத்தின் வெவ்வேறு பிரதிநிதித்துவங்கள் (Instant, PlainDateTime, ZonedDateTime) இதில் Moment எப்போதும் UTC நேர முத்திரையைச் சுற்றி ஒரு ரேப்பராக இருக்கும். டெம்போரல் தேதி வடிவமைப்பிற்காக Intl APIகளைப் பயன்படுத்துகிறது, அதாவது டோக்கன்களை வெளிப்படையாகக் குறிப்பிடாமல் நீங்கள் லோகேல்-அறிவு வடிவமைப்பைக் கொண்டிருக்கலாம்.
பாலிஃபில் பற்றிய குறிப்புகள் முன்பே குறிப்பிட்டபடி, @js-temporal/polyfill என்ற பெயரில் npm தொகுப்பாக விநியோகிக்கப்படும் தற்காலிக பாலிஃபில் உள்ளது. இன்று டெம்போரலைப் பயன்படுத்த விரும்பினால், இதுவரை API ஐ அனுப்பாத Safari போன்ற உலாவிகளை ஆதரிக்க இந்த பாலிஃபில் உங்களுக்குத் தேவைப்படும். இதனுடன் மோசமான செய்தி என்னவென்றால், இது உங்கள் மூட்டை அளவை அதிகரிக்கும். நல்ல செய்தி என்னவென்றால், இது இன்னும் கணம் அல்லது கண நேர மண்டலத்தை விட கணிசமாக குறைவாக சேர்க்கிறது. npm தொகுப்பு அளவுகள் பற்றிய தகவலை வழங்கும் Bundlephobia.com என்ற இணையதளம் அறிக்கையின்படி மூட்டை அளவுகளின் ஒப்பீடு இங்கே உள்ளது (Bundlephobia பகுப்பாய்வு பார்க்க ஒவ்வொரு தொகுப்பின் பெயரையும் கிளிக் செய்யவும்):
தொகுப்பு சிறுமைப்படுத்தப்பட்டது மினிஃபைட் & ஜிஜிப் @js-temporal/polyfill 154.1 கி.பி 44.1 கி.பி கணம் 294.4 கி.பி 75.4 கி.பி கண நேர மண்டலம் 1 எம்பி 114.2 கி.பி
பாலிஃபில் வரலாற்று ரீதியாக நினைவக பயன்பாட்டைச் சுற்றி சில செயல்திறன் சிக்கல்களைக் கொண்டுள்ளது, மேலும் எழுதும் நேரத்தில், அது ஆல்பா நிலையில் இருப்பதாகக் கருதப்படுகிறது. இதன் காரணமாக, அது மிகவும் முதிர்ந்த நிலையை அடையும் வரை நீங்கள் அதை உற்பத்தியில் பயன்படுத்த விரும்பாமல் இருக்கலாம். மற்ற நல்ல செய்தி என்னவென்றால், பாலிஃபில் அதிக நேரம் தேவைப்படாது (நிச்சயமாக நீங்கள் பழைய உலாவிகளை ஆதரிக்க வேண்டும் என்றால்). எழுதும் நேரத்தில், Temporal ஆனது Chrome, Edge மற்றும் Firefox இல் அனுப்பப்பட்டது. சஃபாரியில் இது இன்னும் சரியாகத் தயாராகவில்லை, இருப்பினும் சமீபத்திய தொழில்நுட்ப முன்னோட்டத்தில் இது இயக்க நேரக் கொடியுடன் கிடைக்கும்.
