யூனிக்ஸ் டைம் ஸ்டாம்ப் மாற்றி

அறிமுகம்

யூனிக்ஸ் டைம் ஸ்டாம்ப் (POSIX நேரம் அல்லது எபொக் நேரம் எனவும் அழைக்கப்படுகிறது) என்பது ஒரு குறிப்பிட்ட நேரத்தை விவரிக்க ஒரு முறைமையாகும். இது 1970 ஜனவரி 1 (மதியம் UTC/GMT) முதல் கடந்த செக்குகள், எலிப் செக்குகளை கணக்கில் எடுத்துக்கொள்ளாமல், கடந்த நொடிகளை (seconds) குறிக்கிறது. யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் கணினி அமைப்புகள் மற்றும் நிரலாக்க மொழிகளில் பரவலாகப் பயன்படுத்தப்படுகின்றன, ஏனெனில் அவை ஒரு குறிப்பிட்ட நேரத்தை அடிப்படையாகக் கொண்ட, மொழி சாராத, சுருக்கமான பிரதிநிதித்துவத்தை வழங்குகின்றன.

இந்த டைம் ஸ்டாம்ப் முதல் தேதி மாற்றி பல அளவுகளில் உள்ள டைம் ஸ்டாம்ப்களை தானாகவே கண்டறிந்து செயலாக்குகிறது, மைக்ரோசெக்குகள் (16 இலக்கங்கள்), மில்லிசெக்குகள் (13 இலக்கங்கள்) மற்றும் தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் (10 இலக்கங்கள்) உட்பட. உள்நுழைவு நீளத்தின் அடிப்படையில் டைம் ஸ்டாம்ப் வடிவத்தை அடையாளம் காண்கிறது, அதை மனிதனுக்கு வாசிக்கக்கூடிய தேதி மற்றும் நேரம் வடிவத்திற்கு மாற்றுகிறது, மற்றும் டைம் ஸ்டாம்ப் வகையை குறிப்பிடுவதற்கான தேவையை இல்லாமல் முடிவை காட்டுகிறது. இது 12-மணி (AM/PM) மற்றும் 24-மணி நேர வடிவங்களை ஆதரிக்கிறது, இது பல்வேறு பிராந்திய மற்றும் தனிப்பட்ட விருப்பங்களை ஏற்றுக்கொள்கிறது.

யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் எப்படி வேலை செய்கின்றன

யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் யூனிக்ஸ் எபொக் (1970 ஜனவரி 1, 00:00:00 UTC) முதல் கடந்த நொடிகளை (seconds) எண்ணி கணக்கிடப்படுகின்றன. இது நேர வேறுபாடுகளை கணக்கிடுவதற்கும், ஒரு சுருக்கமான வடிவத்தில் தேதிகளை சேமிக்கவும் மிகவும் பயனுள்ளதாக இருக்கிறது.

யூனிக்ஸ் டைம் ஸ்டாம்ப் முதல் காலண்டர் தேதிக்கு மாற்றுவதற்கான கணித மாற்றம் பல படிகளை உள்ளடக்குகிறது:

1. யூனிக்ஸ் எபொக்குடன் (1970 ஜனவரி 1, 00:00:00 UTC) தொடங்குங்கள்
2. டைம் ஸ்டாம்பில் உள்ள நொடிகளை (seconds) சேர்க்கவும்
3. எலிப் ஆண்டுகள், மாறும் மாத நீளங்கள் மற்றும் பிற காலண்டர் சிக்கல்களை கணக்கில் எடுத்துக்கொள்ளவும்
4. தேவையானால் நேர மண்டல மாற்றங்களைப் பயன்படுத்தவும்

உதாரணமாக, யூனிக்ஸ் டைம் ஸ்டாம்ப் 1609459200 என்பது வெள்ளிக்கிழமை, 2021 ஜனவரி 1, 00:00:00 UTC ஐ குறிக்கிறது.

மாற்று சூத்திரத்தை கீழ்காணும் வகையில் வெளிப்படுத்தலாம்:

$\text{தேதி} = \text{யூனிக்ஸ் எபொக்} + \text{டைம் ஸ்டாம்ப் (நொடிகளில்)}$

பல நிரலாக்க மொழிகள் மற்றும் செயல்பாட்டுப் படிமங்கள் இந்த மாற்றத்தை கையாள்வதற்கான உள்ளமைவுகளை வழங்குகின்றன, இது சிக்கலான காலண்டர் கணக்கீடுகளை மறைக்கிறது.

டைம் ஸ்டாம்ப் வடிவங்கள் மற்றும் தானாகக் கண்டறிதல்

எங்கள் மாற்றி மூன்று பொதுவான டைம் ஸ்டாம்ப் வடிவங்களை ஆதரிக்கிறது, அவற்றை இலக்கங்களின் எண்ணிக்கையின் அடிப்படையில் தானாகவே கண்டறியப்படுகிறது:

1. தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (10 இலக்கங்கள்): யூனிக்ஸ் எபொக்கில் இருந்து கடந்த நொடிகளை (seconds) குறிக்கிறது. உதாரணம்: 1609459200 (2021 ஜனவரி 1, 00:00:00 UTC)

2. மில்லிசெக்குகள் (13 இலக்கங்கள்): யூனிக்ஸ் எபொக்கில் இருந்து கடந்த மில்லிசெக்குகளை (milliseconds) குறிக்கிறது. உதாரணம்: 1609459200000 (2021 ஜனவரி 1, 00:00:00 UTC)

3. மைக்ரோசெக்குகள் (16 இலக்கங்கள்): யூனிக்ஸ் எபொக்கில் இருந்து கடந்த மைக்ரோசெக்குகளை (microseconds) குறிக்கிறது. உதாரணம்: 1609459200000000 (2021 ஜனவரி 1, 00:00:00 UTC)

தானாகக் கண்டறிதல் உள்நுழைவின் நீளத்தைப் பார்க்கும் மூலம் வேலை செய்கிறது:

