Workbench Epoch Time

Monitora l'orologio Unix Epoch in tempo reale, genera timestamp da campi A/M/G/O/M/S, ispeziona i limiti di periodo e calcola i delta di durata nel browser.

Nessun caricamentoNessuna registrazioneRisultati istantanei
Giorno / Settimana / Mese / AnnoCalcolatore delta EpochSQL, JS, Python, Go e Bash
Apri Epoch Workbench
Motore offline prontoSpazio di lavoro 100% privato nel browser • Zero upload in cloud
100% Privato • Nessun Caricamento File su Server

Perché usare il Workbench Epoch Time gratuito di Utiliome?

Creato da zero per garantire massima privacy, esecuzione istantanea e zero intoppi. Senza abbonamento né registrazione.

Orologio Live e Generatore Data A/M/G/O/M/S

Monitora un orologio Unix Epoch in tempo reale (con funzione di pausa) in secondi e millisecondi, oppure costruisci interi Epoch esatti a partire da campi separati per anno, mese, giorno, ora, minuto e secondo in UTC o in qualsiasi fuso orario IANA.

Tabelle dei Limiti per Giorno, Settimana, Mese e Anno

Genera i timestamp Epoch di inizio e fine periodo per la data attiva in UTC e nei fusi orari IANA, pronti da incollare in clausole SQL WHERE, query Prometheus o filtri di analytics.

Calcolatore della Durata Delta tra Due Timestamp

Calcola il tempo trascorso (con segno e assoluto) tra due interi Epoch qualsiasi, scomponendo la durata in giorni, ore, minuti, secondi, millisecondi e stringhe di durata canoniche ISO-8601 (PnDTnHnMnS).

Snippet Multi-Linguaggio Pronti all'Uso

Copia snippet idiomatici per ottenere l'epoch corrente e convertire timestamp in JavaScript, Python, Go, Rust, PostgreSQL/MySQL e Bash, tutti calcolati localmente nel browser senza alcuna richiesta di rete.

Utiliome vs le alternative cloud tradizionali

Confronta il nostro motore locale WebAssembly con i vecchi strumenti in cloud.

Funzionalità Utiliome (Browser Locale) Convertitori Cloud Datati
Orologio Live e Generatore Data A/M/G/O/M/S Monitora un orologio Unix Epoch in tempo reale (con funzione di pausa) in secondi e millisecondi, oppure costruisci interi Epoch esatti a partire da campi separati per anno, mese, giorno, ora, minuto e secondo in UTC o in qualsiasi fuso orario IANA. Opzioni limitate senza personalizzazione avanzata
Tabelle dei Limiti per Giorno, Settimana, Mese e Anno Genera i timestamp Epoch di inizio e fine periodo per la data attiva in UTC e nei fusi orari IANA, pronti da incollare in clausole SQL WHERE, query Prometheus o filtri di analytics. Richiede strumenti esterni o modifiche manuali
Privacy e Elaborazione Dati Elaborazione 100% locale nel browser (zero upload) Carica i dati su server cloud di terze parti
Prezzo e Registrazione 100% gratuito per sempre senza registrazione Richiede registrazione o abbonamento a pagamento
Come funziona

Come usare Workbench Epoch Time in 3 semplici passaggi

Nessuna installazione richiesta. Tutto viene eseguito direttamente nel tuo browser web.

1

Cattura l'Ora Live o Costruisci una Data A/M/G/O/M/S

Blocca l'orologio Unix Epoch in tempo reale sull'istante corrente, inserisci valori discreti per anno, mese, giorno, ora, minuto e secondo, oppure carica un intero Epoch di riferimento in UTC o in un fuso orario IANA.

2

Ispeziona i Limiti di Periodo e Calcola i Delta

Controlla gli interi Epoch di inizio e fine per il giorno, la settimana ISO, il mese e l'anno corrispondenti, oppure fornisci un secondo timestamp per calcolare l'esatta durata trascorsa.

3

Copia Intervalli per Query o Snippet di Codice

