Epoch-tidsverktyg

Följ Unix Epoch-tid i realtid, bygg tidsstämplar från Å/M/D/T/M/S-datum, inspektera periodgränser och beräkna tidsdeltan lokalt i din webbläsare.

Inga uppladdningarIngen registreringOmedelbara resultat
Dag / Vecka / Månad / ÅrEpok-deltakalkylatorSQL, JS, Python, Go & Bash
Öppna Epok-verktyg
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis Epoch-tidsverktyg?

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

Realtidsklocka & Å/M/D/T/M/S-datumbyggare

Övervaka en pausbar Unix Epoch-klocka i realtid i sekunder och millisekunder samtidigt som du konstruerar exakta Epoch-heltal från separata fält för år, månad, dag, timme, minut och sekund i UTC eller valfri IANA-tidszon.

Gränstabeller för dag, vecka, månad & år

Generera Epoch-tidsstämplar för periodstart och periodslut för det aktiva datumet över UTC och IANA-tidszoner, redo att klistras in i SQL WHERE-satser, Prometheus-frågor eller analysfilter.

Deltakalkylator för varaktighet mellan två tidsstämplar

Beräkna teckenförsedd och absolut förfluten tid mellan två valfria Epoch-heltal, med uppdelning i dagar, timmar, minuter, sekunder, millisekunder samt kanoniska ISO-8601-varaktighetssträngar (PnDTnHnMnS).

Kopieringsklara kodsnuttar för flera språk

Kopiera idiomatiska kodsnuttar för aktuell epoch-tid och tidsstämpelkonvertering för JavaScript, Python, Go, Rust, PostgreSQL/MySQL och Bash – allt beräknat lokalt i din webbläsare utan nätverksanrop.

Utiliome jämfört med molnalternativ

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

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Realtidsklocka & Å/M/D/T/M/S-datumbyggare Övervaka en pausbar Unix Epoch-klocka i realtid i sekunder och millisekunder samtidigt som du konstruerar exakta Epoch-heltal från separata fält för år, månad, dag, timme, minut och sekund i UTC eller valfri IANA-tidszon. Begränsade alternativ utan avancerad anpassning
Gränstabeller för dag, vecka, månad & år Generera Epoch-tidsstämplar för periodstart och periodslut för det aktiva datumet över UTC och IANA-tidszoner, redo att klistras in i SQL WHERE-satser, Prometheus-frågor eller analysfilter. 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 Epoch-tidsverktyg i 3 enkla steg

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

1

Fånga realtid eller bygg Å/M/D/T/M/S

Frys Unix Epoch-realtidsklockan i det aktuella ögonblicket, ange separata värden för år, månad, dag, timme, minut och sekund, eller ladda in ett referens-Epoch-heltal i UTC eller en IANA-tidszon.

2

Inspektera periodgränser & beräkna deltan

Granska Epoch-heltalen för start och slut för omgivande dag, ISO-vecka, månad och år, eller ange en andra tidsstämpel för att beräkna exakt förfluten tid.

3

Kopiera frågeintervall eller språksnuttar

Kopiera gränsheltal i sekunder eller millisekunder direkt till SQL- eller observabilitetsfilter, eller hämta körklara Epoch-kodsnuttar för JavaScript, Python, Go, Rust, SQL och Bash.

Bygga Epoch-intervall, datumgränser & tidsdeltan

Snabbsvar: Sätt samman ett Unix Epoch-heltal från separata Å/M/D/T/M/S-fält i UTC eller en IANA-tidszon för att omedelbart få start- och slutgränser för dag, ISO-vecka, månad och år tillsammans med varaktighetsdeltan mellan två tidsstämplar och kopieringsklara kodsnuttar.

När du skriver databasmigreringar, schemalägger cron-bryttider eller avgränsar observabilitetsfrågor utgår du sällan från ett rått 10-siffrigt heltal – du utgår från ett kalenderdatum, en tidszon och ett rapporteringsfönster. Om du anger 2026-07-15 14:30:00 i UTC i Å/M/D/T/M/S-byggaren beräknas måltidpunkten och hela den omgivande gränstabellen fylls i med sekunder och millisekunder:

