Convertitore di timestamp Unix

Strumento di conversione bidirezionale tra timestamp Unix/Linux e data/ora, con confronto basato su diverse fusi orari.

Ora corrente

Timestamp corrente (secondi)

1766507447

Ora corrente

2025-12-23 16:30:47

Fuso orario globale

Conversione da timestamp a data

Risultato della conversione(automatico)

Ora locale

Ora UTC

Ora del fuso orario selezionato

Conversione da data a timestamp

Risultato della conversione(automatico)

Timestamp (secondi)

Timestamp (millisecondi)

Conversore di date e ore da più timestamp

Conversore di timestamp da più date

Istruzioni per l'uso

Questo strumento è utilizzato per completare rapidamente la conversione bidirezionale tra timestamp Unix e data-ora in diversi scenari. Supporta la precisione in secondi e millisecondi e consente di selezionare il fuso orario di destinazione per un confronto visivo. Sono disponibili convertitori a singola carta e a più carte. La conversione avviene immediatamente dopo l'inserimento, e il risultato viene aggiornato automaticamente quando si cambia il fuso orario. Inoltre, sono incorporati intervalli di tempo recenti e intervalli di tempo comuni, soddisfando le esigenze di sviluppo, debug e conversione quotidiana.

Rilevamento automatico: Lo strumento riconoscerà automaticamente se l'input è un timestamp in secondi (10 cifre) o in millisecondi (13 cifre).

Fuso orario: Vengono mostrate l'ora locale e l'ora UTC, facilitando l'utilizzo in diversi fusi orari.

Caratteristiche funzionali dell'strumento

Conversione immediata dopo l'inserimento, supporto per il rilevamento automatico di timestamp in secondi/millisecondi.
Supporto per la selezione e la visualizzazione globale del fuso orario: tre viste per l'ora locale, l'ora UTC e il fuso orario selezionato.
Più carte convertitori per un confronto batch.
Interfaccia reattiva e amichevole per la tastiera, buona accessibilità.
Intervalli di tempo recenti e intervalli di tempo comuni incorporati, pronti per la copia e l'utilizzo.

Cos'è un timestamp?

Il timestamp Unix (Unix Timestamp) è il numero totale di secondi o millisecondi trascorsi dall'00:00:00 UTC del 01-01-1970 (Unix Epoch).

Un timestamp è un numero che rappresenta il tempo, solitamente espresso in secondi o millisecondi.

Il punto di partenza del timestamp è l'00:00:00 UTC del 01 gennaio 1970, questo momento è chiamato l'epoca Unix.

I timestamp sono stati originariamente utilizzati nel sistema operativo Unix, quindi sono spesso chiamati timestamp Unix.

I timestamp sono ampiamente utilizzati nella programmazione e nelle comunicazioni di rete, soprattutto nello sviluppo web.

Precisioni comuni: secondi (ad esempio 1735689600) e millisecondi (ad esempio 1735689600000). Quando si rappresentano date e ore relative a un fuso orario, è necessario formattarli in base al fuso orario.

Timestamp recenti (basati sul fuso orario globale)

Timestamp comuni (durate)

1 minuto

60 Secondi

1 ora

3600 Secondi

1 giorno

86400 Secondi

1 settimana

604800 Secondi

1 mese (30 giorni)

2592000 Secondi

1 anno (365 giorni)

31536000 Secondi

Il problema del 2038 per i timestamp

Il problema del 2038 si riferisce al problema di overflow che si verifica quando un intero con segno a 32 bit viene utilizzato per memorizzare il timestamp Unix (espresso in secondi a partire dall'1 gennaio 1970, 00:00:00 UTC) dopo il 19 gennaio 2038, 03:14:07.

Poiché l'intervallo di un intero con segno a 32 bit va da -2.147.483.648 a 2.147.483.647 e il timestamp del 19 gennaio 2038, 03:14:07 UTC è 2.147.483.647, oltre questo momento l'intero con segno a 32 bit non sarà più in grado di rappresentare i timestamp successivi.

I sistemi o i software più influenzati sono quelli più vecchi che utilizzano il tipo time_t a 32 bit. I sistemi moderni solitamente utilizzano 64 bit (ad esempio, un intero a 64 bit espresso in millisecondi) e non hanno questo problema.

Si consiglia di utilizzare timestamp a 64 bit o di utilizzare librerie di gestione del tempo che supportano un ampio intervallo di date.

Come ottenere/convertire i timestamp tramite linguaggi di programmazione

JavaScript

Ottieni il timestamp corrente

Math.floor(Date.now() / 1000); // seconds
Date.now(); // milliseconds

Timestamp → Data

new Date(1735689600 * 1000).toISOString();

Data → Timestamp

new Date('2025-01-01T00:00:00Z').getTime();

PHP

Ottieni il timestamp corrente

time();                // seconds
intval(microtime(true) * 1000); // milliseconds

Timestamp → Data

date('Y-m-d H:i:s', 1735689600);

Data → Timestamp

strtotime('2025-01-01 00:00:00');

Python

Ottieni il timestamp corrente

import time

int(time.time())        # seconds
int(time.time() * 1000) # milliseconds

Timestamp → Data

import datetime

datetime.datetime.utcfromtimestamp(1735689600).isoformat()

Data → Timestamp

import datetime

int(datetime.datetime(2025,1,1,0,0,0,tzinfo=datetime.timezone.utc).timestamp())

Ottieni il timestamp corrente

import "time"

time.Now().Unix()      // seconds
time.Now().UnixMilli() // milliseconds

Timestamp → Data

import "time"

time.Unix(1735689600, 0).UTC().Format(time.RFC3339)

Data → Timestamp

import "time"

ts := time.Date(2025,1,1,0,0,0,0,time.UTC).Unix()

Rust

Ottieni il timestamp corrente

use chrono::Utc;

let now = Utc::now();
let sec = now.timestamp();        // seconds i64
let ms  = now.timestamp_millis(); // milliseconds i128

Timestamp → Data

use chrono::{DateTime, NaiveDateTime, Utc};

let dt: DateTime = NaiveDateTime::from_timestamp_opt(1735689600, 0)
    .unwrap()
    .and_utc();
let iso = dt.to_rfc3339();

Data → Timestamp

use chrono::DateTime;

let ts = DateTime::parse_from_rfc3339("2025-01-01T00:00:00Z")
    .unwrap()
    .timestamp();

SQL

Ottieni il timestamp corrente

-- MySQL / MariaDB
SELECT UNIX_TIMESTAMP();

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM NOW())::bigint;

-- SQLite
SELECT strftime('%s', 'now');

Timestamp → Data

-- MySQL / MariaDB
SELECT FROM_UNIXTIME(1735689600);

-- PostgreSQL
SELECT to_timestamp(1735689600) AT TIME ZONE 'UTC';

-- SQLite
SELECT datetime(1735689600, 'unixepoch');

Data → Timestamp

-- MySQL / MariaDB
SELECT UNIX_TIMESTAMP('2025-01-01 00:00:00');

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-01-01 00:00:00+00')::bigint;

-- SQLite
SELECT strftime('%s', '2025-01-01 00:00:00');