🕐
← Torna alle guide

Conversione del fuso orario dei timestamp Unix: una guida pratica

· Tag: timezone, dst, utc, time-conversion, unix-timestamp, daylight-saving, epoch

Perché il fuso orario conta per i timestamp Unix

I timestamp Unix di per sé sono indipendenti dal fuso orario — il numero 1785292800 significa lo stesso istante ovunque. La complessità nasce quando si converte quell'istante in un'ora locale leggibile per la visualizzazione, la registrazione o l'analisi dei dati.

Il principio fondamentale: memorizza sempre in UTC, converti solo per la visualizzazione. Questa regola elimina intere categorie di bug e rende i tuoi dati portabili tra i fusi orari.

UTC vs ora locale: comprendere la differenza

UTC (Tempo Universale Coordinato)

UTC è lo standard temporale primario. Non cambia mai per l'ora legale ed è lo stesso ovunque sulla Terra. I timestamp Unix sono definiti in UTC.

Ora locale

L'ora locale è UTC adattato a una specifica regione geografica. Può differire da UTC per un offset fisso (ad es. UTC+8 per l'ora standard della Cina) o per un offset variabile (ad es. l'Eastern Time alterna tra UTC-5 e UTC-4 per l'ora legale).

Il problema dell'offset

Lo stesso timestamp Unix produce orari locali diversi a seconda della posizione dell'osservatore:

| Timestamp | UTC | New York (EST) | Tokyo (JST) | Londra (BST) | |-----------|-----|----------------|-------------|--------------| | 1785292800 | 2026-07-19 00:00 | 2026-07-18 20:00 | 2026-07-19 09:00 | 2026-07-19 01:00 | | 1785379200 | 2026-07-19 23:59 | 2026-07-19 19:59 | 2026-07-20 08:59 | 2026-07-20 00:59 |

Ora legale (DST)

Che cos'è il DST?