{
  "builtInput": "2026-07-15 14:30:00 (UTC)",
  "epochSeconds": 1784125800,
  "epochMilliseconds": 1784125800000,
  "boundariesUtc": {
    "day": {
      "start": 1784073600,
      "end": 1784159999,
      "rangeIso": "2026-07-15T00:00:00Z .. 2026-07-15T23:59:59Z"
    },
    "isoWeek": {
      "week": "2026-W29",
      "start": 1783900800,
      "end": 1784505599,
      "rangeIso": "2026-07-13T00:00:00Z .. 2026-07-19T23:59:59Z"
    },
    "month": {
      "start": 1782864000,
      "end": 1785542399,
      "rangeIso": "2026-07-01T00:00:00Z .. 2026-07-31T23:59:59Z"
    },
    "year": {
      "start": 1767225600,
      "end": 1798761599,
      "rangeIso": "2026-01-01T00:00:00Z .. 2026-12-31T23:59:59Z"
    }
  }
}

För att mäta MTTR vid incidenter, SLA-fönster eller token-TTL:er anger du två tidsstämplar i Deltakalkylatorn och kopierar uttryck för aktuell epoch-tid från Språksnuttshyllan:

# Two-Timestamp Delta Calculation
Timestamp A (Start):  1784125800 (2026-07-15T14:30:00Z)
Timestamp B (End):    1784310325 (2026-07-17T17:45:25Z)
Signed Delta:         +184525 s (+184525000 ms)
Human Breakdown:      2 days, 3 hours, 15 minutes, 25 seconds (51h 15m 25s)
ISO-8601 Duration:    P2DT3H15M25S

# Copy-Ready Current Unix Epoch Snippets
JavaScript (s / ms):  Math.floor(Date.now() / 1000)  |  Date.now()
Python 3 (s / ns):    int(time.time())               |  time.time_ns()
Go (s / ns):          time.Now().Unix()              |  time.Now().UnixNano()
Rust (std):           SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs()
PostgreSQL / MySQL:   SELECT EXTRACT(EPOCH FROM NOW())::bigint;  |  SELECT UNIX_TIMESTAMP();
Bash (GNU / macOS):   date +%s  |  date -u -d @1784125800  |  date -u -r 1784125800

Kalender-till-Epoch-aritmetik, sommartidsövergångar & design av intervallfrågor

Snabbsvar: Att mappa kalenderfält (Å/M/D/T/M/S) och periodgränser till Unix Epoch-heltal bygger på proleptisk gregoriansk dagräkning, halvöppna [start, nextStart)-predikat i SQL som bevarar bråkdelar av den sista sekunden, samt hantering av hopp och överlapp vid sommartid (DST) via IANA-databasen.

Proleptisk gregoriansk kalender-till-Epoch-matematik

Att konvertera diskreta kalenderfält (Y, M, D, H, Min, S) i UTC till ett Unix Epoch-heltal innebär att räkna exakta dagar från 1970-01-01 enligt den 400-åriga gregorianska skottårscykeln (år jämnt delbara med 4 är skottår med 366 dagar, utom sekelår som inte är delbara med 400 – vilket gör 2000 till ett skottår medan 2100 har 365 dagar) och multiplicera med 86 400:

epoch_utc = days_from_civil(Y, M, D) * 86400 + H * 3600 + Min * 60 + S

När inmatningsfälten representerar lokal väggklockstid i en IANA-tidszon snarare än UTC är själva UTC-förskjutningen en funktion av måldatumet, eftersom regioner reviderar standardförskjutningar och regler för sommartid (DST) över tid.

Slutna `23:59:59`-gränser kontra halvöppna `[start, nextStart)`-frågeintervall

Gränstabeller listar vanligtvis den inklusiva sista hela sekunden av ett UTC-dygn (till exempel 1784159999 för 2026-07-15T23:59:59Z) tillsammans med dess motsvarighet i millisekunder (1784159999999 för 23:59:59.999Z). I produktionsdatabaser som lagrar kolumner med millisekunder, mikrosekunder eller TIMESTAMPTZ kommer filtrering med WHERE created_at BETWEEN 1784073600 AND 1784159999 i tysthet att tappa händelser som registrerats under dygnets sista 999 millisekunder (såsom 23:59:59.450Z).

