યુનિક્સ ટાઈમસ્ટેમ્પ કન્વર્ટર

પરિચય

યુનિક્સ ટાઈમસ્ટેમ્પ (જેને પોસિક સમય અથવા ઇપોચ સમય તરીકે પણ ઓળખવામાં આવે છે) સમયના એક બિંદુને વર્ણવવા માટેની એક પદ્ધતિ છે. તે 1 જાન્યુઆરી 1970 (મિડનાઇટ યુટીસી/જીીએમટી) થી પસાર થયેલા સેકંડોની સંખ્યા છે, લીપ સેકંડોને ગણતરીમાં ન લેતા. યુનિક્સ ટાઈમસ્ટેમ્પ કમ્પ્યુટર સિસ્ટમો અને પ્રોગ્રામિંગ ભાષાઓમાં વ્યાપકપણે ઉપયોગમાં લેવાય છે કારણ કે તે ચોક્કસ સમયના ક્ષણનું સંકુચિત, ભાષા-અસંબંધિત પ્રતિનિધિત્વ પ્રદાન કરે છે.

આ કન્વર્ટર તમને યુનિક્સ ટાઈમસ્ટેમ્પને માનવ-વાંચનક્ષમ તારીખ અને સમય ફોર્મેટમાં રૂપાંતરિત કરવાની મંજૂરી આપે છે. તે વિવિધ પ્રાદેશિક અને વ્યક્તિગત પસંદગીઓ માટે 12-કલાક (એએમ/પીએમ) અને 24-કલાક સમય ફોર્મેટ બંનેને સપોર્ટ કરે છે.

યુનિક્સ ટાઈમસ્ટેમ્પ કેવી રીતે કાર્ય કરે છે

યુનિક્સ ટાઈમસ્ટેમ્પ્સ યુનિક્સ ઇપોચ (1 જાન્યુઆરી 1970, 00:00:00 યુટીસી) થી પસાર થયેલા સેકંડોની સંખ્યા તરીકે ગણવામાં આવે છે. આ તેમને સમયના અંતરોની ગણના કરવા અને તારીખોને સંકુચિત ફોર્મેટમાં સંગ્રહિત કરવા માટે વિશેષરૂપે ઉપયોગી બનાવે છે.

યુનિક્સ ટાઈમસ્ટેમ્પને કેલેન્ડર તારીખમાં રૂપાંતરિત કરવા માટેની ગણિતીય રૂપાંતરણમાં અનેક પગલાંનો સમાવેશ થાય છે:

1. યુનિક્સ ઇપોચ (1 જાન્યુઆરી 1970, 00:00:00 યુટીસી) થી શરૂ કરો
2. ટાઈમસ્ટેમ્પમાં સેકંડોની સંખ્યા ઉમેરો
3. લીપ વર્ષો, વિવિધ મહિના લાંબાઈઓ અને અન્ય કેલેન્ડર જટિલતાઓને ધ્યાનમાં લો
4. જો જરૂર હોય તો સમય ઝોનના સમાયોજન લાગુ કરો

ઉદાહરણ તરીકે, યુનિક્સ ટાઈમસ્ટેમ્પ 1609459200 શુક્રવાર, 1 જાન્યુઆરી, 2021, 00:00:00 યુટીસીમાં પ્રતિનિધિત્વ કરે છે.

રૂપાંતરણ સૂત્ર આ રીતે વ્યક્ત કરી શકાય છે:

$\text{તારીખ} = \text{યુનિક્સ ઇપોચ} + \text{ટાઈમસ્ટેમ્પ (સેકંડમાં)}$

અધિકાંશ પ્રોગ્રામિંગ ભાષાઓ અને ઓપરેટિંગ સિસ્ટમો આ રૂપાંતરણને સંભાળવા માટે બિલ્ટ-ઇન કાર્ય પ્રદાન કરે છે, જટિલ કેલેન્ડર ગણનાઓને છુપાવીને.

સમય ફોર્મેટ વિકલ્પો

આ કન્વર્ટર બે સમય ફોર્મેટ વિકલ્પો પ્રદાન કરે છે:

