Unix Timestampથી તારીખ: સેકન્ડ, મિલિસેકન્ડ અને UTC સમજૂતી

આ રૂપાંતર માર્ગદર્શિકા છે: timestampથી તારીખ, તારીખથી timestamp, UTC વિ. સ્થાનિક, અને ISO 8601. કોઈ મૂલ્ય અચાનક 1970ની તારીખ બને તો સામાન્ય રીતે સેકન્ડ/મિલિસેકન્ડનો અમેળ હોય—જુઓ Unix Timestamp સેકન્ડ વિ. મિલિસેકન્ડ: તારીખ 1970 કેમ બતાવે છે.

Unix Timestamp શું છે?

Unix timestamp, Unix time અને epoch time સામાન્ય રીતે 1970-01-01 00:00:00 UTCથી વીતેલો સમય અર્થ આપે છે. આંકડો સમય ક્ષેત્ર લેબલવાળી ફોર્મેટ કરેલી તારીખ નથી. તે જ ક્ષણ UTC, ન્યૂયોર્ક, ટોક્યો કે સિઓલમાં અલગ ઘડિયાળ સમયે દેખાઈ શકે. Unix timestamps હંમેશા સેકન્ડ નથી—વ્યવહારમાં મિલિસેકન્ડ સામાન્ય છે.

Unix Epoch શું છે?

Unix epoch 1970-01-01 00:00:00 UTC છે. timestamp 0 તે જ ક્ષણ છે. ધન timestamp epoch પછીનો છે. કેટલીક સિસ્ટમો epoch પહેલાના સમય માટે ઋણ timestamp સ્વીકારે છે, પણ ભાષા અને તારીખ-શ્રેણીનો આધાર અલગ હોય છે.

મારું timestamp સેકન્ડમાં છે કે મિલિસેકન્ડમાં?

1720000000 સેકન્ડ છે; 1720000000000 મિલિસેકન્ડ છે; તે જ ક્ષણ. વ્યવહારુ સંકેત: આશરે 10 અંક ઘણી વાર સેકન્ડ, આશરે 13 ઘણી વાર મિલિસેકન્ડ. અંકની ગણતરી માત્ર અંદાજપદ્ધતિ છે. ભૂતકાળ કે ભવિષ્યની તારીખો, અન્ય એકમો કે કસ્ટમ epoch અલગ દેખાઈ શકે. તારીખ અને સમય રૂપાંતરક સેકન્ડ, મિલિસેકન્ડ કે સ્વયંથી ફેરવી શકે (≤10 અંક સેકન્ડ, ≥13 મિલિસેકન્ડ)—એકમ ખબર હોય તો તે પસંદ કરો.

ખોટું એકમ ખોટી તારીખ કેમ આપે છે?

JavaScript Date મિલિસેકન્ડ અપેક્ષે છે. 1720000000ને મિલિસેકન્ડ તરીકે આપો તો 1970-01-20 21:46:40 UTC મળે. મિલિસેકન્ડને સેકન્ડ સમજવું, કે ઊલટું, બિલકુલ અલગ તારીખ પર પહોંચે. 1970 નિદાન માર્ગ માટે જુઓ Unix Timestamp સેકન્ડ વિ. મિલિસેકન્ડ: તારીખ 1970 કેમ બતાવે છે.

new Date(1720000000);
// 1970-01-20T21:46:40.000Z

સેકન્ડવાળા Unix timestampને કેવી રીતે ફેરવવા

સેકન્ડને 1000 વડે ગુણો અને મિલિસેકન્ડ મેળવો. JavaScript Date મિલિસેકન્ડ આધારિત છે, તેથી new Date(timestamp * 1000) વાપરો.

const timestamp = 1720000000;
const date = new Date(timestamp * 1000);
date.toISOString();
// 2024-07-03T09:46:40.000Z

મિલિસેકન્ડ timestampને કેવી રીતે ફેરવવા

મિલિસેકન્ડ સીધા Dateને આપો. મિલિસેકન્ડ timestampને ફરી 1000 વડે ન ગુણો.

const timestamp = 1720000000000;
const date = new Date(timestamp);
date.toISOString();
// 2024-07-03T09:46:40.000Z

તે જ timestamp અલગ સમય કેમ બતાવે છે?

Unix timestamp એક ક્ષણ છે. તેને UTC, સ્થાનિક સમય કે પસંદ કરેલા IANA ક્ષેત્રમાં બતાવવાથી ઘડિયાળનો ચહેરો બદલાય છે. 1720000000000 માટે UTC 2024-07-03 09:46:40 છે. તે દિવસે America/New_York 2024-07-03 05:46:40 (EDT) છે. Asia/Seoul 2024-07-03 18:46:40 (UTC+9) છે. ન્યૂયોર્ક અને સિઓલના તે મૂલ્યો Intlમાંથી આવે છે, સ્થિર ઑફસેટના નારાથી નહીં.

Unix timestampમાં સમય ક્ષેત્ર હોય છે?