För att eliminera gränsläckage på undersekundsnivå utan att binda din fråga till kolumnupplösningen bör du föredra halvöppna predikat förankrade i nästa periods 00:00:00-start (1784160000, vilket är 1784159999 + 1):

-- Half-open interval (captures every sub-second fraction up to 23:59:59.999999...)
WHERE epoch_sec >= 1784073600 AND epoch_sec < 1784160000
WHERE epoch_ms  >= 1784073600000 AND epoch_ms < 1784160000000

Luckor och överlapp vid sommartid samt lokala dygn som inte är 86 400 sekunder

Beräkna aldrig lokala dygnsgränser genom att addera 86400 till lokal midnatt. I IANA-zoner som tillämpar sommartid (såsom America/New_York eller Europe/Stockholm) sträcker sig två kalenderdygn varje år inte över 86 400 sekunder:

  • Framåthopp på våren (23-timmarsdygn = 82 800 sekunder): När klockan hoppar från 01:59:59 direkt till 03:00:00 existerar inte lokala tider som 02:30:00 på det kalenderdatumet.
  • Bakåtvikning på hösten (25-timmarsdygn = 90 000 sekunder): När klockan upprepar 01:00:00 till 01:59:59 mappas en lokal tid som 01:30:00 till två skilda Unix Epoch-heltal med 3 600 sekunders mellanrum (först under sommartid, därefter under normaltid).

Genom att slå upp varje gränsvärdes 00:00:00 via IANA-tidszonsdatabasen hålls epoch-värden för dygnsstart och månadsstart exakta över alla sommartidsövergångar.

Väggklocks-Epochs kontra monotona varaktighetstimers

Runtime-anrop som Date.now(), time.time(), time.Now().Unix() och SystemTime::now() läser operativsystemets väggklocka (CLOCK_REALTIME), vilket är nödvändigt för serialiserade tidsstämplar och korrelation mellan maskiner, men klockan kan hoppa bakåt eller justeras under NTP-synkronisering. Använd Unix Epoch-deltan för lagrade historiska tidsstämplar och kombinera dem med monotona klockor (performance.now(), time.monotonic_ns(), std::time::Instant) när du mäter latens inom en process.

Epoch-tidsverktyg kontra Unix-tidsstämpelkonverterare: Vilket behöver du?

Snabbsvar: Använd Epoch-tidsverktyg för att övervaka Unix-realtidsklockan, sätta samman tidsstämplar från Å/M/D/T/M/S-inmatning, hämta gränstabeller för dag/vecka/månad/år, beräkna deltan mellan två tidsstämplar eller kopiera språksnuttar. Använd Unix-tidsstämpelkonverterare för att avkoda enskilda eller batchade heltal i s, ms, µs och ns samt ISO-8601- eller RFC 3339-strängar.

Båda Utiliome-verktygen körs 100 % lokalt i din webbläsare och separerar tydligt interaktiv Epoch-konstruktion & intervallplanering från högprecisionsavkodning av nyttolaster & batchkonvertering av loggar. Stanna i Epoch-tidsverktyg när du konstruerar frågegränser, följer Unix-realtidsklockan, beräknar varaktighetsdeltan eller kopierar språksnuttar. Byt till syskonverktyget Unix-tidsstämpelkonverterare när du har råa 10-, 13-, 16- eller 19-siffriga tidsstämplar eller flerradiga loggutdrag att avkoda.

