Unix-tidsstämpelkonverterare

Konvertera Unix-tidsstämplar (s, ms, µs, ns) samt ISO-8601- och RFC 3339-datum mellan UTC, lokal tid och IANA-tidszoner direkt i din webbläsare.

Inga uppladdningarIngen registreringOmedelbara resultat
Sekunder, ms, µs & nsIANA-tidszoner & batch100% Lokalt • Noll Uppladdningar
Konvertera Unix-tidsstämpel
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis Unix-tidsstämpelkonverterare?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

Automatisk precision & 64-bitars BigInt-matematik

Klassificerar automatiskt 10-siffriga sekunder, 13-siffriga millisekunder, 16-siffriga mikrosekunder och 19-siffriga nanosekunder med 64-bitars BigInt-division så att delsekunder aldrig drabbas av IEEE-754 float64-avrundningsfel.

Utdata i ISO-8601, RFC 3339 & RFC 2822

Renderar varje konverterad tidpunkt samtidigt till kanonisk UTC ISO-8601, RFC 3339 med explicita numeriska tidszonsförskjutningar, RFC 2822 / IMF-fixdate-headers och relativa tidsintervall.

Batchbearbetning per rad & IANA-tidszonsprojektion

Tolkar hundratals radbrytningsseparerade heltalsstämplar eller datumsträngar i ett svep och projicerar tidsstämplar till valfri region i IANA-tidszonsdatabasen med historiska sommartidsregler (DST) applicerade.

Klientbaserad integritet utan uppladdning

Kör all tolkning, BigInt-aritmetik och tidszonsuppslag via Intl.DateTimeFormat lokalt i webbläsarens minne — produktionsloggar och spårningsdata lämnar aldrig din dator.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Automatisk precision & 64-bitars BigInt-matematik Klassificerar automatiskt 10-siffriga sekunder, 13-siffriga millisekunder, 16-siffriga mikrosekunder och 19-siffriga nanosekunder med 64-bitars BigInt-division så att delsekunder aldrig drabbas av IEEE-754 float64-avrundningsfel. Begränsade alternativ utan avancerad anpassning
Utdata i ISO-8601, RFC 3339 & RFC 2822 Renderar varje konverterad tidpunkt samtidigt till kanonisk UTC ISO-8601, RFC 3339 med explicita numeriska tidszonsförskjutningar, RFC 2822 / IMF-fixdate-headers och relativa tidsintervall. Kräver externa verktyg eller manuell hantering
Integritet och databehandling 100 % lokalt i webbläsaren (ingen serveruppladdning) Laddar upp data till externa molnservrar
Pris och kontokrav 100 % gratis för alltid utan registrering Kräver kontoregistrering eller betald prenumeration
Så fungerar det

Hur du använder Unix-tidsstämpelkonverterare i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Klistra in eller ladda upp tidsstämplar eller datumsträngar

Ange en enskild Unix-tidsstämpel, klistra in en datumsträng i ISO-8601, RFC 3339 eller RFC 2822, eller ladda upp en radbrytningsseparerad lista med råa numeriska tidsstämplar från loggar eller databasexporter.

2

Bekräfta precisionsenhet & måltidszon

Låt sifferbaserad detektering identifiera sekunder (10 siffror), millisekunder (13), mikrosekunder (16) eller nanosekunder (19), eller lås en specifik enhet och välj en IANA-tidszon som Europe/Stockholm eller America/New_York.

3

Kopiera normaliserade format eller batchresultat

Kopiera enskilda representationer i ISO-8601, RFC 3339, RFC 2822, UTC eller konverterade heltalsenheter, eller exportera alla konverterade batchrader direkt till urklipp.

Konvertera Unix-tidsstämplar med multiprecision och i batch

Snabbsvar: Klistra in enskilda eller radbrytningsseparerade heltal i sekunder, millisekunder, mikrosekunder eller nanosekunder — eller strängar i ISO-8601 och RFC 3339 — för att konvertera dubbelriktat mellan UTC, lokal tid och valfri IANA-tidszon utan precisionsförlust från flyttal.