Copia gli interi di inizio e fine periodo in secondi o millisecondi direttamente nei filtri SQL o di osservabilità, oppure preleva snippet Epoch pronti all'esecuzione per JavaScript, Python, Go, Rust, SQL e Bash.

Costruzione di Intervalli Epoch, Limiti di Data e Delta di Durata

Risposta Rapida: Assembla un intero Unix Epoch a partire da campi discreti A/M/G/O/M/S in UTC o in un fuso orario IANA per ottenere istantaneamente i limiti di inizio e fine di giorno, settimana ISO, mese e anno, oltre ai delta di durata tra due timestamp e snippet di codice pronti da copiare.

Quando si scrivono migrazioni di database, si pianificano soglie di taglio per job cron o si delimitano query di osservabilità, raramente si parte da un intero grezzo a 10 cifre: si parte invece da una data di calendario, un fuso orario e una finestra di reporting. Inserendo 2026-07-15 14:30:00 in UTC nel Generatore A/M/G/O/M/S, lo strumento risolve l'istante desiderato e popola la tabella completa dei limiti di periodo circostanti in secondi e millisecondi:

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

Per misurare l'MTTR di un incidente, le finestre SLA o il TTL dei token, inserisci due timestamp nel Calcolatore Delta e copia le espressioni per l'epoch corrente dalla sezione Snippet Multi-Linguaggio:

# Calcolo Delta tra Due Timestamp
Timestamp A (Inizio): 1784125800 (2026-07-15T14:30:00Z)
Timestamp B (Fine):   1784310325 (2026-07-17T17:45:25Z)
Delta con Segno:      +184525 s (+184525000 ms)
Scomposizione Umana:  2 days, 3 hours, 15 minutes, 25 seconds (51h 15m 25s)
Durata ISO-8601:      P2DT3H15M25S

# Snippet Pronti all'Uso per l'Unix Epoch Corrente
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

Aritmetica da Calendario a Epoch, Transizioni Ora Legale e Query su Intervalli

Risposta Rapida: La mappatura dei campi civili A/M/G/O/M/S e dei limiti dei periodi di calendario in interi Unix Epoch si basa sul conteggio dei giorni nel calendario gregoriano prolettico, su predicati SQL semi-aperti [start, nextStart) che preservano le frazioni dell'ultimo secondo e sulla risoluzione di salti e sovrapposizioni dell'ora legale (DST) tramite il database IANA.

Aritmetica da Calendario Gregoriano Prolettico a Epoch

La conversione di campi civili discreti (Y, M, D, H, Min, S) in UTC in un intero Unix Epoch conta i giorni esatti trascorsi dal 1970-01-01 secondo il ciclo bisestile gregoriano di 400 anni (gli anni divisibili per 4 sono bisestili di 366 giorni, ad eccezione degli anni secolari non divisibili per 400, rendendo il 2000 bisestile mentre il 2100 ha 365 giorni) e moltiplica il risultato per 86.400:

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

Quando i campi di input rappresentano l'ora locale (wall time) in un fuso orario IANA anziché in UTC, l'offset UTC stesso è una funzione della data target, poiché le regioni modificano gli offset standard e le regole dell'ora legale (DST) nel corso del tempo.

Limiti Chiusi `23:59:59` vs Intervalli di Query Semi-Aperti `[start, nextStart)`

Le tabelle dei limiti elencano comunemente l'ultimo secondo intero inclusivo di un giorno UTC (ad esempio 1784159999 per 2026-07-15T23:59:59Z) insieme al suo equivalente in millisecondi (1784159999999 per 23:59:59.999Z). Nei database di produzione che memorizzano colonne in millisecondi, microsecondi o TIMESTAMPTZ, filtrare con WHERE created_at BETWEEN 1784073600 AND 1784159999 scarta silenziosamente gli eventi registrati durante gli ultimi 999 millisecondi della giornata (come 23:59:59.450Z).

Per eliminare la perdita di dati sub-secondo ai margini senza vincolare la query alla risoluzione della colonna, è preferibile usare predicati semi-aperti ancorati all'inizio 00:00:00 del periodo successivo (1784160000, ovvero 1784159999 + 1):