• உள்நுழைவு 10 இலக்கங்களை கொண்டிருந்தால், இது தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்) ஆகக் கருதப்படுகிறது
• உள்நுழைவு 13 இலக்கங்களை கொண்டிருந்தால், இது மில்லிசெக்குகள் (milliseconds) ஆகக் கருதப்படுகிறது
• உள்நுழைவு 16 இலக்கங்களை கொண்டிருந்தால், இது மைக்ரோசெக்குகள் (microseconds) ஆகக் கருதப்படுகிறது

இந்த தானாகக் கண்டறிதல் பயனர்களால் டைம் ஸ்டாம்ப் வகையை குறிப்பிடுவதற்கான தேவையை நீக்குகிறது, இது கருவியை மேலும் பயனர் நட்பு மற்றும் திறமையானதாக ஆக்குகிறது.

நேர வடிவ விருப்பங்கள்

இந்த மாற்றி இரண்டு நேர வடிவ விருப்பங்களை வழங்குகிறது:

1. 24-மணி வடிவம் (சில நேரங்களில் "மிலிடரி நேரம்" என அழைக்கப்படுகிறது): மணிகள் 0 முதல் 23 வரை உள்ளன, மேலும் AM/PM சான்றிதழ் இல்லை. உதாரணமாக, 3:00 PM 15:00 எனக் குறிக்கப்படுகிறது.

2. 12-மணி வடிவம்: மணிகள் 1 முதல் 12 வரை உள்ளன, மதியம் முதல் மாலை வரை AM (ante meridiem) மற்றும் மாலை முதல் மதியம் வரை PM (post meridiem) ஆகக் குறிக்கப்படுகிறது. உதாரணமாக, 24-மணி வடிவத்தில் 15:00 என்பது 3:00 PM எனக் குறிக்கப்படுகிறது.

இந்த வடிவங்களில் தேர்வு செய்வது பெரும்பாலும் பிராந்திய வழக்கங்கள் மற்றும் தனிப்பட்ட விருப்பங்களின் அடிப்படையில் உள்ளது:

• 24-மணி வடிவம் பெரும்பாலும் ஐரோப்பா, லத்தீன் அமெரிக்கா மற்றும் ஆசியாவின் பெரும்பாலான பகுதிகளில், உலகளாவிய அறிவியல், மிலிடரி மற்றும் மருத்துவ சூழ்நிலைகளில் பயன்படுத்தப்படுகிறது.
• 12-மணி வடிவம் அமெரிக்கா, கனடா, ஆஸ்திரேலியா மற்றும் பிற ஆங்கில பேசும் நாடுகளில் பரவலாக உள்ளது.

எட்ஜ் கேஸ்கள் மற்றும் வரம்புகள்

பல அளவுகளில் உள்ள யூனிக்ஸ் டைம் ஸ்டாம்ப்களைப் பயன்படுத்தும்போது, பல எட்ஜ் கேஸ்கள் மற்றும் வரம்புகளைப் புரிந்துகொள்வது முக்கியம்:

1. எதிர்மறை டைம் ஸ்டாம்ப்கள்: யூனிக்ஸ் எபொக்கிற்கு (1970 ஜனவரி 1) முன்புள்ள தேதிகளை குறிக்கின்றன. கணித ரீதியாக சரியானவை, ஆனால் சில அமைப்புகள் எதிர்மறை டைம் ஸ்டாம்ப்களை சரியாக கையாளவோ முடியாது. இது மூன்று டைம் ஸ்டாம்ப் வடிவங்களுக்கும் பொருந்துகிறது.

2. 2038 ஆண்டின் பிரச்சனை: தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் (10 இலக்கங்கள்) பொதுவாக 32-பிட் கையெழுத்தான முழு எண்களாக சேமிக்கப்படுகின்றன, இது 2038 ஜனவரி 19 அன்று ஓவர்ஃப்ளோ ஆகும். இந்த நேரத்திற்கு பிறகு, 32-பிட் அமைப்புகள் நேரங்களை சரியாக பிரதிநிதித்துவம் செய்ய முடியாது, மாற்றங்கள் செய்யப்படாவிட்டால்.

3. அளவீட்டு கருத்துக்கள்:

   • தரநிலையான டைம் ஸ்டாம்ப்கள் (10 இலக்கங்கள்) நொடிகள் மட்டுமே அளவீடு செய்யும், இது பெரும்பாலான தினசரி பயன்பாடுகளுக்கு போதுமானது.
   • மில்லிசெக்குகள் (13 இலக்கங்கள்) 1000 மடங்கு அதிகமான அளவீட்டை வழங்குகின்றன, மேலும் அதிகமான துல்லியமான நேரத்தை தேவைப்படும் பயன்பாடுகளுக்கு பயனுள்ளதாக இருக்கிறது.
   • மைக்ரோசெக்குகள் (16 இலக்கங்கள்) மேலும் சிறிய அளவீட்டை (1,000,000வது ஒரு நொடி) வழங்குகின்றன, இது உயர் செயல்திறனைப் பெறும் கணினி, அறிவியல் பயன்பாடுகள் மற்றும் சில நிதி பரிவர்த்தனைகளுக்கு தேவையானது.

4. மிகவும் பெரிய டைம் ஸ்டாம்ப்கள்: மிகவும் தொலைவில் உள்ள எதிர்கால தேதிகள் சில அமைப்புகளில் பிரதிநிதித்துவம் செய்ய முடியாது, அல்லது மாறுபட்ட முறையில் கையாளப்படலாம். இது குறிப்பாக மில்லிசெக்குகள் மற்றும் மைக்ரோசெக்குகள் (16 இலக்கங்கள்) உட்பட, பெரிய எண்களைப் பயன்படுத்தும்.