Moderna distribuerade system genererar Unix-tidsstämplar i fyra olika precisionsnivåer beroende på körmiljö och telemetrilager: POSIX-verktyg och JWT-anspråk (exp/iat) genererar 10-siffriga sekunder, JavaScript Date.now() och Java Instant.toEpochMilli() genererar 13-siffriga millisekunder, PostgreSQL och Pythons interna datetime lagrar 16-siffriga mikrosekunder, medan OpenTelemetry-spans, Go time.UnixNano() och Linux clock_gettime(CLOCK_REALTIME) genererar 19-siffriga nanosekunder.

När du klistrar in en 19-siffrig nanosekundstämpel som 1784125800452819307 och väljer America/New_York som mål-IANA-tidszon, delar konverteraren upp heltalskvoten och delsekundsresten med 64-bitars BigInt-aritmetik och genererar alla överföringsformat och skalade enheter samtidigt:

{
  "input": "1784125800452819307",
  "detectedUnit": "nanoseconds (19-digit)",
  "iso8601Utc": "2026-07-15T14:30:00.452819307Z",
  "rfc3339TargetTz": "2026-07-15T10:30:00.452819307-04:00",
  "targetTimezone": "America/New_York (EDT, UTC-04:00)",
  "rfc2822Utc": "Wed, 15 Jul 2026 14:30:00 +0000",
  "units": {
    "seconds": "1784125800",
    "milliseconds": "1784125800452",
    "microseconds": "1784125800452819",
    "nanoseconds": "1784125800452819307"
  }
}

För felsökning av loggar och databasmigreringar kan du klistra in radbrytningsseparerade rader som blandar råa heltal med olika precision, negativa tidpunkter före 1970 och RFC 3339-strängar för dubbelriktad normalisering i en enda körning:

# Input (newline-separated mixed batch)
1784125800
1784125800452
1784125800452819307
-14182940
2026-07-15T23:30:00+09:00

# Normalized Output (UTC ISO-8601 | Epoch Seconds | Detected Format)
2026-07-15T14:30:00Z            | 1784125800 | seconds (10-digit)
2026-07-15T14:30:00.452Z        | 1784125800 | milliseconds (13-digit)
2026-07-15T14:30:00.452819307Z  | 1784125800 | nanoseconds (19-digit)
1969-07-20T20:17:40Z            | -14182940  | seconds (signed pre-1970)
2026-07-15T14:30:00Z            | 1784125800 | RFC 3339 / ISO-8601 string

Specifikation för Unix-tid, precisionsgränser & specialfall

Snabbsvar: POSIX Unix-tid räknar sekunder (exklusive skottsekunder) som förflutit sedan 1970-01-01T00:00:00Z med exakt 86 400 sekunder per UTC-dygn. Förlustfri konvertering mellan flera enheter kräver storleksklassificering, 64-bitars BigInt-division, euklidisk golvdivision för negativa tider före 1970 samt historisk IANA tzdb-uppslagning.

Definition av POSIX-tidsstämpel & skottsekunder

Enligt POSIX.1-2017 (Base Definitions, Section 4.16: Seconds Since the Epoch) definieras Unix-tid inte som en rå räkning av förflutna SI-atomsekunder, utan genom en deterministisk formel som mappar varje UTC-kalenderdygn till exakt 86,400 sekunder. Till skillnad från internationell atomtid (TAI), som för närvarande ligger 37 sekunder före UTC, utelämnar POSIX Unix-tidsstämplar skottsekunder. När IERS infogar en positiv skottsekund (23:59:60Z), ställer operativsystem antingen tillbaka klockan med en sekund eller smetar ut den extra sekunden över ett fler-timmarsfönster via NTP leap smearing. Följaktligen kan ett numeriskt Unix-heltal inte unikt koda 23:59:60Z utan en extern tabell över skottsekunder.

IEEE-754 Float64-trunkering kontra 64-bitars BigInt-aritmetik

JavaScript-tal använder flyttal med dubbel precision enligt IEEE-754 (binary64), vilket allokerar 53 bitar till signifikanden och begränsar exakt heltalsrepresentation till Number.MAX_SAFE_INTEGER (9007199254740991, 16 siffror). En 19-siffrig nanosekundstämpel som 1784125800452819307 ligger över 2^60 (1152921504606846976), där avståndet (ULP) mellan intilliggande representerbara IEEE-754-flyttal breddas till 256 nanosekunder:

Exact 64-bit integer:         1784125800452819307 -> .452819307Z
JavaScript Number() coercion: 1784125800452819200 -> .452819200Z (107 ns lost!)