Funktion Epoch-tidsverktyg Unix-tidsstämpelkonverterare
Primärt arbetsflöde Realtidsklocka, Å/M/D/T/M/S-byggare, periodgränser, deltan & kodsnuttar Dubbelriktad s/ms/µs/ns-tidsstämpel & ISO-8601/RFC 3339-batchavkodning
Unix Epoch-realtidsklocka Ja — realtidsräknare för sekunder & millisekunder med frysning/fångst Ingår ej — fokuserad på deterministisk nyttolastkonvertering
Å/M/D/T/M/S-fältbyggare Interaktiva kalenderfält i UTC eller valfri IANA-tidszon Tolkar inklistrade ISO-8601-, RFC 3339- och RFC 2822-strängar direkt
Tabeller för dag / vecka / månad / år Förberäknar start- och slut-Epoch-heltal för alla fyra perioderna Ingår ej
Deltakalkylator för två tidsstämplar Fullständig T2 - T1-uppdelning (d/h/m/s/ms och ISO-8601 PnDTnHnMnS) Endast relativ förskjutning mot aktuell systemklocka
16-siffriga µs & 19-siffriga ns BigInt Fokuserad på sekunder (10 siffror) och millisekunder (13 siffror) Full 64-bitars BigInt-autodetektering över s, ms, µs och 19-siffriga ns
Flerradig batchkonvertering Enskilt referensdatum + deltapar med två tidsstämplar Ja — konverterar hundratals radbrytningsseparerade tidsstämplar i ett svep

Inspekterar du 19-siffriga OpenTelemetry-nanosekundsspann, 16-siffriga PostgreSQL-mikrosekundsvärden eller en radbrytningsseparerad dump med blandade loggtidsstämplar? Öppna Unix-tidsstämpelkonverterare.

FAQ

Epoch-tidsverktyg FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis epoch tid konverterare online.

Varför bör SQL- och tidsseriefrågor använda halvöppna Epoch-gränser istället för 23:59:59?

En inklusiv övre gräns som slutar vid 23:59:59 (såsom 1784159999) utelämnar alla poster som innehåller bråkdelar av millisekunder eller mikrosekunder mellan 23:59:59.001 och 23:59:59.999. Genom att skriva ett halvöppet predikat förankrat i nästa periods 00:00:00-start (ts >= 1784073600 AND ts < 1784160000 i sekunder, eller ts >= 1784073600000 AND ts < 1784160000000 i millisekunder) fångas hela dygnet rent oavsett undersekundsprecision.

Varför är ett lokalt kalenderdygn inte alltid 86 400 Epoch-sekunder långt?

Ett UTC-dygn sträcker sig alltid över exakt 86 400 POSIX-sekunder, men en IANA-tidszon som tillämpar sommartid upplever ett 23-timmarsdygn (82 800 sekunder) när klockan ställs fram och ett 25-timmarsdygn (90 000 sekunder) när klockan ställs tillbaka. Eftersom addition av 86 400 till lokal midnatt förskjuter gränserna med en timme över sommartidsövergångar slår gränstabellen upp varje lokal 00:00:00-tidpunkt mot IANA-tidszonsdatabasen.

Hur hanterar Å/M/D/T/M/S-byggaren tvetydiga eller icke-existerande timmar vid sommartidsövergångar?

Under en framåtövergång på våren (till exempel när 02:00 hoppar till 03:00 i Europe/Stockholm eller America/New_York) existerar inte väggklocksminuter inom den överhoppade timmen utan flyttas fram över övergångsgapet. Under en bakåtövergång på hösten inträffar den upprepade timmen två gånger – med 3 600 sekunders mellanrum – under den tidigare sommartidsförskjutningen och den senare normaltidförskjutningen. För cron-jobb och faktureringsbrytpunkter som kräver strikt monotonicitet bör du definiera gränser i UTC.

Hur definieras ISO-8601-veckogränser i gränstabellen?

Enligt ISO-8601-reglerna börjar varje vecka på måndag kl. 00:00:00 och slutar på söndag kl. 23:59:59.999. ISO-vecka 1 (W01) under ett år definieras som den måndag-till-söndag-vecka som innehåller årets första torsdag (vilket motsvarar veckan som innehåller 4 januari), vilket innebär att W01 kan börja den 29, 30 eller 31 december föregående kalenderår.

Varför använder GNU Linux och macOS Bash-kommandon olika flaggor för att formatera ett Epoch-heltal?

GNU coreutils date på Linux tolkar ett Unix Epoch-heltal med prefixet -d @TIMESTAMP (date -u -d @1784125800 +%Y-%m-%dT%H:%M:%SZ), medan BSD date på macOS och FreeBSD använder flaggan -r TIMESTAMP (date -u -r 1784125800 +%Y-%m-%dT%H:%M:%SZ). Båda plattformarna stöder date +%s identiskt för att skriva ut aktuell Unix Epoch i sekunder.