Skip to content

Convertitore Timestamp Unix ed Epoch — Multi-Precisione

Converti timestamp Unix in date all'istante. Rileva automaticamente secondi, millisecondi e microsecondi. Orologio live, bidirezionale. Gratis e privato online.

Niente tracciamento Funziona nel browser Gratuito
Tutta l'elaborazione avviene nel tuo browser. Nessun dato viene inviato ad alcun server.

Timestamp Unix Corrente

0

Riferimento Rapido

Esempi di Codice

Revisionato per conformità POSIX e accuratezza di precisione — Team di Ingegneria Go Tools · Mar 22, 2026

Cos'è un Timestamp Unix (Tempo Epoch)?

Un timestamp Unix (chiamato anche tempo Epoch o tempo POSIX) è il numero di secondi trascorsi dal 1 gennaio 1970 00:00:00 UTC e funge da riferimento temporale universale per praticamente tutti i sistemi di calcolo. Dai kernel Linux ai database SQL, dai motori JavaScript ai sistemi operativi mobili, praticamente ogni piattaforma moderna memorizza e scambia il tempo come timestamp Unix.

Come definito formalmente da IEEE Std 1003.1 (POSIX): "L'epoca Unix (1 gennaio 1970 00:00:00 UTC) funge da punto zero per il tempo POSIX" — una convenzione così universalmente adottata da essere ora lo standard de facto per i timestamp leggibili dalle macchine in tutto il mondo. I timestamp Unix sono usati dalla stragrande maggioranza di sistemi lato server, database e protocolli di rete, inclusi header HTTP, token JWT e praticamente ogni API REST.

L'epoca Unix stessa — 1 gennaio 1970 — non è stata scelta arbitrariamente. Unix è stato sviluppato ai Bell Labs alla fine degli anni '60, e il 1970 era un punto di partenza comodo e rotondo, abbastanza recente da rappresentare tutte le date rilevanti con dimensioni intere gestibili. Qualsiasi istante nel tempo può essere espresso come conteggio di secondi in un intero con segno a 64-bit da quel punto di ancoraggio. Le date precedenti all'epoca sono rappresentate come numeri negativi: il 31 dicembre 1969 a mezzanotte UTC è -86400 (un giorno, ovvero 86.400 secondi, prima dell'epoca).

I sistemi moderni spesso necessitano di una risoluzione temporale più fine dei secondi interi. Per accogliere questo, i timestamp sono comunemente espressi in millisecondi (millesimi di secondo, come restituito da `Date.now()` di JavaScript o `System.currentTimeMillis()` di Java) o microsecondi (milionesimi di secondo, usati in database come PostgreSQL e in sistemi di trading ad alta frequenza). Puoi identificare la precisione dal numero di cifre: 10 cifre indicano secondi, 13 cifre indicano millisecondi e 16 cifre indicano microsecondi. Questo convertitore rileva automaticamente la precisione del tuo input.

I timestamp Unix sono la spina dorsale del calcolo distribuito perché sono indipendenti dal fuso orario, incrementano monotonicamente (in condizioni normali) e sono banalmente ordinabili come interi. Memorizzare i tempi come timestamp e convertirli in formati leggibili solo al momento della visualizzazione è una best practice che elimina intere categorie di bug sui fusi orari. Il compromesso è la leggibilità — un timestamp grezzo come 1741965432 è opaco senza un convertitore, che è esattamente ciò che questo strumento fornisce.

Tutte le conversioni avvengono interamente nel tuo browser usando l'API Date di JavaScript — nessun timestamp, data o altro dato viene mai inviato a un server. Questo strumento converte istantaneamente qualsiasi timestamp Unix — incluso il tempo epoch corrente mostrato nell'orologio live sopra — in una data leggibile, con completa privacy.

I timestamp sono strettamente correlati ad altri strumenti per sviluppatori. UUID v1 e v7 incorporano i timestamp direttamente nei loro identificatori, e le risposte API contenenti timestamp sono spesso ispezionate al meglio usando un formattatore JSON per leggibilità. Per una guida approfondita che copre precisione, gestione dei fusi orari e insidie del DST con esempi di codice in JavaScript, Python e Go, leggi la nostra guida ai timestamp Unix.