5. எலிப் செக்குகள்: யூனிக்ஸ் நேரம் எலிப் செக்குகளை கணக்கில் எடுத்துக்கொள்வதில்லை, இது UTC-க்கு சரியான நேரத்தைச் சமன்படுத்துவதற்காக சில நேரங்களில் சேர்க்கப்படுகின்றன. இதனால் யூனிக்ஸ் நேரம் விண்மீன் நேரத்துடன் சரியாக ஒத்திசையாது.

6. நேர மண்டல கருத்துக்கள்: யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் UTC-இல் தரப்படுகின்றன. உள்ளூர் நேரத்திற்கு மாற்றுவதற்கு கூடுதல் நேர மண்டலத் தகவலைப் பயன்படுத்த வேண்டும்.

7. நாள் மாறுதல் நேரம்: டைம் ஸ்டாம்ப்களை உள்ளூர் நேரத்திற்கு மாற்றும்போது, நாள் மாறுதல் நேரம் மாற்றங்களின் சிக்கல்களைப் பரிசீலிக்க வேண்டும்.

8. டைம் ஸ்டாம்ப் வடிவம் குழப்பம்: சரியான கண்டறிதலின் இல்லாமை, 13 இலக்க மில்லிசெக்குகள் (milliseconds) டைம் ஸ்டாம்ப், நொடிகள் அடிப்படையில் டைம் ஸ்டாம்ப் ஆகக் கருதப்பட்டால், மிகவும் தொலைவில் உள்ள எதிர்கால தேதியாக தவறாகக் குறிப்பிடப்படலாம். எங்கள் மாற்றி இதை இலக்கங்களின் நீளத்தின் அடிப்படையில் தானாகக் கண்டறிந்து தடுக்கும்.

பயன்பாட்டு வழிகள்

பல அளவுகளில் உள்ள யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் கணினி மற்றும் தரவுகள் மேலாண்மையில் பல்வேறு பயன்பாடுகளில் பயன்படுத்தப்படுகின்றன:

1. தரவுத்தொகுப்புகள்: டைம் ஸ்டாம்ப்கள் உள்ளீடுகள் எப்போது உருவாக்கப்பட்டன அல்லது திருத்தப்பட்டன என்பதைக் குறிப்பதற்கு பொதுவாகப் பயன்படுத்தப்படுகின்றன.

   • தரநிலையான டைம் ஸ்டாம்ப்கள் (10 இலக்கங்கள்) பொதுவான தரவுத்தொகுப்புப் பயன்பாடுகளுக்கு போதுமானது.
   • மில்லிசெக்குகள் (13 இலக்கங்கள்) நிகழ்வுகளை மேலும் துல்லியமாக வரிசைப்படுத்துவதற்கான தேவையைப் பூர்த்தி செய்யப் பயன்படுத்தப்படுகின்றன.

2. இணைய மேம்பாடு: HTTP தலைப்புகள், குக்கீகள் மற்றும் காசேற்ற முறைமைகள் பொதுவாக யூனிக்ஸ் டைம் ஸ்டாம்ப்களைப் பயன்படுத்துகின்றன.

   • JavaScript இல் Date.now() மில்லிசெக்குகள் (13 இலக்கங்கள்) தருகிறது.

3. பதிவு கோப்புகள்: அமைப்பு பதிவுகள் பொதுவாக நிகழ்வுகளை சரியான வரிசையில் பதிவு செய்ய யூனிக்ஸ் டைம் ஸ்டாம்ப்களைப் பதிவுசெய்கின்றன.

   • உயர்-அளவீட்டு பதிவு அமைப்புகள் மில்லிசெக்குகள் அல்லது மைக்ரோசெக்குகள் அளவீட்டை (16 இலக்கங்கள்) பயன்படுத்தலாம்.

4. பதிப்பு கட்டுப்பாட்டு முறைமைகள்: Git மற்றும் பிற VCS கள் கட்டுப்பாடுகள் எப்போது செய்யப்பட்டன என்பதைக் குறிப்பதற்காக டைம் ஸ்டாம்ப்களைப் பயன்படுத்துகின்றன.

5. API பதில்கள்: பல இணைய API கள் தரவுகளை உருவாக்கிய நேரம் அல்லது வளங்கள் கடைசி முறை மாற்றப்பட்ட நேரத்தை குறிக்க டைம் ஸ்டாம்ப்களைப் 포함ிக்கின்றன.

   • REST API கள் பொதுவாக மில்லிசெக்குகள் (13 இலக்கங்கள்) டைம் ஸ்டாம்ப்களைப் பயன்படுத்துகின்றன.

6. கோப்பு அமைப்புகள்: கோப்பு உருவாக்க மற்றும் திருத்த நேரங்கள் பொதுவாக யூனிக்ஸ் டைம் ஸ்டாம்ப்களாக சேமிக்கப்படுகின்றன.

7. அறிக்கையாளர் மேலாண்மை: இணைய பயன்பாடுகள் பயனர் அறிக்கைகள் எப்போது காலாவதியாக வேண்டும் என்பதைக் கண்டறிய டைம் ஸ்டாம்ப்களைப் பயன்படுத்துகின்றன.

8. தரவுத்தொகுப்பு பகுப்பாய்வு: டைம் ஸ்டாம்ப்கள் பகுப்பாய்வு பயன்பாடுகளில் காலநிலை தரவுகளைப் பயன்படுத்துவதற்கான ஒரு தரநிலையான வழியை வழங்குகின்றன.

9. உயர்-அளவீட்டு வர்த்தகம்: நிதி அமைப்புகள் மைக்ரோசெக்குகள் (16 இலக்கங்கள்) அளவீட்டை (1,000,000வது ஒரு நொடி) தேவையாகக் கொண்டுள்ளன.

10. அறிவியல் அளவீடுகள்: ஆராய்ச்சி உபகரணங்கள் மைக்ரோசெக்குகள் அளவீட்டுடன் (16 இலக்கங்கள்) கவனிப்புகளை பதிவு செய்யும் போது துல்லியமான கால அளவீட்டிற்காக தேவைப்படுகிறது.