1. 24-કલાક ફોર્મેટ (ક્યારેક "મિલિટરી સમય" તરીકે ઓળખાય છે): કલાકો 0 થી 23 વચ્ચે હોય છે, અને AM/PM નિર્દેશન નથી. ઉદાહરણ તરીકે, 3:00 PM ને 15:00 તરીકે દર્શાવવામાં આવે છે.

2. 12-કલાક ફોર્મેટ: કલાકો 1 થી 12 વચ્ચે હોય છે, મધ્યરાતથી બપોર સુધીના સમય માટે AM (એન્ટે મેરિડિયમ) અને બપોરથી મધ્યરાત સુધીના સમય માટે PM (પોસ્ટ મેરિડિયમ) હોય છે. ઉદાહરણ તરીકે, 24-કલાક ફોર્મેટમાં 15:00 ને 3:00 PM તરીકે દર્શાવવામાં આવે છે.

આ ફોર્મેટ્સ વચ્ચેની પસંદગી મોટા ભાગે પ્રાદેશિક પરંપરા અને વ્યક્તિગત પસંદગીઓ પર આધારિત છે:

• 24-કલાક ફોર્મેટનો ઉપયોગ યુરોપ, લેટિન અમેરિકાના મોટા ભાગે અને એશિયામાં થાય છે, તેમજ વૈશ્વિક વૈજ્ઞાનિક, સૈનિક અને તબીબી સંદર્ભોમાં.
• 12-કલાક ફોર્મેટ યુનાઇટેડ સ્ટેટ્સ, કેનેડા, ઓસ્ટ્રેલિયા અને અન્ય કેટલાક અંગ્રેજી બોલતા દેશોમાં રોજિંદા ઉપયોગ માટે વ્યાપક છે.

કિનારા કેસો અને મર્યાદાઓ

યુનિક્સ ટાઈમસ્ટેમ્પ્સ સાથે કામ કરતી વખતે, કેટલાક કિનારા કેસો અને મર્યાદાઓને ધ્યાનમાં રાખવું મહત્વપૂર્ણ છે:

1. ઋણાત્મક ટાઈમસ્ટેમ્પ્સ: આ યુનિક્સ ઇપોચ (1 જાન્યુઆરી 1970) પહેલાંની તારીખોને દર્શાવે છે. જ્યારે આ ગણિતીય રીતે માન્ય હોય છે, કેટલાક સિસ્ટમો ઋણાત્મક ટાઈમસ્ટેમ્પ્સને યોગ્ય રીતે સંભાળતા નથી.

2. વર્ષ 2038 સમસ્યા: યુનિક્સ ટાઈમસ્ટેમ્પ્સ સામાન્ય રીતે 32-બિટ સહીવાળા પૂર્ણાંક તરીકે સંગ્રહિત કરવામાં આવે છે, જે 19 જાન્યુઆરી 2038ના રોજ ઓવરફ્લો થશે. આ બિંદુ પછી, 32-બિટ સિસ્ટમો યોગ્ય રીતે સમયને પ્રતિનિધિત્વ કરવા માટે અસમર્થ રહેશે, જો તે મોટા પૂર્ણાંક પ્રકારનો ઉપયોગ કરવા માટે સુધારવામાં ન આવે.

3. અતિ મોટાં ટાઈમસ્ટેમ્પ્સ: ખૂબ જ દૂરના ભવિષ્યના તારીખો કેટલાક સિસ્ટમોમાં પ્રતિનિધિત્વ કરી શકાતાં નથી, અથવા અસંગત રીતે સંભાળવામાં આવી શકે છે.

4. લીપ સેકંડ્સ: યુનિક્સ સમય લીપ સેકંડ્સને ધ્યાનમાં લેતા નથી, જે યુટીસી સાથે ધરતીના અનિયમિત ગતિને સમાયોજિત કરવા માટે ક્યારેક ઉમેરવામાં આવે છે. આનો અર્થ એ છે કે યુનિક્સ સમય ખગોળીય સમય સાથે ચોક્કસ રીતે સમન્વયિત નથી.