// Get the current Unix timestamp in JavaScript
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // → 1741965432

// Milliseconds (native JavaScript)
const timestampMs = Date.now();
console.log(timestampMs); // → 1741965432000

// Convert timestamp back to a Date object
const date = new Date(timestampSeconds * 1000);
console.log(date.toISOString()); // → '2025-03-14T15:37:12.000Z'

// Python equivalent
// import time
// timestamp = int(time.time())  # → 1741965432

Caratteristiche Principali

Rilevamento Automatico della Precisione

Rileva automaticamente se il tuo timestamp è in secondi (10 cifre), millisecondi (13 cifre) o microsecondi (16 cifre) — nessun cambio di modalità manuale richiesto.

Conversione Bidirezionale

Converti i timestamp in date leggibili, oppure scegli una qualsiasi data e ora per ottenere istantaneamente il timestamp Unix corrispondente in tutti e tre i formati di precisione.

Orologio Epoch Live

Vedi il timestamp Unix corrente scorrere in tempo reale per avere sempre un punto di riferimento accurato per le tue conversioni e calcoli.

Output Multi-Formato

Ogni conversione produce simultaneamente tempo UTC, il tuo fuso orario locale, formato ISO 8601 e un tempo relativo leggibile (es. "3 giorni fa").

Elaborazione 100% Lato Browser

Tutte le conversioni avvengono interamente nel tuo browser usando l'API Date di JavaScript. Nessun timestamp, data o dato personale viene trasmesso ad alcun server.

Timestamp Unix vs Altri Formati di Data

ISO 8601

2025-03-14T15:37:12Z

Sia leggibile che ordinabile lessicograficamente. Lo standard per lo scambio di dati e le API. Preferito ai timestamp Unix quando la leggibilità umana conta.

RFC 2822

Fri, 14 Mar 2025 15:37:12 +0000

Leggibile ma non ordinabile. Usato principalmente negli header email (campo Date). Meno compatto di ISO 8601 e dei timestamp Unix.

Data Umana

14 Marzo 2025 15:37

Il formato più leggibile per gli utenti finali ma non ordinabile né adatto all'uso programmatico. Meglio riservarlo ai livelli di visualizzazione UI.

Esempi di Conversione

Timestamp Unix Standard (secondi)

1741965432
2025-03-14T15:37:12Z

Un timestamp a 10 cifre in secondi — il formato più comune usato da sistemi Unix/Linux, API Unix, token JWT e log del server. Questo particolare valore corrisponde al Pi Day 2025 alle 15:37:12 UTC.

Timestamp Y2K — 1 Gennaio 2000

946684800
2000-01-01T00:00:00Z

Il timestamp Unix per il momento Y2K: esattamente 946.684.800 secondi dopo l'epoca Unix. Questo è un valore di calibrazione utile — se il tuo convertitore produce 1 gennaio 2000 per questo input, sta funzionando correttamente.

