Epoch-tijd Workbench

Volg live Unix Epoch-tijd, bouw tijdstempels uit J/M/D/U/M/S-datums, inspecteer periodegrenzen en bereken tijdsverschillen (delta's) lokaal in uw browser.

Geen uploadsGeen registratieDirect resultaat
Dag / Week / Maand / JaarEpoch-deltacalculatorSQL, JS, Python, Go & Bash
Epoch Workbench openen
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis Epoch-tijd Workbench gebruiken?

Van de grond af opgebouwd voor strikte privacy, directe uitvoering en nul wrijving. Geen registratie nodig.

Live Klok & J/M/D/U/M/S-datumbouwer

Volg een pauzeerbare realtime Unix Epoch-klok in seconden en milliseconden terwijl u exacte Epoch-integers samenstelt uit afzonderlijke velden voor jaar, maand, dag, uur, minuut en seconde in UTC of elke IANA-tijdzone.

Grenstabellen voor Dag, Week, Maand & Jaar

Genereer start- en eind-Epoch-tijdstempels voor de actieve datum in UTC en IANA-tijdzones, direct klaar om te plakken in SQL WHERE-clausules, Prometheus-query's of analysefilters.

Delta-duurcalculator voor Twee Tijdstempels

Bereken de verstreken tijd (met teken en absoluut) tussen twee willekeurige Epoch-integers, uitgesplitst in dagen, uren, minuten, seconden, milliseconden en canonieke ISO-8601-duurstrings (PnDTnHnMnS).

Kopieerklare Multi-Language Snippets

Kopieer idiomatische code-snippets voor de huidige epoch-tijd en tijdstempelconversie in JavaScript, Python, Go, Rust, PostgreSQL/MySQL en Bash—volledig lokaal in uw browser berekend zonder netwerkverzoeken.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
Live Klok & J/M/D/U/M/S-datumbouwer Volg een pauzeerbare realtime Unix Epoch-klok in seconden en milliseconden terwijl u exacte Epoch-integers samenstelt uit afzonderlijke velden voor jaar, maand, dag, uur, minuut en seconde in UTC of elke IANA-tijdzone. Beperkte opties zonder geavanceerde aanpassing
Grenstabellen voor Dag, Week, Maand & Jaar Genereer start- en eind-Epoch-tijdstempels voor de actieve datum in UTC en IANA-tijdzones, direct klaar om te plakken in SQL WHERE-clausules, Prometheus-query's of analysefilters. Vereist externe tools of handmatige bewerking
Privacy & Gegevensverwerking 100% lokale verwerking in je browser (geen uploads) Uploadt gegevens naar externe cloudservers
Prijsmodel & Accountvereisten 100% gratis voor altijd zonder registratie Vereist accountregistratie of betaald abonnement
Hoe het werkt

Hoe Epoch-tijd Workbench te gebruiken in 3 eenvoudige stappen

Geen software-installatie vereist. Alles draait direct in je webbrowser.

1

Leg Live Tijd Vast of Bouw J/M/D/U/M/S

Bevries de live Unix Epoch-klok op het huidige moment, voer afzonderlijke waarden in voor jaar, maand, dag, uur, minuut en seconde, of laad een referentie-Epoch-integer in UTC of een IANA-tijdzone.

2

Inspecteer Periodegrenzen & Bereken Delta's

Bekijk de start- en eind-Epoch-integers voor de omliggende dag, ISO-week, maand en het jaar, of geef een tweede tijdstempel op om de exacte verstreken tijdsduur te berekenen.

3

Kopieer Querybereiken of Taal-snippets

Kopieer grens-integers in seconden of milliseconden rechtstreeks naar SQL- of observability-filters, of pak direct uitvoerbare Epoch-snippets voor JavaScript, Python, Go, Rust, SQL en Bash.

Epoch-bereiken, Datumgrenzen & Tijdsverschillen (Delta's) Bouwen

Kort antwoord: Stel een Unix Epoch-integer samen uit afzonderlijke J/M/D/U/M/S-velden in UTC of een IANA-tijdzone om direct begin- en eindgrenzen voor dag, ISO-week, maand en jaar te verkrijgen, samen met tijdsverschillen tussen twee tijdstempels en kopieerklare code-snippets.

Bij het schrijven van databasemigraties, het inplannen van cron-cutoffs of het afbakenen van observability-query's begint u zelden met een ruwe 10-cijferige integer—u begint met een kalenderdatum, een tijdzone en een rapportagevenster. Wanneer u 2026-07-15 14:30:00 in UTC invoert in de J/M/D/U/M/S-bouwer, wordt het doelmoment berekend en wordt de volledige tabel met omliggende periodegrenzen in seconden en milliseconden ingevuld:

{
  "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"
    }
  }
}

