Unix időbélyeg → dátum átalakító
Alakítson át egy Unix időbélyeget olvasható dátummá és idővé — vagy bármely dátumot vissza Unix időbélyeggé. Másodperceket és ezredmásodperceket is támogat.
Eszköz megosztása
Beágyazás a webhelyre
Kapcsolódó eszközök
Mi az a Unix timestamp?
A Unix timestamp, más néven Unix time vagy POSIX time, az a másodpercek száma, amely 1970-01-01 00:00:00 UTC óta eltelt, ezt nevezzük Unix epoch-nak. Ez az informatikában széles körben használt szabvány, mert az időpontot egyetlen egész számként ábrázolja, ami megkönnyíti a tárolást, az összehasonlítást és a számtani műveleteket.
A JavaScript belsőleg ezredmásodpercben dolgozik, így a Date.now() a Unix timestamp szorozva 1000-rel. Sok API, adatbázis és backend rendszer ezzel szemben másodpercet használ. Ez az eszköz mindkét formátumot fogadja, és automatikusan felismeri, hogy másodpercről vagy ezredmásodpercről van-e szó az beírt szám nagysága alapján.
Kitüntetett Unix timestamp értékek
| Timestamp | Dátum (UTC) | Megjegyzés |
|---|---|---|
0 | 1970-01-01 00:00:00 | Unix epoch |
1,000,000,000 | 2001-09-09 01:46:40 | 1 milliárd másodperc |
2,000,000,000 | 2033-05-18 03:33:20 | 2 milliárd másodperc |
2,147,483,647 | 2038-01-19 03:14:07 | 2038-as probléma (32 bites maximum) |
Miért 1970?
Az 1970. január 1-je választása az Unix epoch-nak részben egyezményen, részben pedig gyakorlati korlátok miatt történt. A Unix-ot az 1960-as évek végén és az 1970-es évek elején fejlesztették ki a Bell Labs-ban. A fejlesztőknek szükségük volt egy közelmúltbeli, kerek kezdődátumra az idő reprezentálásához. Az 1970. január 1. elég közelmúltbeli volt ahhoz, hogy praktikus legyen, és semmiféle különleges technikai jelentőséggel nem bírt — egyszerűen csak egy kényelmes referenciapont volt.
Más rendszerekben különböző epoch dátumok használatosak: a Windows FILETIME epoch 1601. január 1.; a GPS idő 1980. január 6-tól kezdődik; az NTP epoch 1900. január 1. Amikor rendszerek között konvertálunk, elengedhetetlen, hogy ismerjük az egyes rendszerek epoch dátumát.
Másodperc vagy ezredmásodperc
Az eredeti Unix timestamp másodpercben van megadva. A legtöbb szerver oldali nyelv és rendszer (Unix shell, Python time.time(), PHP time(), legtöbb adatbázis) másodpercet használ. A JavaScript Date.now() és new Date().getTime() ezredmásodpercet ad vissza. Ez az eltérés gyakori hibaforrás, amikor JavaScript frontend-ek kommunikálnak backend API-kkal.
Egy Unix timestamp másodpercben kifejezve jelenleg 10 számjegyű szám (2023-ban körülbelül 1 700 000 000). Egy ezredmásodpercben kifejezett timestamp 13 számjegyű. A számológép a beírt számjegyek száma alapján felismeri, hogy melyik formátumról van szó, és ennek megfelelően konvertál.
A 2038-as probléma
Az olyan rendszerek, amelyek a Unix timestamp-et előjeles 32 bites egész számként tárolják, csak az epoch után 2,147,483,647 másodpercig tudnak dátumokat reprezentálni — ez 2038. január 19-én 03:14:07 UTC. E pillanat után a 32 bites előjeles egész szám túlcsordulódik egy nagy negatív szemmá, amely 1901-es dátumot képvisel.
Ezt néha „Y2K38" problémának vagy Unix Millennium Bug-nak hívják. A modern 64 bites rendszerek nem érintettek, mivel egy 64 bites előjeles egész szám körülbelül 292 milliárd évre képes timestamp-eket reprezentálni. Azonban a beágyazott rendszerek, az örökölt adatbázisok és a régebbi 32 bites szoftverek továbbra is sérülékenyek lehetnek. Sok iparág — beleértve a telekommunikációt, a bankszektort és az ipari vezérlőrendszereket — folyamatos migrációs erőfeszítéseket végez ennek megoldása érdekében.
A jelenlegi Unix timestamp lekérése
| Nyelv / környezet | Parancs |
|---|---|
| JavaScript | Math.floor(Date.now() / 1000) |
| Python | import time; int(time.time()) |
| PHP | time() |
| Bash | date +%s |
| SQL (PostgreSQL) | EXTRACT(EPOCH FROM NOW())::int |
| SQL (MySQL) | UNIX_TIMESTAMP() |
| Go | time.Now().Unix() |
| Rust | SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() |
Gyakorlati felhasználási módok
API fejlesztés: A REST API-k általában Unix timestamp-eket használnak a created_at, updated_at és token lejárati mezőkhöz. A timestamp időzóna-független és egyértelmű — ellentétben a formázott dátum szövegekkel, amelyek a locale-tól és a formázási konvencióktól függenek.
Token lejárata: A JWT (JSON Web Tokens) Unix timestamp-eket használ az exp (lejárat) és iat (kibocsátás időpontja) claim-ekhez. A token lejár, amikor az aktuális timestamp meghaladja az exp értéket. A lejárati idő kiszámítása — "ez a token 24 óra múlva járjon le" — az aktuális timestamp-hez 86 400 másodperc hozzáadásához szükséges.
Cache TTL: A cache lejáratát gyakran Unix timestamp-ként vagy másodpercek számára állítják be az aktuális időtől. A cache problémák hibakeresése gyakran egy tárolt lejárati timestamp-et olvasható dátummá konvertálást igényel.
Naplófájl elemzés: A kiszolgáló naplófájlok gyakran Unix timestamp-eket tartalmaznak. Ezek olvasható dátumokká való konvertálása az első lépés a naplóbejegyzések összevetésében a valós eseményekkel.
Adatbázis tárolás: Az timestamp-eket egész számként tárolni formázott szöveg helyett elkerüli az időzóna konverziós hibákat és leegyszerűsíti a rendezést, tartománylekérdezéseket és számtani műveleteket. Az "utolsó 7 nap összes rekordja" lekérdezés a következővé válik: WHERE created_at > (NOW_UNIX - 604800).
Gyakran ismételt kérdések
Mi az a Unix időbélyeg (Unix timestamp)?
A Unix időbélyeg annak a másodpercekben mért időnek a száma, ami 1970. január 1. 00:00:00 UTC óta eltelt — ezt a referenciaidőpontot Unix epoch-nak hívják. Bármely időpontot egyetlen egész számmal ábrázol, ezért könnyű tárolni, összehasonlítani és számolni vele. A legtöbb operációs rendszer, adatbázis, API és programozási nyelv ezt tekinti szabványos időformátumnak.
Hogyan alakíthatok át egy Unix időbélyeget dátummá?
Írd be az időbélyeget a konverterbe, és megkapod a hozzá tartozó dátumot és időt UTC-ben és a helyi időzónádban is. Az eszköz automatikusan felismeri, hogy másodperceket (10 számjegy) vagy ezredmásodperceket (13 számjegy) adtál-e meg. Fordítva is működik: válassz dátumot és időt, és megkapod a megfelelő Unix időbélyeget.
Mi a különbség a Unix idő másodperces és ezredmásodperces formátuma között?
Az eredeti Unix időbélyeg másodpercekben van. A legtöbb szerveroldali rendszer — PHP, Python, Go, Bash, SQL adatbázisok — másodperceket használ. A JavaScript `Date.now()` és `new Date().getTime()` ezredmásodperceket ad vissza (Unix másodperc × 1000). A másodperces időbélyeg jelenleg 10 számjegyű; az ezredmásodperces 13 számjegyű. A kettő összekeverése gyakori hiba, amikor egy JavaScript frontend időbélyeget küld egy backendnek, amely másodperceket vár.
Miért 1970. január 1-jén kezdődik a Unix idő?
Ezt a dátumot a Unix fejlesztői választották a Bell Labsnál az 1970-es évek elején, mert kényelmes, a fejlesztés idejéhez közeli kezdőpont volt. Nincs különösebb jelentősége azon túl, hogy „kerek” dátum és a rendszer megszületéséhez közel esik. Más rendszerek más epoch-ot használnak: a Windows FILETIME 1601. január 1-jén indul; a GPS idő 1980. január 6-án; az NTP 1900. január 1-jén.
Mi a 2038-as probléma (Year 2038 problem)?
Azok a rendszerek, amelyek a Unix időbélyeget előjeles 32 bites egész számként tárolják, csak 2038. január 19-ig tudnak dátumokat ábrázolni (2,147,483,647 időbélyeg). Ezután az érték túlcsordul, és egy nagy negatív szám lesz belőle, ami 1901-es dátumot jelent. A modern 64 bites rendszerek nem érintettek. Viszont régi beágyazott rendszerek, régebbi adatbázisok és 32 bites szoftverek még sérülékenyek lehetnek, és 2038 előtt migrációra lehet szükség.
Hogyan kapom meg az aktuális Unix időbélyeget a programozási nyelvemben?
JavaScript: Math.floor(Date.now() / 1000). Python: import time; int(time.time()). PHP: time(). Bash: date +%s. PostgreSQL: EXTRACT(EPOCH FROM NOW())::int. MySQL: UNIX_TIMESTAMP(). Go: time.Now().Unix(). Ezek mind a jelenlegi időt adják vissza a Unix epoch óta eltelt másodpercekben.