För att förhindra tyst datakorruption på under-mikrosekundnivå tolkar denna konverterare numerisk indata direkt som BigInt, dividerar med enhetsdivisorn (1n, 1000n, 1000000n eller 1000000000n) för att extrahera hela sekunder och formaterar BigInt-resten direkt till nollutfyllda decimaler.

Sifferbandsheuristik, golvdivision före 1970 & år 2038-problemet

Automatisk detektering klassificerar absoluta storlekar under 10^11 som sekunder (täcker 1970-01-01 till och med 5138-11-16), 10^11 till 10^14 - 1 som millisekunder, 10^14 till 10^17 - 1 som mikrosekunder och 10^17 eller högre som nanosekunder. För små heltal nära 1970-startpunkten (exempelvis 86400, vilket motsvarar 1970-01-02T00:00:00Z i sekunder eller 1970-01-01T00:01:26.400Z i millisekunder) bör du låsa enhetsväljaren manuellt.

Två specialfall med teckenförsedda heltal bryter ofta enklare konverterare:

  • 32-bitars teckenförsett time_t-spill (Y2038): Äldre 32-bitars teckenförsedda heltal har sitt maxvärde vid 2147483647 (2038-01-19T03:14:07Z), och slår vid nästa sekund runt till -2147483648 (1901-12-13T20:45:52Z). Moderna system och 64-bitars BigInt-logik undviker detta tak helt och hållet.
  • Negativ euklidisk golvdivision för delsekunder: I ISO-8601 adderas decimaler alltid framåt till den avrundade hela sekunden. För -14182939750 ms (250 ms efter 1969-07-20T20:17:40Z) ger trunkerande division -14182939 s med resten -750 ms, medan euklidisk golvdivision korrekt ger -14182940 s plus +250 ms (1969-07-20T20:17:40.250Z).

Formatgrammatik: ISO-8601 kontra RFC 3339 kontra RFC 2822

Medan ISO-8601 tillåter veckodatum (2026-W29-3), ordningsdatum och utelämnade tidszonsbeteckningar, definierar RFC 3339 en strikt internetprofil som kräver den fullständiga tidsstämpeln YYYY-MM-DDTHH:MM:SS[.fraction] plus ett explicit Z eller en numerisk förskjutning på formen ±HH:MM. RFC 2822 (uppdaterad av RFC 5322) specificerar den utförliga syntaxen Wed, 15 Jul 2026 14:30:00 +0000 som fortfarande krävs i SMTP-e-posthuvuden och HTTP-fälten Last-Modified / Date (IMF-fixdate).

Unix-tidsstämpelkonverterare kontra Epoch-konverterare: Vilken behöver du?

Snabbsvar: Använd Unix-tidsstämpelkonverteraren för att avkoda, normalisera eller batchkonvertera råa heltal i s, ms, µs och ns samt strängar i ISO-8601 eller RFC 3339 över IANA-tidszoner. Byt till vårt Epoch-verktyg när du behöver en live-klocka, en datumbyggare (Å/M/D/T/M/S), tabeller för dag/vecka/månad/år-gränser, tidsdifferenser eller kodsnuttar.

Båda tidsverktygen på Utiliome körs helt på klientsidan, men är byggda för olika utvecklarflöden. Unix-tidsstämpelkonverterare är konstruerad för att avkoda och batchnormalisera råa datapayloads — såsom OpenTelemetry-spårningstidsstämplar i nanosekunder, Kafka-meddelandehuvuden, JWT-anspråk och flerradiga loggutdrag. Om du istället skriver tidsintervallfrågor, beräknar förfluten incidenttid eller skriver datumhanteringskod, öppna syskonverktyget Epoch-konverterare.