Om incident-MTTR, SLA-vensters of token-TTL's te meten, voert u twee tijdstempels in de Delta-calculator in en kopieert u expressies voor de huidige epoch-tijd uit het Taal-snippet-paneel:

# 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-naar-Epoch-rekenkunde, Zomertijd-overgangen & Bereikquery-ontwerp

Kort antwoord: Het omzetten van civiele J/M/D/U/M/S-velden en kalenderperiodegrenzen naar Unix Epoch-integers steunt op proleptische gregoriaanse dagtelling, halfopen [start, volgendeStart) SQL-predicaten die fractionele laatste seconden behouden, en het oplossen van gaten (gaps) en overlappingen (folds) bij IANA-zomertijd (DST).

Proleptische Gregoriaanse Kalender-naar-Epoch-wiskunde

Het omzetten van afzonderlijke civiele datumvelden (Y, M, D, H, Min, S) in UTC naar een Unix Epoch-integer telt het exacte aantal dagen vanaf 1970-01-01 volgens de 400-jarige gregoriaanse schrikkelcyclus (jaren deelbaar door 4 zijn schrikkeljaren van 366 dagen, behalve eeuwjaren die niet deelbaar zijn door 400—waardoor 2000 een schrikkeljaar is terwijl 2100 365 dagen telt) en vermenigvuldigt dit met 86.400:

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

Wanneer de invoervelden de lokale kloktijd in een IANA-tijdzone vertegenwoordigen in plaats van UTC, is de UTC-offset zelf een functie van de doeldatum, omdat regio's hun standaard-offsets en zomertijdregels (Daylight Saving Time, DST) in de loop der tijd aanpassen.

Gesloten `23:59:59`-grenzen vs. Halfopen `[start, nextStart)`-query-intervallen

Grenstabellen vermelden vaak de inclusieve laatste hele seconde van een UTC-dag (bijvoorbeeld 1784159999 voor 2026-07-15T23:59:59Z) naast de milliseconde-tegenhanger (1784159999999 voor 23:59:59.999Z). In productiedatabases die milliseconde-, microseconde- of TIMESTAMPTZ-kolommen opslaan, laat filteren met WHERE created_at BETWEEN 1784073600 AND 1784159999 stilletjes alle events vallen die tijdens de laatste 999 milliseconden van de dag zijn vastgelegd (zoals 23:59:59.450Z).