மாற்றுகள்

யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் பரவலாகப் பயன்படுத்தப்படுவதற்கான பல மாற்று நேர பிரதிநிதித்துவ வடிவங்கள் உள்ளன, அவை சில சூழ்நிலைகளில் மேலும் பொருத்தமாக இருக்கலாம்:

1. ISO 8601: ஒரு தரநிலையான சரம் வடிவம் (உதாரணம்: "2021-01-01T00:00:00Z") இது மனிதனுக்கு வாசிக்கக்கூடியதாகவும், வரிசைப்படுத்துவதற்கானது. தரவுகள் பரிமாற்றம் மற்றும் பயனர் முகப்புப் பயன்பாடுகளுக்காக அதிகமாகக் கையாளப்படுகிறது.

2. RFC 3339: இணைய செயல்முறைகளில் பயன்படுத்தப்படும் ISO 8601 இன் ஒரு சுயமாக்கப்பட்ட வடிவம், அதில் கடுமையான வடிவமைப்பு தேவைகள் உள்ளன.

3. மனிதனுக்கு வாசிக்கக்கூடிய வடிவங்கள்: உள்ளூர் தேதிகள் (உதாரணம்: "ஜனவரி 1, 2021") நேரடியாக பயனர் தொடர்புக்கு மிகவும் பொருத்தமாக இருப்பினும், கணக்கீடுகளுக்கு மிகச் சரியானது அல்ல.

4. மைக்ரோசாஃப்ட் FILETIME: 1601 ஜனவரி 1 முதல் கடந்த 100-நானோசெக்குகளைக் குறிக்கும் 64-பிட் மதிப்பு, விண்டோஸ் அமைப்புகளில் பயன்படுத்தப்படுகிறது.

5. ஜூலியன் நாள் எண்: விண்மீன் மற்றும் சில அறிவியல் பயன்பாடுகளில் பயன்படுத்தப்படும், BC 4713 ஜனவரி 1 முதல் நாட்களை எண்ணுகிறது.

நேர வடிவத்தின் தேர்வு பல காரணிகளைப் பொறுத்தது:

• தேவையான அளவீடு
• மனித வாசிப்பு தேவைகள்
• சேமிப்பு வரம்புகள்
• ஏற்கனவே உள்ள அமைப்புகளுடன் ஏற்பாடு
• பிரதிநிதித்துவம் செய்ய வேண்டிய தேதிகளின் வரம்பு

வரலாறு

யூனிக்ஸ் நேரத்தின் கருத்து 1960 களின் இறுதியில் மற்றும் 1970 களின் ஆரம்பத்தில் பெல் லாப்ஸ் இல் யூனிக்ஸ் செயல்முறைமையின் மேம்பாட்டுடன் தோன்றியது. எபொக்காக 1970 ஜனவரி 1 ஐப் பயன்படுத்துவதற்கான முடிவு சிலwhat கற்பனை இருந்தது, ஆனால் காலத்திற்கேற்ப சேமிப்பு தேவைகளை குறைக்கவும், ஆனால் வரலாற்று தரவுகளுக்குப் பயன்படும்.

முதன்மை செயல்பாட்டில் 32-பிட் கையெழுத்தான முழு எண்களைப் பயன்படுத்தி நொடிகளை (seconds) சேமிக்க முடிவு செய்யப்பட்டு, இது யூனிக்ஸ் அமைப்புகளின் எதிர்பார்க்கப்பட்ட ஆயுளுக்காக போதுமானது. இருப்பினும், இந்த முடிவு 2038 ஆண்டின் பிரச்சனைக்கு (Y2K38 அல்லது யூனிக்ஸ் மில்லேனியம் பக்) வழிவகுத்தது, ஏனெனில் 32-பிட் கையெழுத்தான முழு எண்கள் 1970 முதல் 2038 வரை உள்ள தேதிகளை மட்டுமே பிரதிநிதித்துவம் செய்யக்கூடியதாக இருக்கும்.

யூனிக்ஸ் மற்றும் யூனிக்ஸ் போன்ற செயல்முறைகள் பிரபலமாக மாறும்போது, யூனிக்ஸ் டைம் ஸ்டாம்ப் கணினியில் நேரத்தை பிரதிநிதித்துவம் செய்ய ஒரு பாணியாக மாறியது. இது பல நிரலாக்க மொழிகள், தரவுத்தொகுப்புகள் மற்றும் பயன்பாடுகளில் ஏற்கனவே உள்ள அமைப்புகளால் ஏற்கப்பட்டது, இது அதன் முதன்மை சூழ்நிலையை முந்தையதாகக் காட்டுகிறது.

இன்றைய அமைப்புகள் பெரும்பாலும் 64-பிட் முழு எண்களை டைம் ஸ்டாம்ப்களுக்கு பயன்படுத்துகின்றன, இது எபொக்கின் முன் மற்றும் பின்னால் 292 பில்லியன் ஆண்டுகள் வரை பிரதிநிதித்துவம் செய்யக்கூடியதாக உள்ளது, இது 2038 ஆண்டின் பிரச்சனைக்கு தீர்வாகும். எனினும், பழைய அமைப்புகள் மற்றும் பயன்பாடுகள் இன்னும் பாதிக்கப்படலாம்.

யூனிக்ஸ் டைம் ஸ்டாம்பின் எளிமை மற்றும் பயன்பாடு அதன் தொடர்ந்த முக்கியத்துவத்தை உறுதி செய்துள்ளது, மேலும் இது மேலும் சிக்கலான நேர பிரதிநிதித்துவ வடிவங்களை மேம்படுத்தியுள்ளது. இது கணினி உலகில் ஒரு அடிப்படையான கருத்தாகவே உள்ளது, எங்கள் டிஜிட்டல் அடிப்படையை ஆதரிக்கிறது.

குறியீட்டு எடுத்துக்காட்டுகள்