5. સમય ઝોનના વિચાર: યુનિક્સ ટાઈમસ્ટેમ્પ્સ ક્ષણોને યુટીસીમાં પ્રતિનિધિત્વ કરે છે. સ્થાનિક સમયમાં રૂપાંતર કરવા માટે વધારાના સમય ઝોનની માહિતીની જરૂર છે.

6. ડેઇલાઇટ સેવિંગ ટાઈમ: ટાઈમસ્ટેમ્પ્સને સ્થાનિક સમયમાં રૂપાંતર કરતી વખતે, ડેઇલાઇટ સેવિંગ ટાઈમના પરિવર્તનોની જટિલતાઓને ધ્યાનમાં લેવું જરૂરી છે.

ઉપયોગના કેસ

યુનિક્સ ટાઈમસ્ટેમ્પ્સ કમ્પ્યુટિંગ અને ડેટા વ્યવસ્થાપનમાં અનેક એપ્લિકેશન્સમાં ઉપયોગમાં લેવાય છે:

1. ડેટાબેસ રેકોર્ડ્સ: ટાઈમસ્ટેમ્પ્સ સામાન્ય રીતે એ નોંધ કરવા માટે ઉપયોગમાં લેવાય છે કે પ્રવેશો ક્યારે બનાવવામાં આવ્યા અથવા સુધારવામાં આવ્યા.

2. વેબ વિકાસ: HTTP હેડર્સ, કૂકીઝ અને કેશિંગ મિકેનિઝમો ઘણીવાર યુનિક્સ ટાઈમસ્ટેમ્પ્સનો ઉપયોગ કરે છે.

3. લોગ ફાઇલો: સિસ્ટમ લોગ્સ સામાન્ય રીતે ઘટનાઓને ચોક્કસ ક્રમમાં નોંધવા માટે યુનિક્સ ટાઈમસ્ટેમ્પ્સ સાથે નોંધ લે છે.

4. વર્ષ નિયંત્રણ સિસ્ટમો: Git અને અન્ય VCS ટાઈમસ્ટેમ્પ્સનો ઉપયોગ કરે છે જે નોંધણી ક્યારે કરવામાં આવી હતી તે નોંધવા માટે.

5. એપીઆઈ પ્રતિસાદ: ઘણા વેબ એપીઆઈ તેમના પ્રતિસાદમાં ટાઈમસ્ટેમ્પ્સનો સમાવેશ કરે છે જે દર્શાવે છે કે ડેટા ક્યારે ઉત્પન્ન થયું અથવા સંસાધનો ક્યારે છેલ્લે સુધારવામાં આવ્યા.

6. ફાઇલ સિસ્ટમો: ફાઇલ બનાવવાની અને સુધારવાની સમયને સામાન્ય રીતે યુનિક્સ ટાઈમસ્ટેમ્પ્સ તરીકે સંગ્રહિત કરવામાં આવે છે.

7. સત્ર વ્યવસ્થાપન: વેબ એપ્લિકેશન્સ યુનિક્સ ટાઈમસ્ટેમ્પ્સનો ઉપયોગ કરે છે જે દર્શાવે છે કે વપરાશકર્તા સત્રો ક્યારે સમાપ્ત થવા જોઈએ.

8. ડેટા વિશ્લેષણ: ટાઈમસ્ટેમ્પ્સ વિશ્લેષણ એપ્લિકેશન્સમાં સમયના ડેટા સાથે કામ કરવા માટે એક માનક રીત પ્રદાન કરે છે.

વિકલ્પો

યુનિક્સ ટાઈમસ્ટેમ્પ્સ વ્યાપકપણે ઉપયોગમાં લેવાય છે, પરંતુ કેટલાક સંદર્ભોમાં વધુ યોગ્યતા ધરાવતા સમય પ્રતિનિધિત્વ ફોર્મેટ્સ છે:

1. આઇએસઓ 8601: એક માનક સ્ટ્રિંગ ફોર્મેટ (ઉદાહરણ તરીકે, "2021-01-01T00:00:00Z") જે માનવ-વાંચનક્ષમ છે જ્યારે સોર્ટેબિલિટી જાળવી રાખે છે. ડેટા વિનિમય અને વપરાશકર્તા-સામનો એપ્લિકેશન્સ માટે આ સામાન્ય રીતે પસંદ કરવામાં આવે છે.