Om dataverlies op sub-secondegrenzen te elimineren zonder uw query te koppelen aan de kolomresolutie, geeft u de voorkeur aan halfopen predicaten die zijn verankerd aan de 00:00:00-start van de volgende periode (1784160000, oftewel 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

Zomertijd-gaten (Gaps), Overlappingen (Folds) & Lokale Dagen die geen 86.400 Seconden Duren

Bereken lokale daggrenzen nooit door simpelweg 86400 op te tellen bij het lokale middernacht. In IANA-tijdzones die zomertijd hanteren (zoals Europe/Amsterdam, America/New_York of Europe/London), duren twee kalenderdagen per jaar geen 86.400 seconden:

  • Vooruitzetten in het voorjaar / Spring-forward gap (23-urige dag = 82.800 seconden): Wanneer de klok van 01:59:59 direct naar 03:00:00 springt, bestaan lokale kloktijden zoals 02:30:00 niet op die kalenderdatum.
  • Terugzetten in het najaar / Fall-back fold (25-urige dag = 90.000 seconden): Wanneer de klok 01:00:00 tot en met 01:59:59 (of 02:00:00 t/m 02:59:59 in CET/CEST) herhaalt, wordt een lokale kloktijd zoals 01:30:00 afgebeeld op twee verschillende Unix Epoch-integers met een verschil van 3.600 seconden (eerst onder zomertijd, daarna onder wintertijd/standaardtijd).

Door elke 00:00:00-grens via de IANA-tijdzonedatabase te berekenen, blijven begin-van-de-dag en begin-van-de-maand epochs exact over zomertijdovergangen heen.

Wall-Clock Epochs vs. Monotone Duur-timers

Runtime-aanroepen zoals Date.now(), time.time(), time.Now().Unix() en SystemTime::now() lezen de systeemklok van het besturingssysteem (CLOCK_REALTIME). Dit is essentieel voor geserialiseerde tijdstempels en correlatie tussen verschillende machines, maar kan tijdens NTP-synchronisatie terugspringen of vertragen (slewing). Gebruik Unix Epoch-delta's voor opgeslagen historische tijdstempels en combineer ze met monotone klokken (performance.now(), time.monotonic_ns(), std::time::Instant) bij het benchmarken van in-process latentie.

Epoch-tijd Workbench vs. Unix Timestamp Omzetten: Welke Heeft U Nodig?

Kort antwoord: Gebruik de Epoch-tijd Workbench om de live Unix-klok te volgen, tijdstempels samen te stellen uit J/M/D/U/M/S-invoer, grenstabellen voor dag/week/maand/jaar op te halen, delta's tussen twee tijdstempels te berekenen of taal-snippets te kopiëren. Gebruik Unix Timestamp Omzetten om losse of batch-gewijze s-, ms-, µs- en ns-integers en ISO-8601- of RFC 3339-strings te decoderen.

Beide Utiliome-tools draaien 100% lokaal in uw browser en maken een helder onderscheid tussen interactieve Epoch-constructie & bereikplanning en hoge-precisie payload-decodering & batch-logconversie. Blijf in de Epoch-tijd Workbench wanneer u querygrenzen opbouwt, de live Unix-klok volgt, tijdsverschillen (delta's) berekent of taal-snippets kopieert. Schakel over naar de zustermodule Unix Timestamp Omzetten wanneer u ruwe 10-, 13-, 16- of 19-cijferige tijdstempels of log-extracten van meerdere regels wilt decoderen.

Functionaliteit Epoch-tijd Workbench Unix Timestamp Omzetten
Primaire Workflow Live klok, J/M/D/U/M/S-bouwer, periodegrenzen, delta's & code-snippets Bidirectionele s/ms/µs/ns-tijdstempel & ISO-8601/RFC 3339 batch-decodering
Live Unix Epoch-klok Ja — realtime seconden- & millisecondenteller met pauzeer-/vastlegfunctie Niet inbegrepen — gericht op deterministische payload-conversie
J/M/D/U/M/S-veldbouwer Interactieve kalenderveldinvoer in UTC of elke IANA-tijdzone Parset geplakte ISO-8601-, RFC 3339- en RFC 2822-strings rechtstreeks
Dag / Week / Maand / Jaar-tabellen erekent vooraf start- en eind-Epoch-integers voor alle vier de perioden Niet inbegrepen
Delta-calculator voor Twee Tijdstempels Volledige T2 - T1-uitsplitsing (d/h/m/s/ms en ISO-8601 PnDTnHnMnS) Alleen relatieve offset ten opzichte van de huidige systeemklok
16-cijferige µs & 19-cijferige ns BigInt Gericht op seconden (10-cijferig) en milliseconden (13-cijferig) Volledige 64-bit BigInt auto-detectie voor s, ms, µs en 19-cijferige ns
Multi-line Batch-conversie Enkele referentiedatum + paar van twee tijdstempels voor delta Ja — converteert honderden door regeleindes gescheiden tijdstempels in één keer

Inspecteert u 19-cijferige OpenTelemetry nanoseconde-spans, 16-cijferige PostgreSQL microseconde-waarden of een lijst met gemengde log-tijdstempels? Open dan Unix Timestamp Omzetten.

Veelgestelde vragen

Epoch-tijd Workbench FAQ en Technische Gids

Alles wat je moet weten over het gebruik van Utiliome's gratis online epoch converter.

Waarom zouden SQL- en tijdreeksquery's halfopen Epoch-grenzen moeten gebruiken in plaats van 23:59:59?

Een inclusieve bovengrens die eindigt op 23:59:59 (zoals 1784159999) sluit elk record uit dat fractionele milliseconden of microseconden bevat tussen 23:59:59.001 en 23:59:59.999. Door een halfopen predicaat te schrijven dat is verankerd aan de 00:00:00-start van de volgende periode (ts >= 1784073600 AND ts < 1784160000 in seconden, of ts >= 1784073600000 AND ts < 1784160000000 in milliseconden), vangt u de volledige dag foutloos op, ongeacht de sub-secondeprecisie.

Waarom duurt een lokale kalenderdag niet altijd 86.400 Epoch-seconden?

Een UTC-dag beslaat altijd exact 86.400 POSIX-seconden, maar een IANA-tijdzone die zomertijd (Daylight Saving Time) hanteert, kent één dag van 23 uur (82.800 seconden) wanneer de klok in het voorjaar vooruit wordt gezet en één dag van 25 uur (90.000 seconden) wanneer de klok in het najaar terug wordt gezet. Omdat het optellen van 86.400 bij het lokale middernacht de grenzen bij een zomertijdovergang met een uur verschuift, berekent de grenstabel elk lokaal 00:00:00-moment rechtstreeks via de IANA-tijdzonedatabase.

Hoe gaat de J/M/D/U/M/S-bouwer om met dubbelzinnige of niet-bestaande uren tijdens de zomertijdovergang?

Tijdens een overgang naar de zomertijd (bijvoorbeeld wanneer de klok van 02:00 naar 03:00 springt in America/New_York of Europe/Amsterdam), bestaan de klokminuten binnen het overgeslagen uur niet en schuiven ze door over het overgangsgat. Tijdens het terugzetten naar de wintertijd komt het herhaalde uur twee keer voor—met een tussenpoos van 3.600 seconden—eerst onder de eerdere zomertijd-offset en daarna onder de latere standaard-offset. Voor cron-jobs en facturatie-cutoffs die strikte monotonie vereisen, definieert u grenzen altijd in UTC.

Hoe worden ISO-8601-weekgrenzen gedefinieerd in de grenstabel?

Volgens de ISO-8601-regels begint elke week op maandag om 00:00:00 en eindigt deze op zondag om 23:59:59.999. ISO-week 1 (W01) van elk jaar is gedefinieerd als de week van maandag tot en met zondag die de eerste donderdag van het jaar bevat (oftewel de week waarin 4 januari valt), wat betekent dat W01 al op 29, 30 of 31 december van het voorgaande kalenderjaar kan beginnen.

Waarom gebruiken GNU Linux en macOS Bash-commando's verschillende vlaggen om een Epoch-integer te formatteren?

GNU coreutils date op Linux parset een Unix Epoch-integer met het voorvoegsel -d @TIMESTAMP (date -u -d @1784125800 +%Y-%m-%dT%H:%M:%SZ), terwijl BSD date op macOS en FreeBSD de vlag -r TIMESTAMP gebruikt (date -u -r 1784125800 +%Y-%m-%dT%H:%M:%SZ). Beide platformen ondersteunen date +%s op identieke wijze voor het afdrukken van de huidige Unix Epoch in seconden.