பல அளவுகளில் உள்ள யூனிக்ஸ் டைம் ஸ்டாம்ப்களை மனிதனுக்கு வாசிக்கக்கூடிய தேதிகளாக மாற்றுவதற்கான எடுத்துக்காட்டுகள்:

1// யாவும் யூனிக்ஸ் டைம் ஸ்டாம்ப் மாற்றம் தானாகக் கண்டறிதல்
2function convertTimestamp(timestamp, use12Hour = false) {
3  // எண்ணிக்கையால் மாற்றவும்
4  const numericTimestamp = Number(timestamp);
5  
6  // இலக்க நீளத்தின் அடிப்படையில் டைம் ஸ்டாம்ப் வடிவத்தை கண்டறிதல்
7  let date;
8  if (timestamp.length === 16) {
9    // மைக்ரோசெக்குகள் (1,000,000 க்கு வகுக்கவும்)
10    date = new Date(numericTimestamp / 1000);
11    console.log("கண்டறிக்கப்பட்டது: மைக்ரோசெக்குகள் (16 இலக்கங்கள்)");
12  } else if (timestamp.length === 13) {
13    // மில்லிசெக்குகள்
14    date = new Date(numericTimestamp);
15    console.log("கண்டறிக்கப்பட்டது: மில்லிசெக்குகள் (13 இலக்கங்கள்)");
16  } else if (timestamp.length === 10) {
17    // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)
18    date = new Date(numericTimestamp * 1000);
19    console.log("கண்டறிக்கப்பட்டது: தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)");
20  } else {
21    throw new Error("தவறான டைம் ஸ்டாம்ப் வடிவம். 10, 13 அல்லது 16 இலக்கங்களை எதிர்பார்க்கிறேன்.");
22  }
23  
24  // வடிவமைப்பு விருப்பங்கள்
25  const options = {
26    year: 'numeric',
27    month: 'long',
28    day: 'numeric',
29    weekday: 'long',
30    hour: use12Hour ? 'numeric' : '2-digit',
31    minute: '2-digit',
32    second: '2-digit',
33    hour12: use12Hour
34  };
35  
36  // உள்ளூர் வடிவமைப்பைப் பயன்படுத்தி சரியாக மாற்றவும்
37  return date.toLocaleString(undefined, options);
38}
39
40// எடுத்துக்காட்டு பயன்பாடு
41try {
42  // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (10 இலக்கங்கள்)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // மில்லிசெக்குகள் (13 இலக்கங்கள்)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // மைக்ரோசெக்குகள் (16 இலக்கங்கள்)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# பைதான் டைம் ஸ்டாம்ப் மாற்றம் தானாகக் கண்டறிதல்
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # முழுமையாக எண்செய்யவும்
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # இலக்க நீளத்தின் அடிப்படையில் டைம் ஸ்டாம்ப் வடிவத்தை கண்டறிதல்
10    if len(timestamp) == 16:
11        # மைக்ரோசெக்குகள் (1,000,000 க்கு வகுக்கவும்)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("கண்டறிக்கப்பட்டது: மைக்ரோசெக்குகள் (16 இலக்கங்கள்)")
14    elif len(timestamp) == 13:
15        # மில்லிசெக்குகள் (1,000 க்கு வகுக்கவும்)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("கண்டறிக்கப்பட்டது: மில்லிசெக்குகள் (13 இலக்கங்கள்)")
18    elif len(timestamp) == 10:
19        # தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("கண்டறிக்கப்பட்டது: தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)")
22    else:
23        raise ValueError("தவறான டைம் ஸ்டாம்ப் வடிவம். 10, 13 அல்லது 16 இலக்கங்களை எதிர்பார்க்கிறேன்.")
24    
25    # தேதியின் சரியாக வடிவமைத்தல்
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-மணி வடிவம் AM/PM உடன்
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-மணி வடிவம்
30    
31    return date.strftime(format_string)
32
33# எடுத்துக்காட்டு பயன்பாடு
34try:
35    # தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (10 இலக்கங்கள்)
36    print(convert_timestamp("1609459200", False))
37    
38    # மில்லிசெக்குகள் (13 இலக்கங்கள்)
39    print(convert_timestamp("1609459200000", False))
40    
41    # மைக்ரோசெக்குகள் (16 இலக்கங்கள்)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// பிஎச்‌பி டைம் ஸ்டாம்ப் மாற்றம் தானாகக் கண்டறிதல்
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // உள்நுழைவைக் களவிடு
5    $timestamp = trim((string)$timestamp);
6    
7    // இலக்க நீளத்தின் அடிப்படையில் டைம் ஸ்டாம்ப் வடிவத்தை கண்டறிதல்
8    if (strlen($timestamp) === 16) {
9        // மைக்ரோசெக்குகள் (1,000,000 க்கு வகுக்கவும்)
10        $seconds = $numericTimestamp / 1000000;
11        echo "கண்டறிக்கப்பட்டது: மைக்ரோசெக்குகள் (16 இலக்கங்கள்)\n";
12    } elseif (strlen($timestamp) === 13) {
13        // மில்லிசெக்குகள் (1,000 க்கு வகுக்கவும்)
14        $seconds = $numericTimestamp / 1000;
15        echo "கண்டறிக்கப்பட்டது: மில்லிசெக்குகள் (13 இலக்கங்கள்)\n";
16    } elseif (strlen($timestamp) === 10) {
17        // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)
18        $seconds = $numericTimestamp;
19        echo "கண்டறிக்கப்பட்டது: தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)\n";
20    } else {
21        throw new Exception("தவறான டைம் ஸ்டாம்ப் வடிவம். 10, 13 அல்லது 16 இலக்கங்களை எதிர்பார்க்கிறேன்.");
22    }
23    
24    // வடிவமைப்பு
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // 12-மணி வடிவம் AM/PM உடன்
27        : 'l, F j, Y H:i:s';   // 24-மணி வடிவம்
28    
29    // தேதியை மாற்றவும்
30    return date($formatString, $seconds);
31}
32
33// எடுத்துக்காட்டு பயன்பாடு
34try {
35    // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (10 இலக்கங்கள்)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // மில்லிசெக்குகள் (13 இலக்கங்கள்)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // மைக்ரோசெக்குகள் (16 இலக்கங்கள்)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// ஜாவா டைம் ஸ்டாம்ப் மாற்றம் தானாகக் கண்டறிதல்
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class TimestampConverter {
8    public static String convertTimestamp(String timestamp, boolean use12Hour) {
9        // உள்நுழைவைக் களவிடு
10        timestamp = timestamp.trim();
11        
12        // இலக்க நீளத்தின் அடிப்படையில் டைம் ஸ்டாம்ப் வடிவத்தை கண்டறிதல்
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // மைக்ரோசெக்குகள் (1,000,000 க்கு வகுக்கவும்)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // நானோசெக்குகளுக்கு மாற்றவும்
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("கண்டறிக்கப்பட்டது: மைக்ரோசெக்குகள் (16 இலக்கங்கள்)");
20        } else if (timestamp.length() == 13) {
21            // மில்லிசெக்குகள் (1,000 க்கு வகுக்கவும்)
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("கண்டறிக்கப்பட்டது: மில்லிசெக்குகள் (13 இலக்கங்கள்)");
26        } else if (timestamp.length() == 10) {
27            // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("கண்டறிக்கப்பட்டது: தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)");
32        } else {
33            throw new IllegalArgumentException("தவறான டைம் ஸ்டாம்ப் வடிவம். 10, 13 அல்லது 16 இலக்கங்களை எதிர்பார்க்கிறேன்.");
34        }
35        
36        // விருப்பத்திற்கேற்ப வடிவமைப்பாளர் உருவாக்கவும்
37        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
38            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
39        );
40        
41        // தேதியை வடிவமைக்கவும்
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (10 இலக்கங்கள்)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // மில்லிசெக்குகள் (13 இலக்கங்கள்)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // மைக்ரோசெக்குகள் (16 இலக்கங்கள்)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// C# டைம் ஸ்டாம்ப் மாற்றம் தானாகக் கண்டறிதல்
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // உள்நுழைவைக் களவிடு
9        timestamp = timestamp.Trim();
10        
11        // இலக்க நீளத்தின் அடிப்படையில் டைம் ஸ்டாம்ப் வடிவத்தை கண்டறிதல்
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // மைக்ரோசெக்குகள் (1,000,000 க்கு வகுக்கவும்)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("தவறான டைம் ஸ்டாம்ப் வடிவம்");
18                
19            // மைக்ரோசெக்குகளை DateTime ஆக மாற்றவும்
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("கண்டறிக்கப்பட்டது: மைக்ரோசெக்குகள் (16 இலக்கங்கள்)");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // மில்லிசெக்குகள் (1,000 க்கு வகுக்கவும்)
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("தவறான டைம் ஸ்டாம்ப் வடிவம்");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("கண்டறிக்கப்பட்டது: மில்லிசெக்குகள் (13 இலக்கங்கள்)");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("தவறான டைம் ஸ்டாம்ப் வடிவம்");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("கண்டறிக்கப்பட்டது: தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (நொடிகள்)");
40        }
41        else
42        {
43            throw new ArgumentException("தவறான டைம் ஸ்டாம்ப் வடிவம். 10, 13 அல்லது 16 இலக்கங்களை எதிர்பார்க்கிறேன்.");
44        }
45        
46        // 12-மணி அல்லது 24-மணி விருப்பத்திற்கு ஏற்ப வடிவமைப்பு
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-மணி வடிவம் AM/PM உடன்
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-மணி வடிவம்
50        
51        // வடிவமைக்கப்பட்ட தேதியை திருப்பவும்
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (10 இலக்கங்கள்)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // மில்லிசெக்குகள் (13 இலக்கங்கள்)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // மைக்ரோசெக்குகள் (16 இலக்கங்கள்)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