-- Intervallo semi-aperto (cattura ogni frazione di secondo fino a 23:59:59.999999...)
WHERE epoch_sec >= 1784073600 AND epoch_sec < 1784160000
WHERE epoch_ms  >= 1784073600000 AND epoch_ms < 1784160000000

Salti, Sovrapposizioni dell'Ora Legale (DST) e Giorni Locali Non di 86.400 Secondi

Non calcolare mai i limiti di un giorno locale aggiungendo 86400 alla mezzanotte locale. Nei fusi orari IANA che osservano l'ora legale (come America/New_York o Europe/London), due giorni di calendario all'anno non durano 86.400 secondi:

  • Salto in avanti primaverile (giorno di 23 ore = 82.800 secondi): Quando gli orologi passano direttamente dalle 01:59:59 alle 03:00:00, gli orari locali come le 02:30:00 non esistono in quella data di calendario.
  • Ripetizione autunnale (giorno di 25 ore = 90.000 secondi): Quando gli orologi ripetono l'intervallo dalle 01:00:00 alle 01:59:59, un orario locale come le 01:30:00 corrisponde a due distinti interi Unix Epoch separati da 3.600 secondi (prima nell'ora legale, poi nell'ora solare).

Risolvere l'istante 00:00:00 di ciascun limite tramite il database dei fusi orari IANA mantiene esatti gli epoch di inizio giorno e inizio mese anche attraverso le transizioni DST.

Epoch dell'Orologio di Sistema vs Timer Monotonici di Durata

Le chiamate di runtime come Date.now(), time.time(), time.Now().Unix() e SystemTime::now() leggono l'orologio di sistema del sistema operativo (CLOCK_REALTIME), essenziale per i timestamp serializzati e la correlazione tra macchine diverse, ma soggetto a salti all'indietro o variazioni di velocità (slew) durante la sincronizzazione NTP. Usa i delta Unix Epoch per i timestamp storici persistiti e abbinali a orologi monotonici (performance.now(), time.monotonic_ns(), std::time::Instant) quando misuri la latenza in-process.

Workbench Epoch Time vs Convertitore Timestamp Unix: Quale Scegliere?

Risposta Rapida: Usa il Workbench Epoch Time per monitorare l'orologio Unix live, assemblare timestamp da input A/M/G/O/M/S, ottenere tabelle dei limiti di giorno/settimana/mese/anno, calcolare i delta tra due timestamp o copiare snippet di codice. Usa il Convertitore Timestamp Unix per decodificare interi singoli o in batch in s, ms, µs e ns e stringhe ISO-8601 o RFC 3339.

Entrambi gli strumenti di Utiliome vengono eseguiti al 100% localmente nel tuo browser, separando nettamente la costruzione interattiva di valori Epoch e la pianificazione di intervalli dalla decodifica di payload ad alta precisione e conversione batch di log. Rimani nel Workbench Epoch Time quando stai costruendo limiti per query, monitorando l'orologio Unix in tempo reale, calcolando delta di durata o copiando snippet nei vari linguaggi. Passa invece allo strumento complementare Convertitore Timestamp Unix quando hai timestamp grezzi a 10, 13, 16 o 19 cifre o estratti di log multi-riga da decodificare.

Funzionalità Workbench Epoch Time Convertitore Timestamp Unix
Flusso di Lavoro Principale Orologio live, generatore A/M/G/O/M/S, limiti di periodo, delta e snippet di codice Decodifica bidirezionale e batch di timestamp s/ms/µs/ns e stringhe ISO-8601/RFC 3339
Orologio Unix Epoch Live Sì — contatore in tempo reale in secondi e millisecondi con blocco/cattura Non incluso — focalizzato sulla conversione deterministica di payload
Generatore Campi A/M/G/O/M/S Input interattivi per i campi del calendario in UTC o qualsiasi fuso IANA Analizza direttamente stringhe ISO-8601, RFC 3339 e RFC 2822 incollate
Tabelle Giorno / Settimana / Mese / Anno Precalcola gli interi Epoch di inizio e fine per tutti e quattro i periodi Non incluso
Calcolatore Delta tra Due Timestamp Scomposizione completa T2 - T1 (d/h/m/s/ms e formato ISO-8601 PnDTnHnMnS) Solo offset relativo rispetto all'orologio di sistema corrente
BigInt a 16 Cifre (µs) e 19 Cifre (ns) Focalizzato su secondi (10 cifre) e millisecondi (13 cifre) Rilevamento automatico BigInt a 64 bit completo tra s, ms, µs e ns a 19 cifre
Conversione Batch Multi-Riga Data di riferimento singola + coppia di timestamp per calcolo delta Sì — converte centinaia di timestamp separati da a capo in un solo passaggio

