Convertitore Timestamp

Cos'è un timestamp Unix?

Un timestamp Unix (detto anche epoch time o POSIX time) è il numero di secondi trascorsi dal 1° gennaio 1970, 00:00:00 UTC. Questa data prende il nome di Unix epoch. Ogni secondo che passa incrementa il contatore di uno, assegnando a ogni istante una rappresentazione intera univoca. Un convertitore di timestamp Unix traduce tra questo intero e formati di data leggibili come ISO 8601, RFC 2822 o stringhe localizzate.

I timestamp Unix sono il metodo standard per rappresentare il tempo nei sistemi informatici. I database memorizzano le colonne created_at e updated_at come interi o timestamp in millisecondi. Le risposte API includono timestamp per gli header di cache (Expires, Last-Modified), i claim JWT (iat, exp, nbf) e i log degli eventi. I file di log di nginx, syslog e dei framework applicativi utilizzano tutti l'epoch time. Il formato è privo di ambiguità perché rappresenta sempre UTC, senza fusi orari o offset per l'ora legale da interpretare erroneamente.

Convertire manualmente tra timestamp e date è soggetto a errori. Un valore come 1711324800 non fornisce alcun indizio visivo sulla data che rappresenta. Questo strumento converte i timestamp Unix in date leggibili e le date in timestamp. Che tu stia leggendo un claim JWT exp, analizzando una query su database o verificando un timestamp nei log, gestisce automaticamente valori a 10 cifre (secondi) e a 13 cifre (millisecondi).

Perché usare questo convertitore di timestamp?

Leggere timestamp Unix grezzi da log, database o risposte API richiede di memorizzare l'aritmetica dell'epoch o di scrivere codice usa e getta. Questo convertitore funziona nel browser senza alcuna configurazione. Che tu debba decodificare la scadenza di un JWT, verificare una riga di log o impostare un TTL su un database, il risultato è a un clic. Lo strumento rileva automaticamente se un valore è un timestamp in secondi a 10 cifre o in millisecondi a 13 cifre, eliminando la necessità di dividere manualmente per 1000. Tutta l'elaborazione avviene localmente nel browser. Nessun dato lascia il tuo computer, quindi i timestamp provenienti da sistemi interni e log sensibili rimangono privati.

Casi d'uso del convertitore di timestamp

Tabella di riferimento dei timestamp Unix

La tabella seguente mostra timestamp Unix noti e le date corrispondenti. Questi valori sono utili per verifiche rapide, test e per comprendere l'intervallo dei timestamp a 32 e 64 bit.

Confronto dei formati di data e ora

Sistemi e standard diversi rappresentano lo stesso istante nel tempo usando diversi formati stringa. La tabella confronta i formati più comuni che incontrerai in API, log e database.

Esempi di codice

Converti tra timestamp Unix e date nel linguaggio con cui stai lavorando. Ogni esempio mostra entrambe le direzioni: da timestamp a data e da data a timestamp.

// Current Unix timestamp in seconds
Math.floor(Date.now() / 1000)  // → 1711324800

// Unix timestamp to Date object
const date = new Date(1711324800 * 1000)
date.toISOString()             // → "2024-03-25T00:00:00.000Z"
date.toUTCString()             // → "Mon, 25 Mar 2024 00:00:00 GMT"

// Date string to Unix timestamp
Math.floor(new Date('2024-03-25T00:00:00Z').getTime() / 1000)
// → 1711324800

// Millisecond timestamps (common in JS APIs)
Date.now()                     // → 1711324800000 (ms)
Date.parse('2024-03-25')       // → 1711324800000 (ms)

import time
from datetime import datetime, timezone

# Current Unix timestamp
int(time.time())                                    # → 1711324800

# Unix timestamp to datetime
dt = datetime.fromtimestamp(1711324800, tz=timezone.utc)
dt.isoformat()                                      # → '2024-03-25T00:00:00+00:00'
dt.strftime('%Y-%m-%d %H:%M:%S %Z')                 # → '2024-03-25 00:00:00 UTC'

# Datetime string to Unix timestamp
dt = datetime.fromisoformat('2024-03-25T00:00:00+00:00')
int(dt.timestamp())                                  # → 1711324800

# Parse RFC 2822 dates (from email headers)
from email.utils import parsedate_to_datetime
parsedate_to_datetime('Mon, 25 Mar 2024 00:00:00 +0000').timestamp()
# → 1711324800.0

package main

import (
    "fmt"
    "time"
)

func main() {
    // Current Unix timestamp
    now := time.Now().Unix() // → 1711324800

    // Unix timestamp to time.Time
    t := time.Unix(1711324800, 0).UTC()
    fmt.Println(t.Format(time.RFC3339))
    // → 2024-03-25T00:00:00Z

    // Parse a date string to Unix timestamp
    parsed, _ := time.Parse(time.RFC3339, "2024-03-25T00:00:00Z")
    fmt.Println(parsed.Unix())
    // → 1711324800

    // Millisecond timestamp
    ms := time.Now().UnixMilli() // → 1711324800000
    fmt.Println(now, ms)
}

# Current Unix timestamp
date +%s                                    # → 1711324800

# Convert timestamp to human-readable date (GNU date)
date -d @1711324800                         # → Mon Mar 25 00:00:00 UTC 2024

# Convert timestamp to ISO 8601
date -d @1711324800 --iso-8601=seconds      # → 2024-03-25T00:00:00+00:00

# macOS (BSD date) — slightly different flags
date -r 1711324800                          # → Mon Mar 25 00:00:00 UTC 2024

# Date string to timestamp (GNU date)
date -d "2024-03-25 00:00:00 UTC" +%s       # → 1711324800

Domande frequenti