எட்ஜ் கேஸ்களை கையாளுதல்

பல அளவுகளில் உள்ள யூனிக்ஸ் டைம் ஸ்டாம்ப்களைப் பயன்படுத்தும் போது, எட்ஜ் கேஸ்களை சரியாகக் கையாள்வது முக்கியம். கீழே உள்ள எடுத்துக்காட்டில் முழுமையான எட்ஜ் கேஸ்களை கையாள்வது காணலாம்:

1// யாவும் யூனிக்ஸ் டைம் ஸ்டாம்ப் மாற்றம் முழுமையான எட்ஜ் கேஸ் கையாளுதல்
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // உள்நுழைவைக் களவிடு
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "தவறு: காலியாக அல்லது வரையறுக்கப்படாத டைம் ஸ்டாம்ப்";
6  }
7  
8  // இலக்கங்களைக் கண்டறியவும்
9  const timestampStr = String(timestamp).trim();
10  
11  // டைம் ஸ்டாம்ப் உள்ளடக்கியது என்பதைச் சரிபார்க்கவும்
12  if (!/^\d+$/.test(timestampStr)) {
13    return "தவறு: டைம் ஸ்டாம்ப் எண்களை மட்டும் உள்ளடக்கியிருக்க வேண்டும்";
14  }
15  
16  // வடிவத்தை கண்டறிதல்
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // மைக்ரோசெக்குகள்
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // மில்லிசெக்குகளுக்கு மாற்றவும்
23      console.log("மைக்ரோசெக்குகள் (16 இலக்கங்கள்) செயலாக்கம்");
24      
25      // தவறான தேதி சரிபார்க்கவும்
26      if (isNaN(date.getTime())) {
27        return "தவறு: தவறான மைக்ரோசெக்குகள் டைம் ஸ்டாம்ப்";
28      }
29    } else if (timestampStr.length === 13) {
30      // மில்லிசெக்குகள்
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("மில்லிசெக்குகள் (13 இலக்கங்கள்) செயலாக்கம்");
34      
35      // தவறான தேதி சரிபார்க்கவும்
36      if (isNaN(date.getTime())) {
37        return "தவறு: தவறான மில்லிசெக்குகள் டைம் ஸ்டாம்ப்";
38      }
39    } else if (timestampStr.length === 10) {
40      // தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப்
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("தரநிலையான டைம் ஸ்டாம்ப் (10 இலக்கங்கள்) செயலாக்கம்");
44      
45      // தவறான தேதி சரிபார்க்கவும்
46      if (isNaN(date.getTime())) {
47        return "தவறு: தவறான தரநிலையான டைம் ஸ்டாம்ப்";
48      }
49      
50      // Y2K38 பிரச்சனை சரிபார்க்கவும் (32-பிட் அமைப்புகளுக்காக)
51      const maxInt32 = 2147483647; // 32-பிட் கையெழுத்தான முழு எண்ணின் அதிகபட்ச மதிப்பு
52      if (seconds > maxInt32) {
53        console.warn("எச்சரிக்கை: டைம் ஸ்டாம்ப் 32-பிட் முழு எண்ணின் வரம்பை மீறுகிறது (Y2K38 பிரச்சனை)");
54      }
55    } else {
56      return "தவறு: தவறான டைம் ஸ்டாம்ப் நீளம். 10, 13 அல்லது 16 இலக்கங்களை எதிர்பார்க்கிறேன்.";
57    }
58    
59    // தேதியை வடிவமைத்தல்
60    const options = {
61      year: 'numeric',
62      month: 'long',
63      day: 'numeric',
64      weekday: 'long',
65      hour: use12Hour ? 'numeric' : '2-digit',
66      minute: '2-digit',
67      second: '2-digit',
68      hour12: use12Hour
69    };
70    
71    return date.toLocaleString(undefined, options);
72  } catch (error) {
73    return "டைம் ஸ்டாம்ப் மாற்றும் போது தவறு: " + error.message;
74  }
75}
76
77// பல எட்ஜ் கேஸ்களைச் சோதிக்கவும்
78console.log(safeConvertTimestamp("1609459200"));      // தரநிலையான (10 இலக்கங்கள்)
79console.log(safeConvertTimestamp("1609459200000"));   // மில்லிசெக்குகள் (13 இலக்கங்கள்)
80console.log(safeConvertTimestamp("1609459200000000")); // மைக்ரோசெக்குகள் (16 இலக்கங்கள்)
81console.log(safeConvertTimestamp("abc123"));          // எண் அல்ல
82console.log(safeConvertTimestamp("12345"));           // தவறான நீளம்
83console.log(safeConvertTimestamp("9999999999999999")); // மிகவும் பெரிய மைக்ரோசெக்குகள் டைம் ஸ்டாம்ப்
84console.log(safeConvertTimestamp(""));                // காலியான சரம்
85

