Epoch Time: Le Basi dei Timestamp Unix

December 04, 2025 • 5 min di lettura

Written by Simon Meier

Cos'è Esattamente l'Epoch Time?

Se hai mai lavorato con date e orari nella programmazione, probabilmente hai incontrato i timestamp Unix. Ma cosa sono realmente e perché li usiamo?

L'Unix epoch time (chiamato anche Unix time, POSIX time, o semplicemente "epoch") rappresenta un singolo momento nel tempo come il numero di secondi trascorsi dal 1 gennaio 1970, a mezzanotte UTC (Tempo Coordinato Universale). Questo momento specifico è conosciuto come "Unix epoch" o "epoch zero".

Esempio Veloce: Se il timestamp Unix attuale è 1728773400, significa che sono trascorsi esattamente 1.728.773.400 secondi dal rintocco della mezzanotte del 1 gennaio 1970.

Perché il 1 Gennaio 1970?

Questa data potrebbe sembrare arbitraria, ma è stata scelta quando Unix veniva sviluppato nei primi anni '70 ai Bell Labs. Gli sviluppatori avevano bisogno di un punto di partenza coerente per il loro sistema di tracciamento del tempo, e il 1 gennaio 1970 era vicino al periodo in cui stavano lavorando al progetto. Da allora è diventato lo standard universale.

Comprendere il Formato

I timestamp Unix si presentano in formati diversi a seconda della precisione necessaria:

Secondi (10 cifre): Il formato standard, come 1728773400
Millisecondi (13 cifre): Per maggiore precisione, come 1728773400000
Microsecondi (16 cifre): Per temporizzazione ultra-precisa, come 1728773400000000

Intervalli di Tempo Comuni in Secondi

Comprendere questi intervalli comuni può aiutarti a lavorare con i timestamp in modo più intuitivo:

Periodo di Tempo	Secondi	Calcolo Rapido
1 Ora	3.600	60 × 60
1 Giorno	86.400	24 × 3.600
1 Settimana	604.800	7 × 86.400
1 Mese (medio)	2.629.743	30,44 × 86.400
1 Anno (medio)	31.556.926	365,24 × 86.400

Il Problema dell'Anno 2038 (Y2038)

Ecco qualcosa di importante: molti sistemi memorizzano i timestamp Unix come interi con segno a 32 bit. Questo crea un problema simile al bug Y2K.

Un intero con segno a 32 bit può contare solo fino a 2.147.483.647 secondi. Una volta raggiunto il 19 gennaio 2038, alle 03:14:07 UTC, questo contatore andrà in overflow e tornerà a un numero negativo, causando potenzialmente malfunzionamenti e bug del sistema.

Importante: I sistemi moderni stanno passando a timestamp a 64 bit, che non andranno in overflow per altri 292 miliardi di anni. Assicurati che le tue applicazioni utilizzino interi a 64 bit per la memorizzazione dei timestamp!

Ottenere l'Epoch Time Corrente

Ogni linguaggio di programmazione ha il suo modo per recuperare il timestamp Unix corrente. Ecco i metodi più comuni:

Sviluppo Web

JavaScript

// Ottieni il timestamp in millisecondi, dividi per 1000 per i secondi
const timestamp = Math.floor(Date.now() / 1000);

// Metodo alternativo
const timestamp = Math.floor(new Date().getTime() / 1000);

PHP

// Semplice e diretto
$timestamp = time();

// Usando DateTime (più flessibile)
$timestamp = (new DateTime())->getTimestamp();

Linguaggi Backend

Python

import time

# Ottieni il timestamp corrente
timestamp = int(time.time())

# Usando il modulo datetime
from datetime import datetime
timestamp = int(datetime.now().timestamp())

Java

// Restituisce millisecondi, dividi per 1000 per i secondi
long timestamp = System.currentTimeMillis() / 1000;

// Usando Instant (Java 8+)
long timestamp = Instant.now().getEpochSecond();

// .NET Framework 4.6+ / .NET Core
long timestamp = DateTimeOffset.Now.ToUnixTimeSeconds();

// Versioni precedenti
var epoch = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;

Ruby

# Ottieni il timestamp corrente
timestamp = Time.now.to_i

# Alternativa
timestamp = Time.new.to_i

import "time"

// Ottieni il timestamp Unix corrente
timestamp := time.Now().Unix()

// Per i millisecondi
milliseconds := time.Now().UnixMilli()

Query Database

MySQL