Devi ispezionare span OpenTelemetry in nanosecondi a 19 cifre, valori PostgreSQL in microsecondi a 16 cifre o un dump multi-riga di timestamp di log misti? Apri il Convertitore Timestamp Unix.

Domande frequenti

FAQ e Guida Tecnica su Workbench Epoch Time

Tutto ciò che devi sapere sull'uso di convertitore epoch time online e gratuito di Utiliome.

Perché le query SQL e su serie temporali dovrebbero usare limiti Epoch semi-aperti invece di 23:59:59?

Un limite superiore inclusivo che termina alle 23:59:59 (come 1784159999) esclude qualsiasi record contenente frazioni di millisecondi o microsecondi comprese tra 23:59:59.001 e 23:59:59.999. Scrivere un predicato semi-aperto ancorato all'inizio 00:00:00 del periodo successivo (ts >= 1784073600 AND ts < 1784160000 in secondi, oppure ts >= 1784073600000 AND ts < 1784160000000 in millisecondi) cattura l'intera giornata in modo pulito, indipendentemente dalla precisione sub-secondo.

Perché un giorno di calendario locale non dura sempre 86.400 secondi Epoch?

Un giorno UTC dura sempre esattamente 86.400 secondi POSIX, ma un fuso orario IANA che osserva l'ora legale (DST) sperimenta un giorno di 23 ore (82.800 secondi) quando gli orologi vengono spostati in avanti in primavera e un giorno di 25 ore (90.000 secondi) quando vengono riportati indietro in autunno. Poiché aggiungere 86.400 alla mezzanotte locale sposta i limiti di un'ora durante le transizioni DST, la tabella dei limiti risolve ogni istante locale 00:00:00 consultando il database dei fusi orari IANA.

Come gestisce il generatore A/M/G/O/M/S le ore dell'ora legale ambigue o inesistenti?

Durante una transizione in avanti verso l'ora legale (ad esempio il salto dalle 02:00 alle 03:00 in America/New_York), i minuti dell'orologio locale all'interno dell'ora saltata non esistono e avanzano oltre il divario di transizione. Durante il ritorno all'ora solare, l'ora ripetuta si verifica due volte — a 3.600 secondi di distanza — prima con l'offset dell'ora legale e poi con l'offset standard. Per job cron e chiusure di fatturazione che richiedono una stretta monotonicità, è consigliabile definire i limiti in UTC.

Come vengono definiti i limiti delle settimane ISO-8601 nella tabella dei limiti?

Seguendo le regole ISO-8601, ogni settimana inizia il lunedì alle 00:00:00 e termina la domenica alle 23:59:59.999. La Settimana ISO 1 (W01) di qualsiasi anno è definita come la settimana da lunedì a domenica che contiene il primo giovedì dell'anno (o, in modo equivalente, la settimana che contiene il 4 gennaio); ciò significa che W01 può iniziare il 29, 30 o 31 dicembre dell'anno solare precedente.

Perché i comandi Bash su GNU Linux e macOS usano flag diversi per formattare un intero Epoch?

Il comando date di GNU coreutils su Linux analizza un intero Unix Epoch usando il prefisso -d @TIMESTAMP (date -u -d @1784125800 +%Y-%m-%dT%H:%M:%SZ), mentre il comando date BSD su macOS e FreeBSD utilizza il flag -r TIMESTAMP (date -u -r 1784125800 +%Y-%m-%dT%H:%M:%SZ). Entrambe le piattaforme supportano invece in modo identico date +%s per stampare l'Unix Epoch corrente in secondi.