அடிக்கடி கேட்கப்படும் கேள்விகள்

யூனிக்ஸ் டைம் ஸ்டாம்ப் என்ன?

யூனிக்ஸ் டைம் ஸ்டாம்ப் என்பது 1970 ஜனவரி 1 (மதியம் UTC/GMT) முதல் கடந்த நொடிகளை (seconds) குறிக்கிறது, எலிப் செக்குகளை கணக்கில் எடுத்துக்கொள்ளாமல். இது ஒரு குறிப்பிட்ட நேரத்தை அடிப்படையாகக் கொண்ட, மொழி சாராத, சுருக்கமான பிரதிநிதித்துவத்தை வழங்குகிறது.

தானாகக் கண்டறிதல் எப்படி வேலை செய்கிறது?

மாற்றி டைம் ஸ்டாம்ப் வடிவத்தை இலக்கங்களின் எண்ணிக்கையின் அடிப்படையில் தானாகவே கண்டறிகிறது:

• 10 இலக்கங்கள்: தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப் (எபொக்கில் இருந்து நொடிகள்)
• 13 இலக்கங்கள்: மில்லிசெக்குகள் (milliseconds)
• 16 இலக்கங்கள்: மைக்ரோசெக்குகள் (microseconds)

நான் மில்லிசெக்குகள் அல்லது மைக்ரோசெக்குகள் அளவீட்டை ஏன் தேவைப்படும்?

மில்லிசெக்குகள் (13 இலக்கங்கள்) அதிகமான துல்லியமான நேரத்தை தேவைப்படும் பயன்பாடுகளுக்கு பயனுள்ளதாக இருக்கிறது, அதாவது செயல்திறனை கண்காணிக்கும், பயனர் தொடர்புகளைப் பதிவு செய்யும் மற்றும் சில நிதி பயன்பாடுகள். மைக்ரோசெக்குகள் (16 இலக்கங்கள்) உயர் செயல்திறனைப் பெறும் கணினி, அறிவியல் பயன்பாடுகள் மற்றும் உயர் அளவீட்டு வர்த்தக அமைப்புகளுக்கு தேவையானது.

நான் 1970 க்கு முன்புள்ள தேதிகளை யூனிக்ஸ் டைம் ஸ்டாம்ப் மூலம் மாற்ற முடியுமா?

ஆம், 1970 ஜனவரி 1 க்கு முன்புள்ள தேதிகள் எதிர்மறை டைம் ஸ்டாம்ப்களால் பிரதிநிதித்துவம் செய்யப்படுகின்றன. இருப்பினும், சில அமைப்புகள் எதிர்மறை டைம் ஸ்டாம்ப்களை சரியாக கையாளவோ முடியாது, எனவே நீங்கள் இந்த செயல்பாட்டை சோதிக்க வேண்டும்.

2038 ஆண்டின் பிரச்சனை என்ன?