2. RFC 3339: ઇન્ટરનેટ પ્રોટોકોલ્સમાં ઉપયોગમાં લેવાતી આઇએસઓ 8601 ની એક પ્રોફાઇલ, જે કડક ફોર્મેટિંગની આવશ્યકતાઓ ધરાવે છે.

3. માનવ-વાંચનક્ષમ ફોર્મેટ્સ: સ્થાનિકીકૃત તારીખની સ્ટ્રિંગ્સ (ઉદાહરણ તરીકે, "જાન્યુઆરી 1, 2021") સીધી વપરાશકર્તા ક્રિયાપ્રતિક્રિયા માટે વધુ યોગ્ય છે પરંતુ ગણનાના માટે ઓછા યોગ્ય છે.

4. માઇક્રોસોફ્ટ ફાઇલટાઇમ: 64-બિટ મૂલ્ય જે 1601-01-01 થી 100-નાનો સેકંડના અંતરનું પ્રતિનિધિત્વ કરે છે, જે વિન્ડોઝ સિસ્ટમોમાં ઉપયોગમાં લેવાય છે.

5. જુલિયન દિવસ નંબર: ખગોળશાસ્ત્ર અને કેટલાક વૈજ્ઞાનિક એપ્લિકેશન્સમાં ઉપયોગમાં લેવાય છે, 4713 BCE થી દિવસોની ગણતરી કરે છે.

સમય ફોર્મેટની પસંદગીનો આધાર વિવિધ પરિબળો પર આધારિત છે જેમ કે:

• જરૂરી ચોકસાઈ
• માનવ વાંચનક્ષમતા જરૂરિયાતો
• સંગ્રહ મર્યાદાઓ
• અસ્તિત્વમાં રહેલા સિસ્ટમો સાથે સુસંગતતા
• પ્રતિનિધિત્વ કરવાની જરૂરિયાત ધરાવતી તારીખોની શ્રેણી

ઇતિહાસ

યુનિક્સ સમયની સંકલ્પના યુનિક્સ ઓપરેટિંગ સિસ્ટમના વિકાસ સાથે બેલ લેબ્સમાં 1960 અને 1970ના દાયકામાં ઉદ્ભવી. ઇપોચ તરીકે 1 જાન્યુઆરી 1970 ને પસંદ કરવાનો નિર્ણય થોડો અનિયમિત હતો પરંતુ સમય માટે વ્યાવહારિક હતો—તે રસપ્રદ તારીખો માટે સંગ્રહ જરૂરિયાતોને ઓછું કરવા માટે તાજેતરમાં હતું પરંતુ ઐતિહાસિક ડેટા માટે ઉપયોગી બનવા માટે પૂરતું દૂર હતું.

મૂળ અમલમાં 32-બિટ સહીવાળા પૂર્ણાંકનો ઉપયોગ કરીને સેકંડોની સંખ્યા સંગ્રહિત કરવામાં આવી, જે તે સમયે યુનિક્સ સિસ્ટમ્સની અપેક્ષિત આયુષ્ય માટે પૂરતી હતી. પરંતુ આ નિર્ણય વર્ષ 2038 સમસ્યાને જન્મ આપ્યો (ક્યારેક "Y2K38" અથવા "યુનિક્સ મિલેનિયમ બગ" તરીકે ઓળખાય છે), કારણ કે 32-બિટ સહીવાળા પૂર્ણાંક 1 જાન્યુઆરી 2038 (03:14:07 યુટીસી) સુધીની તારીખોને જ પ્રતિનિધિત્વ કરી શકે છે.

યુનિક્સ અને યુનિક્સ જેવા ઓપરેટિંગ સિસ્ટમોનો લોકપ્રિયતા વધતા જતા યુનિક્સ ટાઈમસ્ટેમ્પ એક અસલ ધોરણ તરીકે વિકસિત થયો. તે અનેક પ્રોગ્રામિંગ ભાષાઓ, ડેટાબેસ અને એપ્લિકેશન્સ દ્વારા અપનાવવામાં આવ્યો, જે તેના મૂળ યુનિક્સ પર્યાવરણથી આગળ વધીને.