L'ora legale (Daylight Saving Time) è la pratica di avanzare gli orologi durante i mesi estivi affinché la luce serale duri più a lungo. Gli orologi "saltano in avanti" (perdono un'ora) in primavera e "tornano indietro" (guadagnano un'ora) in autunno.

L'impatto sulla conversione dei timestamp

Il DST crea un offset variabile tra l'ora locale e UTC. Ciò significa:

  1. La stessa ora locale può corrispondere a due timestamp diversi (durante la transizione "fall back", l'ora 1:00 AM si verifica due volte)
  2. Alcune ore locali non esistono (durante la transizione "spring forward", ad es. le 2:00 AM non accadono mai — gli orologi saltano direttamente alle 3:00 AM)

Esempio: l'ora ambigua

Nel fuso orario Eastern Time degli Stati Uniti, la prima domenica di novembre alle 2:00 AM, gli orologi tornano indietro alle 1:00 AM. Ciò significa:

from datetime import datetime, timezone
import pytz

eastern = pytz.timezone("America/New_York")

# First occurrence of 1:00 AM (EDT, UTC-4)
first = eastern.localize(datetime(2026, 11, 1, 1, 0), is_dst=True)
print(first.timestamp())
# Some timestamp value

# Second occurrence of 1:00 AM (EST, UTC-5) = 3600 seconds later!
second = eastern.localize(datetime(2026, 11, 1, 1, 0), is_dst=False)
print(second.timestamp())
# first.timestamp() + 3600

Gestisci sempre con attenzione l'ambigua ora del "fall back" nelle tue applicazioni. L'uso dei flag is_dst/ambiguous in Python o delle opzioni equivalenti in altri linguaggi previene bug sottili.

Conversione tra fusi orari

Usare il nostro strumento online

L'approccio più semplice per conversioni una tantum è il nostro Convertitore di timestamp Unix, che mostra i risultati in più fusi orari contemporaneamente.

Usare la riga di comando Linux

# Display timestamp in multiple timezones
TZ="America/New_York" date -d @1785292800
TZ="Europe/London"    date -d @1785292800
TZ="Asia/Tokyo"       date -d @1785292800

# With custom ISO format
TZ="UTC" date -d @1785292800 +"%Y-%m-%d %H:%M:%S %Z"
# Output: 2026-07-19 00:00:00 UTC

TZ="Asia/Shanghai" date -d @1785292800 +"%Y-%m-%d %H:%M:%S %Z"
# Output: 2026-07-19 08:00:00 CST

Usare Python

from datetime import datetime
from zoneinfo import ZoneInfo  # Python 3.9+

ts = 1785292800

# Convert to multiple timezones
timezones = ["America/New_York", "Europe/London", "Asia/Tokyo", "Australia/Sydney"]

for tz_name in timezones:
    tz = ZoneInfo(tz_name)
    dt = datetime.fromtimestamp(ts, tz=tz)
    print(f"{tz_name}: {dt.strftime('%Y-%m-%d %H:%M:%S %Z')}")

Usare JavaScript

const ts = 1785292800;
const date = new Date(ts * 1000);

const timezones = [
    "America/New_York",
    "Europe/London",
    "Asia/Tokyo",
    "Australia/Sydney"
];

for (const tz of timezones) {
    const str = date.toLocaleString("en-US", {
        timeZone: tz,
        timeZoneName: "short",
    });
    console.log(`${tz}: ${str}`);
}

Usare Go

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Unix(1785292800, 0)
    
    timezones := []string{
        "America/New_York",
        "Europe/London",
        "Asia/Tokyo",
        "Australia/Sydney",
    }
    
    for _, tz := range timezones {
        loc, _ := time.LoadLocation(tz)
        fmt.Printf("%s: %s\n", tz, t.In(loc).Format("2006-01-02 15:04:05"))
    }
}

Schemi comuni di conversione del fuso orario

Convertire i log del server nell'ora locale

I log dei server registrano comunemente i timestamp in UTC. Quando li analizzi, convertili nel tuo fuso orario locale:

# Read a log file and display timestamps in Pacific time
while IFS= read -r line; do
    if [[ $line =~ ^([0-9]+) ]]; then
        ts="${BASH_REMATCH[1]}"
        TZ="America/Los_Angeles" date -d @"$ts" "+%Y-%m-%d %H:%M:%S"
        echo " $line"
    fi
done < server.log

Pianificare eventi tra fusi orari

Quando condividi gli orari degli eventi tra fusi orari, comunica sempre in UTC o condividi direttamente il timestamp Unix. Questo elimina l'ambiguità:

  • "Riunione alle 1785292800" è privo di ambiguità
  • "Riunione alle 9:00 AM EST" diventa ambiguo durante le transizioni DST
  • "Riunione alle 9:00 AM America/New_York" è meglio ma richiede comunque di conoscere lo stato del DST

Memorizzare i timestamp nei database

-- Always store the timestamp itself (timezone-independent)
INSERT INTO events (occurred_at, user_id) VALUES (1785292800, 42);

-- OR store with an explicit UTC timestamp column
INSERT INTO events (occurred_at_utc, user_id) 
VALUES ('2026-07-19 00:00:00+00', 42);

Riepilogo delle migliori pratiche

  1. Memorizza in UTC, converti per la visualizzazione — Non memorizzare mai l'ora locale nei database
  2. Usa i nomi di fuso orario IANA (ad es. America/New_York) invece delle abbreviazioni (EST, PST) — le abbreviazioni sono ambigue e non tengono conto del DST
  3. Gestisci esplicitamente il DST — Usa librerie consapevoli del fuso orario; non aggiungere/sottrarre mai ore manualmente
  4. Richiedi sempre le informazioni sul fuso orario — Quando accetti date dagli utenti, raccogli il fuso orario, non solo l'offset
  5. Testa le date limite — Metti alla prova la tua logica di conversione nelle date di transizione DST (sia primavera che autunno) per individuare i bug in anticipo

Database dei fusi orari

I dati sui fusi orari del tuo sistema provengono dalla IANA Time Zone Database (chiamata anche database di Olson), che viene aggiornata più volte all'anno man mano che i governi cambiano le regole del DST. Mantieni aggiornato il tuo sistema:

# Debian / Ubuntu
sudo apt update && sudo apt install tzdata

# macOS
# Automatically updated via software updates

# Verify your database version
zdump -v /etc/localtime | head -1

Usa il nostro Convertitore di timestamp Unix per conversioni rapide consapevoli del fuso orario in tutti i principali fusi orari.