Timestamp Negativo (Prima dell'Epoca)

-86400
1969-12-31T00:00:00Z

I timestamp Unix negativi rappresentano date precedenti al 1 gennaio 1970. Il valore -86400 è esattamente un giorno (86.400 secondi) prima dell'epoca, che corrisponde al 31 dicembre 1969 a mezzanotte UTC. Non tutti i sistemi supportano timestamp negativi, ma questo convertitore li gestisce correttamente.

Timestamp in Millisecondi (13 cifre)

1741965432000
2025-03-14T15:37:12.000Z

Un timestamp a 13 cifre in millisecondi — il formato nativo usato da Date.now() di JavaScript, System.currentTimeMillis() di Java e la maggior parte delle API REST moderne. È equivalente al primo esempio moltiplicato per 1000. Il rilevatore automatico riconosce la lunghezza di 13 cifre e lo interpreta correttamente come millisecondi.

Come Convertire un Timestamp Unix in Data

  1. 1

    Seleziona la Direzione della Conversione

    Scegli "Timestamp → Data" per decodificare un timestamp Unix in una data leggibile, oppure "Data → Timestamp" per convertire una data e ora del calendario in un timestamp Unix.

  2. 2

    Inserisci il Tuo Valore

    Incolla o digita un timestamp Unix (es. 1741965432 o 1741965432000) nel campo di input. Lo strumento identifica automaticamente se si tratta di secondi, millisecondi o microsecondi. Per Data → Timestamp, seleziona anno, mese, giorno, ora, minuto e secondo usando il selettore di data.

  3. 3

    Copia il Risultato Convertito

    Vedi istantaneamente il risultato in UTC, ora locale, ISO 8601 e tempo relativo. Clicca sul pulsante Copia accanto a qualsiasi formato per copiarlo direttamente negli appunti.

Casi d'Uso Comuni

Sviluppo e Debug di API
Decodifica timestamp opachi nelle risposte API, nei payload dei token JWT (claim iat, exp, nbf), nei dati degli eventi webhook e nelle voci di log. Verifica istantaneamente se un token di autenticazione è scaduto o quando è avvenuto un evento.
Archiviazione Database e Query con Timestamp
Converti tra timestamp Unix e date leggibili quando scrivi query di database, ispezioni record memorizzati o valida che i filtri di intervallo di date siano specificati correttamente nelle tue clausole WHERE.
Analisi e Correlazione di File di Log
Molti log di sistema e applicazione registrano eventi come timestamp Unix. Converti voci di log sospette in ore leggibili per correlare eventi tra più servizi, identificare finestre di attacco o individuare il momento esatto in cui è avvenuto un errore.
Verifica della Scadenza dei Token JWT
I JSON Web Token codificano iat (emesso a), exp (scade a) e nbf (non prima) come timestamp Unix nel loro payload. Incolla questi valori direttamente per verificare le finestre di validità del token senza fare manualmente la matematica dell'epoca.
Pianificazione di Cron Job
Verifica che le pianificazioni dei cron job, le attività schedulate e i trigger basati sul tempo si allineino con le finestre di esecuzione previste convertendo i tempi di esecuzione proposti in timestamp e viceversa.
Coordinamento di Date Cross-Fuso Orario
I timestamp Unix sono intrinsecamente neutrali rispetto al fuso orario. Usa questo convertitore per stabilire un punto di riferimento condiviso quando coordini date e scadenze tra team in fusi orari diversi, confermando l'equivalente UTC di qualsiasi ora locale.

Riferimento Tecnico

Definizione di Timestamp Unix
Un timestamp Unix è il conteggio intero di secondi trascorsi dall'epoca Unix: 1 gennaio 1970, 00:00:00 UTC (Coordinated Universal Time). Il valore è lo stesso indipendentemente dal fuso orario locale dell'osservatore, rendendolo una rappresentazione ideale neutrale rispetto al fuso orario per memorizzare e confrontare i tempi.
Valore Massimo di Intero con Segno a 32-Bit
Il valore massimo di un intero con segno a 32-bit è 2.147.483.647. Come timestamp Unix, corrisponde al 19 gennaio 2038 alle 03:14:07 UTC. I sistemi che memorizzano i timestamp in interi con segno a 32-bit andranno in overflow in questo momento — un problema noto come problema del 2038. I sistemi a 64-bit possono rappresentare date miliardi di anni nel futuro.
JavaScript Usa i Millisecondi
Date.now() e new Date().getTime() di JavaScript restituiscono il numero di millisecondi dall'epoca — non secondi. Questo produce numeri di 13 cifre. Per convertire al timestamp Unix standard in secondi, dividi per 1000 e arrotonda per difetto: Math.floor(Date.now() / 1000). Molte API e strumenti si aspettano i secondi, quindi questo passaggio di conversione è critico.
I Timestamp Negativi Rappresentano Date Pre-Epoca
I timestamp Unix possono essere negativi per rappresentare date precedenti al 1 gennaio 1970. Ad esempio, -86400 rappresenta il 31 dicembre 1969 alle 00:00:00 UTC. L'intervallo di un timestamp con segno a 64-bit si estende da circa 292 miliardi di anni prima dell'epoca a 292 miliardi di anni dopo, più che sufficiente per qualsiasi applicazione pratica.
Il Tempo Unix Non Tiene Conto dei Secondi Intercalari
Il tempo Unix assume esattamente 86.400 secondi per giorno (24 ore × 60 minuti × 60 secondi). In realtà, i secondi intercalari vengono occasionalmente inseriti dall'IERS per mantenere UTC sincronizzato con la rotazione terrestre. Questo significa che il tempo Unix non è perfettamente lineare rispetto al TAI (International Atomic Time), e la differenza cresce nel tempo. Per la maggior parte delle applicazioni questa discrepanza è irrilevante, ma i sistemi di cronometraggio di precisione devono tenerne conto.

Best Practice per la Gestione dei Timestamp

Memorizza Sempre i Timestamp in UTC
Memorizza i timestamp in UTC (o come timestamp Unix) e converti in ora locale solo al livello di visualizzazione. Mescolare fusi orari nel tuo database è una fonte comune di bug difficili da riprodurre e debuggare, specialmente durante le transizioni dell'ora legale.
Usa la Precisione in Millisecondi per le API Moderne
La maggior parte delle API moderne, degli ambienti JavaScript e dei database usa millisecondi (timestamp a 13 cifre) piuttosto che secondi (timestamp a 10 cifre). Quando integri con sistemi esterni, conferma la precisione attesa — passare un timestamp in millisecondi dove ci si aspettano secondi produrrà date circa 11.000 anni nel futuro.
Attenzione al Problema del 2038
I sistemi che memorizzano timestamp Unix in interi con segno a 32-bit andranno in overflow il 19 gennaio 2038 alle 03:14:07 UTC. Verifica i sistemi legacy per campi timestamp a 32-bit e migra a interi a 64-bit o stringhe ISO 8601. La maggior parte dei linguaggi e database moderni usa timestamp a 64-bit per impostazione predefinita, ma sistemi embedded, database più vecchi e file system potrebbero essere ancora a rischio.
Non Affidarti Mai agli Orologi Lato Client per la Sicurezza
Gli orologi dei dispositivi client possono essere impostati su qualsiasi valore, accidentalmente o maliziosamente. Non usare mai un timestamp fornito dal client per logica sensibile alla sicurezza come controlli di scadenza JWT, timeout di sessione o rate limiting. Valida sempre i timestamp sul server usando una sorgente di tempo fidata.
Usa ISO 8601 per lo Scambio Leggibile
Quando hai bisogno di un formato timestamp che sia sia analizzabile dalla macchina sia leggibile — ad esempio, in file di log, file di configurazione o risposte API dove uno sviluppatore potrebbe leggere l'output — ISO 8601 (es. 2025-03-14T15:37:12Z) è la scelta migliore. È ordinabile lessicograficamente, non ambiguo e supportato praticamente da tutti i parser moderni.

Domande Frequenti

Perché il tempo Unix parte dal 1 gennaio 1970?
La data di epoca Unix del 1 gennaio 1970 è stata scelta dagli sviluppatori di Unix ai Bell Labs alla fine degli anni '60 come comodo punto di partenza rotondo che era sia recente sia computazionalmente pratico. All'epoca, i timestamp erano memorizzati in interi a 32-bit, quindi l'epoca doveva essere abbastanza vicina al presente perché le date comuni entrassero in un numero di dimensione ragionevole. Il 1970 era semplicemente un anno pulito e rotondo successivo all'inizio dello sviluppo del sistema. Non c'è alcun significato tecnico profondo specifico per il 1 gennaio 1970 — è stato pragmatismo ingegneristico. Altri sistemi hanno scelto epoche diverse: la classic toolbox del Macintosh usava il 1 gennaio 1904; Windows NT usa il 1 gennaio 1601; il tempo GPS parte dal 6 gennaio 1980. Ognuno riflette l'era e i vincoli di progettazione del sistema che l'ha scelto. Ciò che ha fatto attecchire l'epoca Unix è che Unix è diventato il sistema operativo dominante nel calcolo, e ogni linguaggio di programmazione, database e sistema operativo principale alla fine ha adottato il tempo Unix come standard universale per rappresentare timestamp leggibili dalla macchina. Oggi, l'epoca Unix è effettivamente una costante universale nel calcolo, riconosciuta da ogni piattaforma principale, dai kernel Linux ai motori JavaScript ai database SQL. La scelta ha una conseguenza ben nota: le date precedenti al 1 gennaio 1970 sono rappresentate come numeri negativi, che alcuni sistemi più vecchi non possono gestire. Per date storiche e calcoli astronomici, a volte si preferiscono formati timestamp alternativi. Per la stragrande maggioranza dello sviluppo software, tuttavia, l'epoca Unix copre comodamente tutte le date rilevanti.
Cos'è il problema del 2038?
Il problema del 2038 (chiamato anche Y2K38 o l'Epochalypse) è un problema informatico che affliggerà i sistemi che memorizzano i timestamp Unix come interi con segno a 32-bit. Un intero con segno a 32-bit può contenere valori da -2.147.483.648 a 2.147.483.647. Quando interpretato come timestamp Unix, il valore massimo di 2.147.483.647 corrisponde al 19 gennaio 2038 alle 03:14:07 UTC. Un secondo dopo, il contatore andrà in overflow e tornerà al valore più negativo rappresentabile, che corrisponde al 13 dicembre 1901 — facendo sì che questi sistemi interpretino date future come appartenenti al lontano passato. Le conseguenze possono variare da banali a catastrofiche a seconda di come vengono usati i timestamp. I sistemi potrebbero rifiutare date future valide durante la validazione dell'input, ordinare in modo errato record sensibili al tempo, calcolare male le date di scadenza per certificati e token o andare in crash quando incontrano il valore di overflow. La soluzione è semplice: migrare a interi con segno a 64-bit per l'archiviazione dei timestamp. Un timestamp a 64-bit può rappresentare date circa 292 miliardi di anni prima e dopo l'epoca — molto oltre qualsiasi preoccupazione pratica. La maggior parte dei sistemi operativi, linguaggi di programmazione e database moderni usa già internamente timestamp a 64-bit. Il rischio risiede nel codice legacy, sistemi embedded, sistemi operativi a 32-bit ancora in produzione, metadati di file system (come i campi timestamp di FAT32) e colonne di database definite come INT anziché BIGINT. Gli sviluppatori dovrebbero verificare i loro sistemi ora. La migrazione da timestamp a 32-bit a 64-bit deve avvenire prima del 2038, e in pratica, qualsiasi sistema con record a lungo termine (mutui, asset infrastrutturali, documenti legali) potrebbe incontrare il problema molto prima, man mano che date future vengono inserite nei campi interessati.
Qual è la differenza tra timestamp in secondi, millisecondi e microsecondi?
I timestamp Unix esistono in tre precisioni comuni, distinte dal numero di cifre nel valore: **Secondi (10 cifre)**: Il formato timestamp Unix originale e più comune. `1741965432` rappresenta un secondo specifico nel tempo. Usato da: chiamate di sistema Unix/Linux (`time()`), la maggior parte delle utility Unix, token JWT (claim `iat`, `exp`), header HTTP (`Last-Modified`) e molte API REST. Il timestamp corrente è lungo circa 10 cifre. **Millisecondi (13 cifre)**: Precisione di un millesimo di secondo. `1741965432000` è lo stesso istante di cui sopra, moltiplicato per 1.000. Usato da: `Date.now()` di JavaScript, `System.currentTimeMillis()` di Java, Node.js, la maggior parte delle API JavaScript/TypeScript moderne, Redis e molti client di database. Quando vedi un timestamp di 13 cifre in una risposta API JSON, sono quasi certamente millisecondi. **Microsecondi (16 cifre)**: Precisione di un milionesimo di secondo. `1741965432000000` è lo stesso istante moltiplicato per 1.000.000. Usato da: tipi `TIMESTAMP` e `TIMESTAMPTZ` di PostgreSQL, `time.time_ns()` di Python (sebbene restituisca nanosecondi), sistemi di trading ad alta frequenza e strumenti di analisi dei pacchetti di rete. L'errore più comune è mescolare le precisioni — per esempio, passare un timestamp in millisecondi a una funzione che si aspetta secondi. Questo produce date circa 11.574 anni nel futuro. Controlla sempre la documentazione dell'API o del sistema con cui stai lavorando per confermare la precisione attesa, e usa il rilevamento automatico di questo convertitore come controllo di sanità.
Il tempo Unix tiene conto dei secondi intercalari?
No — il tempo Unix non tiene conto dei secondi intercalari, e questa è una delle sue limitazioni note per le applicazioni di cronometraggio di precisione. I secondi intercalari vengono occasionalmente inseriti (o teoricamente rimossi, anche se nessuno è stato rimosso finora) dall'International Earth Rotation and Reference Systems Service (IERS) per mantenere UTC sincronizzato con la rotazione leggermente irregolare della Terra. Al 2026, sono stati inseriti 27 secondi intercalari da quando furono introdotti per la prima volta nel 1972. Il tempo Unix assume un calendario perfettamente regolare con esattamente 86.400 secondi al giorno (24 × 60 × 60). Quando viene inserito un secondo intercalare, il mondo reale ha un secondo che il tempo Unix ignora. Sistemi operativi diversi gestiscono questo in modo diverso: Linux tradizionalmente "spalma" il secondo intercalare facendo girare l'orologio leggermente lento per un periodo intorno al punto di inserimento (l'approccio di Google, chiamato anche "leap smearing"); alcuni sistemi duplicano il secondo alle 23:59:60 UTC; altri saltano semplicemente l'aggiustamento e lasciano derivare l'orologio. Per la stragrande maggioranza delle applicazioni software — servizi web, API, database, logica di business — i circa 27 secondi di discrepanza accumulata da secondi intercalari in oltre 50 anni sono completamente irrilevanti. La differenza è impercettibile per qualsiasi applicazione rivolta all'utente. Dove contano i secondi intercalari: sincronizzazione GPS, osservazione astronomica, protocolli di temporizzazione di rete a pacchetto (PTP/IEEE 1588) e qualsiasi sistema che debba correlare con precisione i timestamp Unix con TAI (International Atomic Time). Se la tua applicazione rientra in queste categorie, dovresti usare una libreria di cronometraggio che supporti esplicitamente la consapevolezza dei secondi intercalari, o lavorare direttamente con timestamp TAI.
I timestamp Unix possono essere negativi?
Sì, i timestamp Unix possono essere negativi, e i timestamp negativi sono un modo legittimo e ben definito per rappresentare date precedenti all'epoca Unix (1 gennaio 1970, 00:00:00 UTC). Ogni secondo prima dell'epoca corrisponde a un decremento di 1 da zero. Ad esempio, -1 rappresenta il 31 dicembre 1969 alle 23:59:59 UTC; -86400 rappresenta il 31 dicembre 1969 alle 00:00:00 UTC (esattamente un giorno prima dell'epoca); e -2208988800 rappresenta il 1 gennaio 1900 alle 00:00:00 UTC. La maggior parte dei linguaggi di programmazione e sistemi operativi moderni supporta i timestamp negativi. `datetime.fromtimestamp(-86400)` di Python restituisce correttamente il 31 dicembre 1969. `new Date(-86400 * 1000)` di JavaScript visualizza correttamente la stessa data. PostgreSQL memorizza i timestamp come interi a 8 byte e gestisce correttamente date migliaia di anni prima dell'epoca. Tuttavia, ci sono importanti avvertenze. Alcuni sistemi più vecchi, librerie o driver di database potrebbero non supportare correttamente i timestamp negativi. I sistemi a 32-bit che usano interi senza segno per i timestamp non possono rappresentare affatto valori negativi. Alcuni database definiti come tipi UNSIGNED BIGINT o DATETIME potrebbero rifiutare valori negativi o interpretarli come date nel lontano futuro. Per date storiche (qualsiasi cosa prima del 1970), è spesso più sicuro memorizzare la data come stringa ISO 8601 o usare un tipo di data nativo del database piuttosto che affidarsi a timestamp Unix negativi per la portabilità. Questo convertitore gestisce correttamente i timestamp negativi e visualizzerà la data pre-1970 corrispondente.
Come ottengo il timestamp Unix corrente in JavaScript, Python o altri linguaggi?
Ottenere il timestamp Unix corrente è semplice in ogni linguaggio di programmazione principale: **JavaScript / TypeScript:** ```javascript // Seconds (most APIs expect this) const seconds = Math.floor(Date.now() / 1000); // Milliseconds (JavaScript native) const milliseconds = Date.now(); ``` **Python:** ```python import time seconds = int(time.time()) # 1741965432 import datetime milliseconds = int(datetime.datetime.now(datetime.UTC).timestamp() * 1000) ``` **Go:** ```go import "time" seconds := time.Now().Unix() // int64 milliseconds := time.Now().UnixMilli() // int64 microseconds := time.Now().UnixMicro() // int64 ``` **Java:** ```java long seconds = System.currentTimeMillis() / 1000L; long milliseconds = System.currentTimeMillis(); // Or with java.time (Java 8+): long seconds2 = Instant.now().getEpochSecond(); ``` **PHP:** ```php $seconds = time(); // integer $milliseconds = round(microtime(true) * 1000); ``` **Ruby:** ```ruby seconds = Time.now.to_i milliseconds = (Time.now.to_f * 1000).to_i ``` **Bash / Shell:** ```bash date +%s # seconds date +%s%3N # milliseconds (GNU date) ``` La cosa più importante da ricordare è che JavaScript lavora nativamente in millisecondi, mentre praticamente ogni altro linguaggio usa i secondi per impostazione predefinita. Sii sempre esplicito su quale precisione stai usando e documentala nei contratti API per prevenire bug di integrazione.
Come converto il tempo epoch in una data leggibile?
Ci sono tre modi rapidi per convertire il tempo epoch (timestamp Unix) in una data leggibile: **1. Usa questo convertitore online (il più veloce)** Incolla il tuo timestamp epoch nel campo di input sopra. Lo strumento rileva automaticamente se è in secondi, millisecondi o microsecondi e visualizza istantaneamente il risultato in UTC, nel tuo fuso orario locale, ISO 8601 e formati di tempo relativo. Clicca Copia per prendere qualsiasi formato. **2. Usa il codice** In JavaScript: `new Date(1741965432 * 1000).toISOString()` restituisce `'2025-03-14T15:37:12.000Z'`. In Python: `from datetime import datetime, UTC; datetime.fromtimestamp(1741965432, UTC)` restituisce lo stesso risultato. Nota che JavaScript si aspetta millisecondi mentre Python si aspetta secondi — la fonte più comune di bug di conversione. **3. Usa la riga di comando** Su Linux o macOS con GNU date: `date -d @1741965432` (Linux) o `date -r 1741965432` (macOS). Su Windows PowerShell: `[DateTimeOffset]::FromUnixTimeSeconds(1741965432).DateTime`. Tutti e tre i metodi producono lo stesso risultato. Il convertitore online sopra è l'opzione più veloce quando hai solo bisogno di una risposta rapida senza aprire un terminale o scrivere codice.
Qual è il timestamp Unix corrente proprio adesso?
Il timestamp Unix corrente è visualizzato nell'orologio live in cima a questa pagina, aggiornato ogni secondo. Il timestamp Unix è semplicemente il numero di secondi dal 1 gennaio 1970 00:00:00 UTC, e si incrementa esattamente di 1 ogni secondo. Per ottenere il timestamp corrente programmaticamente: - **JavaScript**: `Math.floor(Date.now() / 1000)` (secondi) o `Date.now()` (millisecondi) - **Python**: `import time; int(time.time())` - **Bash**: `date +%s` Al 2026, il timestamp Unix corrente è nell'intervallo di 1,77 miliardi (10 cifre). Raggiungerà i 2 miliardi intorno a maggio 2033, e il valore massimo per i sistemi a 32-bit (2.147.483.647) sarà raggiunto il 19 gennaio 2038 alle 03:14:07 UTC — il cosiddetto problema del 2038. Aggiungi questa pagina ai segnalibri per avere sempre il tempo epoch corrente a un clic di distanza.
Devo fare il debug di un timestamp nella mia risposta API — come lo converto?
Copia il valore del timestamp dalla tua risposta API (tipicamente sarà un numero di 10 o 13 cifre in un campo JSON come "created_at" o "timestamp"). Incollalo direttamente nel campo di input sopra — lo strumento rileva automaticamente se è in secondi o millisecondi e mostra istantaneamente la data UTC, la tua ora locale e il formato ISO 8601. Se il timestamp è annidato all'interno di un token JWT, decodifica prima il payload JWT (che è codificato in Base64URL) per estrarre i campi iat, exp o nbf, quindi incolla quei valori qui. Per il debug batch, usa lo snippet di codice: new Date(timestamp * 1000).toISOString() nella console del tuo browser per controllare rapidamente più timestamp senza lasciare i tuoi dev tool.
Come ottengo il timestamp Unix corrente in Python/JavaScript/Go?
In JavaScript, usa Math.floor(Date.now() / 1000) per i secondi o Date.now() per i millisecondi. In Python, usa import time; int(time.time()) per i secondi, o int(time.time() * 1000) per i millisecondi. In Go, usa time.Now().Unix() per i secondi, time.Now().UnixMilli() per i millisecondi, o time.Now().UnixMicro() per i microsecondi. Ricorda che JavaScript lavora nativamente in millisecondi mentre Python e Go usano i secondi per impostazione predefinita — questa è la singola fonte più comune di bug sui timestamp quando si integrano sistemi scritti in linguaggi diversi. Documenta sempre quale precisione la tua API si aspetta nella tua specifica OpenAPI/Swagger.
Cosa succede ai timestamp Unix durante i cambi dell'ora legale?
I timestamp Unix sono completamente non influenzati dai cambi dell'ora legale (DST) perché sono basati su UTC, che non osserva l'ora legale. Quando gli orologi "saltano avanti" o "tornano indietro" in un fuso orario locale, il timestamp Unix continua a incrementare esattamente di 1 al secondo senza alcun salto o ripetizione. Questo è uno dei vantaggi chiave di memorizzare i tempi come timestamp Unix piuttosto che come stringhe datetime locali. Tuttavia, se converti un timestamp Unix in un'ora locale durante una transizione DST, la stessa ora locale può corrispondere a due diversi timestamp Unix (durante l'ora di "ritorno indietro" quando gli orologi si ripetono). Memorizza e confronta sempre i timestamp in UTC, e converti in ora locale solo per scopi di visualizzazione.
Ho un timestamp in millisecondi — come lo converto in secondi?
Dividi il timestamp in millisecondi per 1000 e scarta la parte decimale. In JavaScript: Math.floor(ms / 1000). In Python: ms // 1000 (divisione intera). Ad esempio, 1741965432000 (millisecondi) diventa 1741965432 (secondi). Puoi identificare i timestamp in millisecondi dalla loro lunghezza di 13 cifre rispetto alla lunghezza di 10 cifre dei timestamp in secondi. Questo strumento rileva automaticamente la precisione, quindi puoi incollare direttamente entrambi i formati. La conversione inversa (da secondi a millisecondi) è semplicemente una moltiplicazione per 1000: 1741965432 * 1000 = 1741965432000. Fai attenzione a non passare accidentalmente un valore in millisecondi a una funzione che si aspetta secondi — il risultato sarebbe una data circa 11.574 anni nel futuro.

Strumenti correlati

Vedi tutti gli strumenti →