આધુનિક સિસ્ટમો increasingly 64-બિટ પૂર્ણાંક ટાઈમસ્ટેમ્પ્સનો ઉપયોગ કરે છે, જે ઇપોચથી લગભગ 292 અબજ વર્ષ સુધીના પ્રતિનિધિત્વની શ્રેણી વિસ્તૃત કરે છે, જે વર્ષ 2038ની સમસ્યાને અસરકારક રીતે ઉકેલે છે. જોકે, વારસાગત સિસ્ટમો અને એપ્લિકેશન્સ હજુ પણ જોખમમાં હોઈ શકે છે.

યુનિક્સ ટાઈમસ્ટેમ્પની સરળતા અને ઉપયોગિતા તેની સતત સંબંધિતતાને સુનિશ્ચિત કરે છે, વધુ વિકસિત સમય પ્રતિનિધિત્વ ફોર્મેટ્સની વિકાસના બાવજૂત. તે કમ્પ્યુટિંગમાં એક મૂળભૂત સંકલ્પના તરીકે રહે છે, જે અમારી ડિજિટલ ઇન્ફ્રાસ્ટ્રક્ચરના ઘણાં ભાગોને આધાર આપે છે.

કોડ ઉદાહરણો

અહીં વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં યુનિક્સ ટાઈમસ્ટેમ્પને માનવ-વાંચનક્ષમ તારીખોમાં રૂપાંતરિત કરવાની ઉદાહરણો છે:

1// જાવાસ્ક્રિપ્ટ ટાઈમસ્ટેમ્પ રૂપાંતરણ
2function convertUnixTimestamp(timestamp, use12Hour = false) {
3  // નવી તારીખની વસ્તુ બનાવો (જાવાસ્ક્રિપ્ટ મિલિસેકન્ડ્સનો ઉપયોગ કરે છે)
4  const date = new Date(timestamp * 1000);
5  
6  // ફોર્મેટ વિકલ્પો
7  const options = {
8    year: 'numeric',
9    month: 'long',
10    day: 'numeric',
11    weekday: 'long',
12    hour: use12Hour ? 'numeric' : '2-digit',
13    minute: '2-digit',
14    second: '2-digit',
15    hour12: use12Hour
16  };
17  
18  // લોકલ ફોર્મેટિંગનો ઉપયોગ કરીને સ્ટ્રિંગમાં રૂપાંતરિત કરો
19  return date.toLocaleString(undefined, options);
20}
21
22// ઉદાહરણ ઉપયોગ
23const timestamp = 1609459200; // 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
24console.log(convertUnixTimestamp(timestamp, false)); // 24-કલાક ફોર્મેટ
25console.log(convertUnixTimestamp(timestamp, true));  // 12-કલાક ફોર્મેટ
26

1# પાયથન ટાઈમસ્ટેમ્પ રૂપાંતરણ
2import datetime
3
4def convert_unix_timestamp(timestamp, use_12hour=False):
5    # યુનિક્સ ટાઈમસ્ટેમ્પને datetime વસ્તુમાં રૂપાંતરિત કરો
6    date = datetime.datetime.fromtimestamp(timestamp)
7    
8    # તારીખની સ્ટ્રિંગ ફોર્મેટ
9    if use_12hour:
10        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-કલાક ફોર્મેટ AM/PM સાથે
11    else:
12        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-કલાક ફોર્મેટ
13    
14    return date.strftime(format_string)
15
16# ઉદાહરણ ઉપયોગ
17timestamp = 1609459200  # 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
18print(convert_unix_timestamp(timestamp, False))  # 24-કલાક ફોર્મેટ
19print(convert_unix_timestamp(timestamp, True))   # 12-કલાક ફોર્મેટ
20