-- Ottieni il timestamp corrente
SELECT UNIX_TIMESTAMP();

-- Ottieni il timestamp da una data specifica
SELECT UNIX_TIMESTAMP('2025-10-12 14:30:00');

PostgreSQL

-- Ottieni il timestamp corrente
SELECT EXTRACT(EPOCH FROM NOW());

-- Da una data specifica
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-10-12 14:30:00');

SQLite

-- Ottieni il timestamp corrente
SELECT STRFTIME('%s', 'now');

-- Da una data specifica
SELECT STRFTIME('%s', '2025-10-12 14:30:00');

Riga di Comando

Unix/Linux Shell

# Ottieni il timestamp corrente
date +%s

# Converti una data specifica in timestamp
date +%s -d "2025-10-12 14:30:00"

# Per orario UTC/GMT, usa -ud invece di -d
date +%s -ud "2025-10-12 14:30:00"

PowerShell

# Ottieni il timestamp corrente
[int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))

Convertire DA Epoch a Data Leggibile

Una volta che hai un timestamp Unix, spesso dovrai convertirlo in un formato di data leggibile:

JavaScript

// Converti il timestamp in oggetto Date
const date = new Date(timestamp * 1000); // Moltiplica per 1000 per i millisecondi

// Formattalo
console.log(date.toLocaleString()); // Formato locale
console.log(date.toISOString());    // Formato ISO 8601

PHP

// Formatta il timestamp
$date = date('Y-m-d H:i:s', $timestamp);

// Formato RFC 2822
$date = date('r', $timestamp);

// Usando DateTime
$date = (new DateTime())->setTimestamp($timestamp)->format('Y-m-d H:i:s');

Python

from datetime import datetime

# Converti in oggetto datetime
dt = datetime.fromtimestamp(timestamp)

# Formattalo
formatted = dt.strftime('%Y-%m-%d %H:%M:%S')

# Per UTC
dt_utc = datetime.utcfromtimestamp(timestamp)

MySQL

-- Converti il timestamp in datetime
SELECT FROM_UNIXTIME(1728773400);

-- Con formato personalizzato
SELECT FROM_UNIXTIME(1728773400, '%Y-%m-%d %H:%i:%s');

Convertire DA Data Leggibile a Epoch

L'operazione opposta è altrettanto importante:

JavaScript

// Analizza la stringa di data in timestamp
const timestamp = Math.floor(new Date('2025-10-12 14:30:00').getTime() / 1000);

// Usando Date.parse()
const timestamp = Math.floor(Date.parse('October 12, 2025') / 1000);

PHP

// Analizza la maggior parte dei testi di date in inglese
$timestamp = strtotime('15 November 2025');
$timestamp = strtotime('next Monday');
$timestamp = strtotime('+1 week');

// Usando DateTime
$timestamp = (new DateTime('2025-10-12 14:30:00'))->getTimestamp();

Python

from datetime import datetime
import time

# Analizza la stringa di data
dt = datetime.strptime('2025-10-12 14:30:00', '%Y-%m-%d %H:%M:%S')
timestamp = int(dt.timestamp())

# Per UTC
import calendar
timestamp = calendar.timegm(time.strptime('2025-10-12 14:30:00', '%Y-%m-%d %H:%M:%S'))

Best Practices

Quando lavori con i timestamp Unix nelle tue applicazioni:

Usa sempre interi a 64 bit per evitare il problema Y2038
Memorizza i timestamp in UTC nel tuo database, converti in orario locale solo per la visualizzazione
Sii coerente con la tua precisione (secondi vs millisecondi) in tutta l'applicazione
Documenta il tuo formato – rendi chiaro se stai usando secondi o millisecondi
Considera librerie timezone-aware per operazioni complesse di data/ora
Non memorizzare mai l'orario locale come timestamp senza informazioni sul fuso orario

Conclusione

I timestamp Unix sono un concetto fondamentale nella programmazione che ogni sviluppatore dovrebbe comprendere. Forniscono un modo semplice e universale per rappresentare il tempo che funziona su tutti i sistemi e linguaggi di programmazione.

Che tu stia costruendo un'applicazione web, lavorando con database o semplicemente programmando attività, comprendere l'epoch time ti renderà la vita molto più facile. Usa il nostro strumento Convertitore di Timestamp Unix per convertire rapidamente tra timestamp e date leggibili!

Provalo ora: Vai al nostro strumento convertitore per esercitarti a lavorare con i timestamp Unix in tempo reale!