Funktion Unix-tidsstämpelkonverterare Epoch-konverterare
Primärt arbetsflöde Avkoda & batchkonvertera råa numeriska tidsstämplar och datumsträngar Bygg tidsstämplar från kalenderfält, slå upp periodgränser & beräkna differenser
Delsekundsprecision Detekterar automatiskt sekunder (10), ms (13), µs (16) och 64-bitars BigInt ns (19) Sekunder och millisekunder för klockor, byggare och frågegränser
Batchbearbetning per rad Ja — konverterar flerradiga listor med blandade tidsstämplar och ISO-8601-datum Arbetsbänk för enskilt referensdatum och differensjämförelse mellan två tider
Live Unix-klocka Inte i fokus — optimerad för deterministisk payload-inspektion Ja — realtidstickande räknare med paus-/frysfunktion
Start-/slutgränser för perioder Konverterar endast enskilda tidpunkter Förberäknar start- & sluttider för dag, ISO-vecka, månad och år
Differensmatematik för två tider Visar relativ förskjutning från aktuell klocka Fullständig T2 - T1-uppdelning (d/h/m/s/ms + ISO-8601 PnDTnHnMnS)
Kodsnuttar för programmeringsspråk Utdata i överföringsformat (ISO-8601, RFC 3339, RFC 2822) Kopieringsklara kodsnuttar för JS, Python, Go, Rust, SQL och Bash

Behöver du heltalsgränser för början av dagen eller slutet av månaden till en SQL WHERE-sats, en exakt differens mellan två incidenttidsstämplar eller en kopieringsklar enradare i Go/Rust/SQL? Gå vidare till Epoch-konverterare.

FAQ

Unix-tidsstämpelkonverterare FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis konvertera unix tidsstämpel till datum online.

Hur skiljer den automatiska precisionsdetekteringen på sekunder, millisekunder, mikrosekunder och nanosekunder?

Tolken tar bort blanksteg, utvärderar den absoluta heltalsstorleken via BigInt och klassificerar värden efter tiopotensband: storlekar under 10^11 mappas till sekunder (datum fram till år 5138), 10^11 till 10^14 - 1 mappas till millisekunder, 10^14 till 10^17 - 1 mappas till mikrosekunder och 10^17 och uppåt mappas till nanosekunder. Om du inspekterar små delsekundsheltal registrerade kort efter 1970-01-01 kan du åsidosätta den automatiska detekteringen genom att välja en explicit enhet.

Varför förlorar 19-siffriga nanosekundstämplar precision i vanliga JavaScript Date()-anrop?

Standard-JavaScript har två begränsningar: Date-objekt lagrar endast hela millisekunder internt, och Number-värden i JavaScript använder 64-bitars IEEE-754-flyttal vars 53-bitars signifikand förlorar heltalsprecision över Number.MAX_SAFE_INTEGER (9007199254740991). Vid 10^18 nanosekunder avrundar float64 heltal till multiplar av 256 ns. Detta verktyg kringgår Number-typkonvertering under tolkningen genom att använda 64-bitars BigInt-division och restformatering för att bevara alla 9 nanosekundsdecimaler.

Hur hanteras negativa Unix-tidsstämplar före den 1 januari 1970?

Negativa heltal räknar sekunder (eller delsekundsenheter) bakåt från 1970-01-01T00:00:00Z — exempelvis motsvarar -14182940 sekunder 1969-07-20T20:17:40Z. För negativa delsekundsvärden som -14182939750 millisekunder tillämpar konverteraren euklidisk golvdivision (-14182940 sekunder plus +250 millisekunder) så att ISO-8601-utdatan korrekt visar 1969-07-20T20:17:40.250Z utan ett avrundningsfel på en sekund.

Vad är skillnaden mellan utdataformaten ISO-8601, RFC 3339 och RFC 2822?

ISO-8601 är den breda internationella standarden som täcker kalenderdatum, ordningsdatum, veckodatum och tidsintervall. RFC 3339 är en strikt internetprofil av ISO-8601 som används i JSON-API:er, Kubernetes-manifest och strukturerade loggar, vilken kräver en fullständig YYYY-MM-DDTHH:MM:SS-tidsstämpel med en explicit Z- eller ±HH:MM UTC-förskjutning. RFC 2822 (samt RFC 5322 / HTTP IMF-fixdate) är den läsbara headersyntaxen som Wed, 15 Jul 2026 14:30:00 +0000 vilken används i e-post- och HTTP-headers.

Tillämpar IANA-tidszonskonverteringen historiska regler för sommartid (DST)?

Ja. När du väljer en region som America/New_York, Europe/Berlin eller Australia/Sydney tillfrågas webbläsarens inbyggda IANA-tidszonsdatabas via Intl.DateTimeFormat för exakt den historiska eller framtida tidpunkt som konverteras — vilket applicerar EDT (-04:00) på en tidsstämpel i juli och EST (-05:00) på en tidsstämpel i januari, istället för att använda dagens lokala tidsförskjutning rakt av.