1<?php
2// પીએચપી ટાઈમસ્ટેમ્પ રૂપાંતરણ
3function convertUnixTimestamp($timestamp, $use12Hour = false) {
4    // ફોર્મેટ સ્ટ્રિંગ
5    $formatString = $use12Hour 
6        ? 'l, F j, Y g:i:s A'  // 12-કલાક ફોર્મેટ AM/PM સાથે
7        : 'l, F j, Y H:i:s';   // 24-કલાક ફોર્મેટ
8    
9    // રૂપાંતરિત અને ફોર્મેટ કરો
10    return date($formatString, $timestamp);
11}
12
13// ઉદાહરણ ઉપયોગ
14$timestamp = 1609459200; // 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
15echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-કલાક ફોર્મેટ
16echo convertUnixTimestamp($timestamp, true) . "\n";  // 12-કલાક ફોર્મેટ
17?>
18

1// જાવા ટાઈમસ્ટેમ્પ રૂપાંતરણ
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class UnixTimestampConverter {
8    public static String convertUnixTimestamp(long timestamp, boolean use12Hour) {
9        // યુનિક્સ ટાઈમસ્ટેમ્પને ઇન્સ્ટન્ટમાં રૂપાંતરિત કરો, પછી સ્થાનિક તારીખ અને સમયમાં
10        Instant instant = Instant.ofEpochSecond(timestamp);
11        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
12        
13        // ઇચ્છિત ફોર્મેટના આધારે ફોર્મેટર બનાવો
14        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
15            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
16        );
17        
18        // તારીખને ફોર્મેટ કરો
19        return dateTime.format(formatter);
20    }
21    
22    public static void main(String[] args) {
23        long timestamp = 1609459200; // 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
24        System.out.println(convertUnixTimestamp(timestamp, false)); // 24-કલાક ફોર્મેટ
25        System.out.println(convertUnixTimestamp(timestamp, true));  // 12-કલાક ફોર્મેટ
26    }
27}
28

1// C# ટાઈમસ્ટેમ્પ રૂપાંતરણ
2using System;
3
4class UnixTimestampConverter
5{
6    public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
7    {
8        // યુનિક્સ ટાઈમસ્ટેમ્પને તારીખ અને સમયમાં રૂપાંતરિત કરો
9        // યુનિક્સ ટાઈમસ્ટેમ્પ 1970-01-01 થી સેકંડ છે
10        DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
11        
12        // 12-કલાક અથવા 24-કલાક પસંદગીને આધારે ફોર્મેટ સ્ટ્રિંગ
13        string formatString = use12Hour 
14            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-કલાક ફોર્મેટ AM/PM સાથે
15            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-કલાક ફોર્મેટ
16        
17        // ફોર્મેટ કરેલ તારીખને પાછું આપો
18        return dateTime.ToString(formatString);
19    }
20    
21    static void Main()
22    {
23        long timestamp = 1609459200; // 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
24        Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-કલાક ફોર્મેટ
25        Console.WriteLine(ConvertUnixTimestamp(timestamp, true));  // 12-કલાક ફોર્મેટ
26    }
27}
28

1# રૂબી ટાઈમસ્ટેમ્પ રૂપાંતરણ
2require 'time'
3
4def convert_unix_timestamp(timestamp, use_12hour = false)
5  # યુનિક્સ ટાઈમસ્ટેમ્પને સમયની વસ્તુમાં રૂપાંતરિત કરો
6  time = Time.at(timestamp)
7  
8  # 12-કલાક અથવા 24-કલાક પસંદગીને આધારે ફોર્મેટ
9  if use_12hour
10    time.strftime("%A, %B %d, %Y %I:%M:%S %p")  # 12-કલાક ફોર્મેટ AM/PM સાથે
11  else
12    time.strftime("%A, %B %d, %Y %H:%M:%S")     # 24-કલાક ફોર્મેટ
13  end
14end
15
16# ઉદાહરણ ઉપયોગ
17timestamp = 1609459200  # 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
18puts convert_unix_timestamp(timestamp, false)  # 24-કલાક ફોર્મેટ
19puts convert_unix_timestamp(timestamp, true)   # 12-કલાક ફોર્મેટ
20