ના. તે America/New_York કે Asia/Seoul સંગ્રહતું નથી. timestamp એક ક્ષણ ઓળખે છે. સમય ક્ષેત્ર ત્યારે લાગુ પડે છે જ્યારે તે ક્ષણને વાંચી શકાય તેવી તારીખ અને સમય તરીકે ફોર્મેટ કરો. epoch UTCની સાપેક્ષે વ્યાખ્યાયિત છે; આંકડો પોતે «UTC સમય ક્ષેત્ર ફીલ્ડ» નથી.

Unix Timestamp વિ. ISO 8601

1720000000 અને 2024-07-03T09:46:40Z એ જ ક્ષણ દર્શાવી શકે. Unix વીતેલા સમયનું સંખ્યાત્મક મૂલ્ય છે. ISO 8601 વાંચી શકાય તેવી તારીખ-સમય સ્ટ્રિંગ છે અને Z (UTC) કે સંખ્યાત્મક ઑફસેટથી અટકી શકે. Z એટલે UTC; ક્યારેક Zulu કહે છે. આ એ જ ફોર્મેટ નથી.

વર્તમાન Unix timestamp કેવી રીતે મેળવવું?

JavaScriptમાં Date.now() મિલિસેકન્ડ છે. Math.floor(Date.now() / 1000) સેકન્ડ છે. લેખમાં «હવે»ને સ્થિર ન લખો; તે ખસે છે.

Date.now();
Math.floor(Date.now() / 1000);

તારીખ પાછી Unix timestampમાં ફેરવી શકાય?

હા. સ્પષ્ટ UTC ISO સ્ટ્રિંગમાંથી getTime() મિલિસેકન્ડ આપે છે; સેકન્ડ માટે 1000 વડે ભાગીને નીચે પૂર્ણાંક કરો.

const date = new Date("2024-07-03T09:46:40Z");
date.getTime();
// 1720000000000
Math.floor(date.getTime() / 1000);
// 1720000000

અસ્પષ્ટ તારીખ ફોર્મેટથી સાવધાન રહો

03/07/2024 પ્રદેશ પ્રમાણે 7 માર્ચ કે 3 જુલાઈ હોઈ શકે. સમય ક્ષેત્ર કે ઑફસેટવાળી ISO-શૈલી તારીખ અને સમય પસંદ કરો. તારીખ અને સમય રૂપાંતરક 01/02/2026 જેવી અસ્પષ્ટ સંખ્યાત્મક તારીખો નકારે છે અને તારીખ પસંદગીકાર કે ISO-શૈલી મૂલ્ય માગે છે.

ડેલાઇટ સેવિંગ ટાઇમ વિશે શું?

Unix timestamp DST ધ્વજ સંગ્રહતું નથી. સ્થાનિક દેખાવ ક્ષેત્રના નિયમો લાગુ કરે છે. America/New_York શિયાળા અને ઉનાળામાં અલગ ઑફસેટ વાપરે છે, તેથી «ન્યૂયોર્ક UTC-5 છે» હંમેશા સાચું નથી.

Unix timestampsમાં લીપ સેકન્ડ હોય છે?

સામાન્ય POSIX/Unix સમય લીપ સેકન્ડને સતત માપપટ્ટી પર વધારાના SI સેકન્ડ તરીકે ગણતો નથી. પ્લેટફોર્મ અલગ હોઈ શકે. રોજિંદા રૂપાંતરમાં આ વિગત અવગણી શકાય.

Unix timestamp રૂપાંતરની સામાન્ય ભૂલો

આ ગૂંચવણો ખોટી તારીખ કે ખોટો ઘડિયાળ ચહેરો આપે છે:

સેકન્ડને મિલિસેકન્ડ સમજવું
આધુનિક સેકન્ડ મૂલ્ય ત્યારે JavaScript Dateમાં 1970 પાસે બેસે છે.

મિલિસેકન્ડને સેકન્ડ સમજવું
તારીખ દૂરના ભવિષ્યમાં કૂદે છે.

10 કે 13 અંકને નિયમ સમજવા
અંકની ગણતરી સંકેત છે, બાંહેધરી નથી.

UTCને સ્થાનિક સમય સાથે ભેળવવું
ક્ષણ એ જ છે; બતાવેલી ઘડિયાળ અલગ હોઈ શકે.

સમય ક્ષેત્ર આંકડામાં છે એમ માનવું
IANA નામો દેખાડતી વખતે લાગુ પડે છે, timestampમાં સંગ્રહાતા નથી.

અસ્પષ્ટ તારીખો, DST નારા, કે વધારાનું ×1000
ISO-શૈલી ઇનપુટ વાપરો. મિલિસેકન્ડ timestampને ફરી ન ગુણો.

ચકાસેલા UTC ઉદાહરણો

આ UTC ઘડિયાળ સમય ગણાયા છે, અટકળ નથી:

ઇનપુટ	એકમ	UTC
0	સેકન્ડ	1970-01-01 00:00:00
1720000000	સેકન્ડ	2024-07-03 09:46:40
1720000000000	મિલિસેકન્ડ	2024-07-03 09:46:40
1720000000	મિલિસેકન્ડ	1970-01-20 21:46:40