2038 ஆண்டின் பிரச்சனை 32-பிட் கையெழுத்தான முழு எண்களால் யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் பொதுவாக சேமிக்கப்படுவதால் ஏற்படுகிறது, இது 2038 ஜனவரி 19 அன்று ஓவர்ஃப்ளோ ஆகும். இந்த நேரத்திற்கு பிறகு, 32-பிட் அமைப்புகள் நேரங்களை சரியாக பிரதிநிதித்துவம் செய்ய முடியாது. நவீன அமைப்புகள் 64-பிட் முழு எண்களைப் பயன்படுத்துவதற்கு அதிகமாக மாறுகின்றன.

நான் யூனிக்ஸ் டைம் ஸ்டாம்ப்களை உள்ளூர் நேரத்திற்கு மாற்ற எப்படி?

யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் எப்போதும் UTC (மைய உலக நேரம்) இல் உள்ளன. உள்ளூர் நேரத்திற்கு மாற்றுவதற்கு, நீங்கள் டைம் ஸ்டாம்ப் மாற்றிய பிறகு சரியான நேர மண்டலத்தைப் பயன்படுத்த வேண்டும். பல நிரலாக்க மொழிகள் நேர மண்டல மாற்றங்களை கையாள்வதற்கான உள்ளமைவுகளை வழங்குகின்றன.

யூனிக்ஸ் நேரம் மற்றும் ISO 8601 இன் இடையிலான வேறுபாடு என்ன?

யூனிக்ஸ் நேரம் ஒரு எண்முறை பிரதிநிதித்துவம் (எபொக்கில் இருந்து நொடிகள்) ஆகும், ஆனால் ISO 8601 என்பது ஒரு சரம் வடிவம் (உதாரணம்: "2021-01-01T00:00:00Z"). யூனிக்ஸ் நேரம் கணக்கீடுகளுக்கு மிகவும் சுருக்கமாகவும் எளிதாகவும் இருக்கிறது, ஆனால் ISO 8601 மனிதனுக்கு வாசிக்கக்கூடியதாகவும், சுயவிவரமாகவும் உள்ளது.

யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் எவ்வளவு துல்லியமாக உள்ளன?

தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் நொடிகள் மட்டுமே அளவீடு செய்கின்றன. அதிகமான துல்லியத்தை தேவைப்படும் பயன்பாடுகளுக்கு, மில்லிசெக்குகள் (13 இலக்கங்கள்) 1/1000 நொடி அளவீட்டை வழங்குகின்றன, மேலும் மைக்ரோசெக்குகள் (16 இலக்கங்கள்) 1/1,000,000 நொடி அளவீட்டை வழங்குகின்றன.

யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் எலிப் செக்குகளை கணக்கில் எடுத்துக்கொள்கின்றனவா?

இல்லை, யூனிக்ஸ் நேரம் எலிப் செக்குகளை கணக்கில் எடுத்துக்கொள்வதில்லை, இது UTC-க்கு சரியான நேரத்தைச் சமன்படுத்துவதற்காக சில நேரங்களில் சேர்க்கப்படுகின்றன. இதனால் யூனிக்ஸ் நேரம் விண்மீன் நேரத்துடன் சரியாக ஒத்திசையாது.

நான் எதிர்கால நிகழ்வுகளை திட்டமிட யூனிக்ஸ் டைம் ஸ்டாம்ப்களைப் பயன்படுத்த முடியுமா?

ஆம், யூனிக்ஸ் டைம் ஸ்டாம்ப்கள் திட்டமிடுவதற்காக பரவலாகப் பயன்படுத்தப்படுகின்றன. இருப்பினும், மிகவும் தொலைவில் உள்ள எதிர்கால தேதிகளைப் பயன்படுத்தும்போது, 32-பிட் அமைப்புகளுக்கான 2038 ஆண்டின் பிரச்சனை மற்றும் நாள் மாறுதல் நேரம் மாற்றங்களின் சிக்கல்களைப் பரிசீலிக்க வேண்டும்.

மேற்கோள்கள்

1. "யூனிக்ஸ் நேரம்." விக்கிபீடியா, விக்கிமீடியா அறக்கட்டளை, https://en.wikipedia.org/wiki/Unix_time

2. "2038 ஆண்டின் பிரச்சனை." விக்கிபீடியா, விக்கிமீடியா அறக்கட்டளை, https://en.wikipedia.org/wiki/Year_2038_problem

3. ஒல்சன், ஆர்தர் டேவிட். "காலண்டர் நேரத்தின் சிக்கல்கள்." திறந்த குழு, https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601." விக்கிபீடியா, விக்கிமீடியா அறக்கட்டளை, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: இணையத்தில் தேதியும் நேரமும்: டைம் ஸ்டாம்ப்கள்." இணைய பொறியியல் பணியகம் (IETF), https://tools.ietf.org/html/rfc3339

6. கெர்னிகன், பிரையன் டபிள்யூ., மற்றும் டெனிஸ் எம். ரிச்சி. "C நிரலாக்க மொழி." பிரென்டிஸ் ஹால், 1988.

7. "உயர்-செயல்திறன் கணினியில் துல்லியமான நேரம்." ACM கணினி ஆய்வுகள், https://dl.acm.org/doi/10.1145/3232678

8. "நிதி அமைப்புகளில் நேர பிரதிநிதித்துவம்." நிதி தொழில்நுட்பம் இதழ், https://www.fintech-journal.com/time-representation

இப்போது எங்கள் டைம் ஸ்டாம்ப் மாற்றியைப் பயன்படுத்தி, எந்த அளவிலும் உள்ள யூனிக்ஸ் டைம் ஸ்டாம்ப்களை மனிதனுக்கு வாசிக்கக்கூடிய தேதிகளாக எளிதாக மாற்றுங்கள். தரநிலையான யூனிக்ஸ் டைம் ஸ்டாம்ப்கள், மில்லிசெக்குகள் அல்லது மைக்ரோசெக்குகள், எங்கள் கருவி தானாகவே வடிவத்தை கண்டறிந்து சரியான மாற்றங்களை வழங்குகிறது.