1// ગો ટાઈમસ્ટેમ્પ રૂપાંતરણ
2package main
3
4import (
5    "fmt"
6    "time"
7)
8
9func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
10    // યુનિક્સ ટાઈમસ્ટેમ્પને સમયમાં રૂપાંતરિત કરો
11    t := time.Unix(timestamp, 0)
12    
13    // 12-કલાક અથવા 24-કલાક પસંદગીને આધારે ફોર્મેટ સ્ટ્રિંગ
14    formatString := "Monday, January 2, 2006 "
15    if use12Hour {
16        formatString += "3:04:05 PM"  // 12-કલાક ફોર્મેટ AM/PM સાથે
17    } else {
18        formatString += "15:04:05"    // 24-કલાક ફોર્મેટ
19    }
20    
21    // ફોર્મેટ કરેલ સમયને પાછું આપો
22    return t.Format(formatString)
23}
24
25func main() {
26    timestamp := int64(1609459200) // 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
27    fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-કલાક ફોર્મેટ
28    fmt.Println(convertUnixTimestamp(timestamp, true))  // 12-કલાક ફોર્મેટ
29}
30

1// સ્વિફ્ટ ટાઈમસ્ટેમ્પ રૂપાંતરણ
2import Foundation
3
4func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
5    // યુનિક્સ ટાઈમસ્ટેમ્પને તારીખમાં રૂપાંતરિત કરો
6    let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
7    
8    // તારીખ ફોર્મેટર બનાવો
9    let formatter = DateFormatter()
10    formatter.dateStyle = .full
11    
12    // 12-કલાક અથવા 24-કલાક પસંદગીને આધારે સમય શૈલી સેટ કરો
13    if use12Hour {
14        formatter.timeStyle = .medium
15        formatter.amSymbol = "AM"
16        formatter.pmSymbol = "PM"
17    } else {
18        formatter.timeStyle = .medium
19        formatter.dateFormat = formatter.dateFormat?.replacingOccurrences(of: "h:mm:ss a", with: "HH:mm:ss")
20    }
21    
22    // ફોર્મેટ કરેલ તારીખને પાછું આપો
23    return formatter.string(from: date)
24}
25
26// ઉદાહરણ ઉપયોગ
27let timestamp = 1609459200 // 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
28print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-કલાક ફોર્મેટ
29print(convertUnixTimestamp(timestamp, use12Hour: true))  // 12-કલાક ફોર્મેટ
30

1# આર ટાઈમસ્ટેમ્પ રૂપાંતરણ
2convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
3  # યુનિક્સ ટાઈમસ્ટેમ્પને POSIXct તારીખ/સમયમાં રૂપાંતરિત કરો
4  date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
5  
6  # 12-કલાક અથવા 24-કલાક પસંદગીને આધારે ફોર્મેટ
7  if (use_12hour) {
8    format_string <- "%A, %B %d, %Y %I:%M:%S %p"  # 12-કલાક ફોર્મેટ AM/PM સાથે
9  } else {
10    format_string <- "%A, %B %d, %Y %H:%M:%S"     # 24-કલાક ફોર્મેટ
11  }
12  
13  # ફોર્મેટ કરેલ તારીખની સ્ટ્રિંગને પાછું આપો
14  format(date_time, format_string)
15}
16
17# ઉદાહરણ ઉપયોગ
18timestamp <- 1609459200  # 1 જાન્યુઆરી, 2021 00:00:00 યુટીસી
19cat(convert_unix_timestamp(timestamp, FALSE), "\n")  # 24-કલાક ફોર્મેટ
20cat(convert_unix_timestamp(timestamp, TRUE), "\n")   # 12-કલાક ફોર્મેટ
21