સરળ રૂપાંતર નિર્ણય માર્ગદર્શિકા

સ્ત્રોત એકમ કહે તો તે વાપરો. નહીં તો અંકની ગણતરી સંકેત છે—પછી તારીખ વિશ્વસનીય લાગે છે કે નહીં જુઓ. APIને ms જોઈએ તો સેકન્ડને મિલિસેકન્ડ બનાવો. બતાવવા માટે UTC, સ્થાનિક કે IANA ક્ષેત્ર પસંદ કરો. ISO 8601 સંગ્રહ અને આપ-લે માટે ઉપયોગી છે.

• Unix timestamp છે
• ↓
• એકમ કહ્યું? વાપરો; નહીં તો પરિમાણ જુઓ
• સેકન્ડ? APIને મિલિસેકન્ડ જોઈએ તો ×1000
• મિલિસેકન્ડ? ms-આધારિત APIમાં સીધું વાપરો
• UTC, સ્થાનિક કે IANA ક્ષેત્ર તરીકે બતાવો
• ↓
• સ્ટ્રિંગ જોઈએ? ISO 8601 બેસી શકે

તમારા બ્રાઉઝરમાં Unix timestamps ફેરવો

NEXNARA તારીખ અને સમય રૂપાંતરક Unix સેકન્ડ અને મિલિસેકન્ડ ફેરવે છે, UTC, સ્થાનિક સમય અને ISO 8601 બતાવે છે, અને IANA સમય ક્ષેત્રો વચ્ચે ફેરવે છે.

Unix મોડ સેકન્ડ, મિલિસેકન્ડ, સ્વયં એકમ, વર્તમાન સમય અને તારીખ-થી-timestampને ટેકો આપે છે. સમય ક્ષેત્ર મોડ IANA નામો શોધે છે, બ્રાઉઝર ક્ષેત્ર વાપરે છે, અને DST-જાણકાર Intl ઑફસેટ લાગુ કરે છે. ફોર્મેટ મોડમાં પ્રદેશ-વાંચનીય આઉટપુટ, 12/24 કલાક દેખાવ, અને અસ્પષ્ટ-તારીખ રક્ષક છે. તારીખ તફાવત અલગ મોડ છે.

રૂપાંતર બ્રાઉઝરના Date અને Intl API વાપરે છે. Date જે મૂલ્યો રજૂ ન કરી શકે તે નકારાય છે. સ્વયં એકમ 11–12 અંકના મૂલ્યો અનુમાન કરતું નથી; સેકન્ડ કે મિલિસેકન્ડ પસંદ કરો.

તારીખ અને timestamp રૂપાંતર પોતે તમારા બ્રાઉઝરમાં થાય છે. ઇનપુટ રૂપાંતર માટે NEXNARA સર્વર પર મોકલાતા નથી. જાહેરાતો અને સાઇટની અન્ય સુવિધાઓ હજુ નેટવર્ક વાપરે છે.

તારીખ અને સમય રૂપાંતરકમાં timestamp ચોંટાડો અને એકમ પસંદ કરતાં પહેલાં UTC, સ્થાનિક સમય અને ISO 8601 સરખાવો.

FAQ

Unix timestampને તારીખમાં કેવી રીતે ફેરવવું?

એકમ જાણો. JavaScriptમાં સેકન્ડ માટે new Date(n * 1000). મિલિસેકન્ડ માટે new Date(n). પછી UTC, સ્થાનિક કે ક્ષેત્ર તરીકે ફોર્મેટ કરો.

Unix timestamp સેકન્ડમાં છે કે મિલિસેકન્ડમાં?

બંને હોઈ શકે. આશરે 10 અંક ઘણી વાર સેકન્ડ અને આશરે 13 ઘણી વાર મિલિસેકન્ડ, પણ તે અંદાજપદ્ધતિ છે, નિયમ નથી.

મારું timestamp 1970 કેમ બતાવે છે?

સામાન્ય રીતે સેકન્ડ મૂલ્ય મિલિસેકન્ડ વંચાયું. જુઓ Unix Timestamp સેકન્ડ વિ. મિલિસેકન્ડ: તારીખ 1970 કેમ બતાવે છે.

Unix timestamp હંમેશા UTC છે?

epoch UTCની સાપેક્ષે વ્યાખ્યાયિત છે, અને આંકડો એક ક્ષણ ઓળખે છે. દેખાવ સમય ક્ષેત્ર અલગ છે. તે સંગ્રહિત «UTC સમય ક્ષેત્ર ફીલ્ડ» નથી.

Unix timestampમાં સમય ક્ષેત્ર હોય છે?

ના. તે IANA ઓળખ લઈ જતું નથી. સમય ક્ષેત્ર ક્ષણ ફોર્મેટ કરતી વખતે લાગુ પડે છે.

તારીખને Unix timestampમાં કેવી રીતે ફેરવવી?

UTC ISO સ્ટ્રિંગમાંથી date.getTime() મિલિસેકન્ડ છે; Math.floor(date.getTime() / 1000) સેકન્ડ છે.