1% મેટલેબ ટાઈમસ્ટેમ્પ રૂપાંતરણ
2function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
3    % યુનિક્સ ટાઈમસ્ટેમ્પને મેટલેબ તારીખ/સમયમાં રૂપાંતરિત કરો
4    % મેટલેબ તારીખો 1900-01-01 થી દિવસો છે, 1 = 1900-01-01
5    % યુનિક્સ ટાઈમસ્ટેમ્પ 1970-01-01 થી સેકંડ છે
6    
7    % પહેલા મેટલેબ તારીખ ફોર્મેટમાં રૂપાંતરિત કરો
8    % 25569 1900-01-01 અને 1970-01-01 વચ્ચેના દિવસોની સંખ્યા છે
9    Dim excelDate As Double
10    excelDate = (timestamp / 86400) + 25569;
11    
12    % 12-કલાક અથવા 24-કલાક પસંદગીને આધારે ફોર્મેટ
13    If use12Hour Then
14        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy h:mm:ss AM/PM');
15    Else
16        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy hh:mm:ss');
17    End If
18end
19
20% વર્કશીટમાં ઉપયોગ:
21% =ConvertUnixTimestamp(1609459200, TRUE)  ' 12-કલાક ફોર્મેટ
22% =ConvertUnixTimestamp(1609459200, FALSE) ' 24-કલાક ફોર્મેટ
23

કિનારા કેસો સંભાળવું

યુનિક્સ ટાઈમસ્ટેમ્પ્સ સાથે કામ કરતી વખતે, કેટલાક સામાન્ય કિનારા કેસોનું યોગ્ય રીતે સંભાળવું મહત્વપૂર્ણ છે. અહીં કેટલાક સામાન્ય કિનારા કેસો સંભાળવા માટેના ઉદાહરણો છે:

1// જાવાસ્ક્રિપ્ટ કિનારા કેસો સંભાળવું
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // તપાસો કે ટાઈમસ્ટેમ્પ માન્ય છે કે નહીં
4  if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
5    return "અમાન્ય ટાઈમસ્ટેમ્પ";
6  }
7  
8  // ઋણાત્મક ટાઈમસ્ટેમ્પ્સ માટે તપાસો (1970 પહેલાંની તારીખો)
9  if (timestamp < 0) {
10    // કેટલાક બ્રાઉઝર્સ ઋણાત્મક ટાઈમસ્ટેમ્પ્સને યોગ્ય રીતે સંભાળતા નથી
11    // 1970 પહેલાંની તારીખો માટે વધુ મજબૂત પદ્ધતિનો ઉપયોગ કરો
12    const date = new Date(timestamp * 1000);
13    if (isNaN(date.getTime())) {
14      return "અમાન્ય તારીખ (1970 પહેલાં)";
15    }
16  }
17  
18  // વર્ષ 2038 સમસ્યાને ધ્યાનમાં રાખો (32-બિટ સિસ્ટમો માટે)
19  const maxInt32 = 2147483647; // 32-બિટ સહીવાળા પૂર્ણાંક માટે મહત્તમ મૂલ્ય
20  if (timestamp > maxInt32) {
21    // ખૂબ મોટા ટાઈમસ્ટેમ્પ્સ માટે BigInt નો ઉપયોગ કરવા પર વિચાર કરો
22    console.warn("ટાઈમસ્ટેમ્પ 32-બિટ પૂર્ણાંક મર્યાદાને પાર કરે છે (Y2K38 સમસ્યા)");
23  }
24  
25  // સામાન્ય રૂપાંતરણ સાથે આગળ વધો
26  try {
27    const date = new Date(timestamp * 1000);
28    const options = {
29      year: 'numeric',
30      month: 'long',
31      day: 'numeric',
32      weekday: 'long',
33      hour: use12Hour ? 'numeric' : '2-digit',
34      minute: '2-digit',
35      second: '2-digit',
36      hour12: use12Hour
37    };
38    return date.toLocaleString(undefined, options);
39  } catch (error) {
40    return "ટાઈમસ્ટેમ્પ રૂપાંતરિત કરતી વખતે ભૂલ: " + error.message;
41  }
42}
43

સંદર્ભો

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. "આઇએસઓ 8601." વિકીપીડિયા, વિકીમિડિયા ફાઉન્ડેશન, https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: ઇન્ટરનેટ પર તારીખ અને સમય: ટાઈમસ્ટેમ્પ્સ." ઇન્ટરનેટ એન્જિનિયરિંગ ટાસ્ક ફોર્સ (IETF), https://tools.ietf.org/html/rfc3339

6. કેર્નિગન, બ્રાયન ડબલ્યુ., અને ડેનિસ એમ. રિચી. "C પ્રોગ્રામિંગ ભાષા." પ્રેન્ટિસ હોલ, 1988.