Com convertir una marca de temps Unix a una data

Una marca de temps Unix es veu així: 1712505600.

No significa res a primera vista. Però representa un moment específic en el temps — 7 d'abril de 2024 a les 16:00:00 UTC, per ser precisos. Convertir-la a quelcom llegible és senzill, però hi ha una sèrie de maneres en què pot fallar si no hi poses atenció.

Aquesta guia cobreix com convertir una marca de temps Unix a una data llegible en els llenguatges i entorns més comuns, quins són els errors típics, i com gestionar segons versus mil·lisegons — que és d'on provenen la majoria de bugs.

Si només necessites una conversió ràpida ara mateix, el Convertidor de Marca de Temps Unix ho fa instantàniament.

Què estàs convertint realment

Una marca de temps Unix és el nombre de segons (o de vegades mil·lisegons) des de l'1 de gener de 1970, 00:00:00 UTC. Aquest punt de partida s'anomena era Unix.

Quan converteix una marca de temps a una data, estàs responent: "quina data i hora del calendari correspon a aquest nombre de segons, en una zona horària determinada?"

La resposta depèn de dues coses: el valor de la marca de temps en si, i la zona horària que vols a la sortida. La mateixa marca de temps és una hora local diferent depenent d'on siguis. És intencional — la marca de temps emmagatzema un moment universal únic, i apliques la zona horària a l'hora de mostrar-la.

Segons versus mil·lisegons: la font més comuna de bugs

Abans de convertir res, comprova si la teva marca de temps està en segons o mil·lisegons.

Les marques de temps Unix en segons són actualment 10 dígits (al voltant de 1.700.000.000 a finals de 2023). El Date.now() de JavaScript retorna mil·lisegons, donant-te un nombre de 13 dígits com 1.700.000.000.000.

Si alimentes una marca de temps en mil·lisegons en una funció que espera segons, obtindràs una data en algun moment de l'any 55.000. Si alimentes una marca de temps en segons en una funció que espera mil·lisegons, obtindràs una data en gener de 1970.

Una comprovació ràpida: compta els dígits. 10 dígits = segons. 13 dígits = mil·lisegons.

Com convertir en JavaScript

L'objecte Date de JavaScript funciona en mil·lisegons, així que si tens una marca de temps en segons, multiplica per 1000 primer.

const ts = 1712505600; // segons
const date = new Date(ts * 1000);

console.log(date.toISOString()); // "2024-04-07T16:00:00.000Z"
console.log(date.toLocaleString()); // string de zona horària local

Si la teva marca de temps ja està en mil·lisegons:

const ts = 1712505600000; // mil·lisegons
const date = new Date(ts);

toISOString() sempre retorna UTC. toLocaleString() utilitza la zona horària local de l'usuari. Si necessites una zona horària específica, utilitza toLocaleString amb un objecte d'opcions:

date.toLocaleString('en-GB', { timeZone: 'Europe/London' });

Com convertir en Python

El mòdul datetime de Python ho fa de manera neta.

from datetime import datetime, timezone

ts = 1712505600  # segons
dt = datetime.fromtimestamp(ts, tz=timezone.utc)
print(dt)  # 2024-04-07 16:00:00+00:00

fromtimestamp sense un argument tz utilitza la zona horària local del sistema, que pot causar resultats inconsistents depenent de la màquina. Passa tz=timezone.utc per ser explícit, després converteix a hora local si cal:

from datetime import timezone
import pytz

local_tz = pytz.timezone('America/New_York')
local_dt = dt.astimezone(local_tz)
print(local_dt)  # 2024-04-07 12:00:00-04:00

Per a marques de temps en mil·lisegons, divideix per 1000 abans de passar a fromtimestamp.

Com convertir en PHP

$ts = 1712505600;
echo date('Y-m-d H:i:s', $ts); // "2024-04-07 16:00:00" en zona horària del servidor
echo gmdate('Y-m-d H:i:s', $ts); // sempre UTC

date() utilitza la zona horària predeterminada del servidor. gmdate() sempre retorna UTC. En la majoria del codi PHP de producció, establir la zona horària de manera explícita és més segur que confiar en la predeterminada del servidor.

Com convertir en Go

import (
    "fmt"
    "time"
)

ts := int64(1712505600)
t := time.Unix(ts, 0).UTC()
fmt.Println(t.Format(time.RFC3339)) // "2024-04-07T16:00:00Z"

time.Unix(seconds, nanoseconds) pren la marca de temps en segons. Crida .UTC() per normalitzar a UTC, o .Local() per aplicar la zona horària del sistema.

Com convertir en SQL

Les marques de temps emmagatzemades com a enters són comuns en bases de dades, especialment per a columnes created_at i updated_at.

PostgreSQL: `sql SELECT TO_TIMESTAMP(1712505600); -- 2024-04-07 16:00:00+00 `

MySQL: `sql SELECT FROM_UNIXTIME(1712505600); -- 2024-04-07 16:00:00 (zona horària del servidor) `

SQLite: `sql SELECT datetime(1712505600, 'unixepoch'); -- 2024-04-07 16:00:00 `

SQLite emmagatzema tot com a text o nombres i no té cap tipus datetime natiu, així que el modificador unixepoch li diu que tracti l'enter com una marca de temps Unix.

Formatatge de la sortida

Convertir a un objecte de data és el primer pas. Formatjar-lo per mostrar és el segon.

Codis de format comuns:

SímbolSignificatExemple
Y / %Yany de 4 dígits2024
m / %mMes (amb zero inicial)04
d / %dDia (amb zero inicial)07
H / %HHora (24h)16
i / %MMinut00
s / %SSegon00

El format ISO 8601 (YYYY-MM-DDTHH:MM:SSZ) és l'opció més segura per a res que travessi límits de sistema o s'emmagatzemi en una base de dades. És inequívoc, ordenable com a string, i universalment entès.

Gestió correcta de la zona horària

La mateixa marca de temps representa hores locals diferents. 1712505600 és:

  • 16:00 UTC
  • 12:00 Eastern (UTC-4 durant l'estalvi de luz)
  • 18:00 Central European (UTC+2 durant l'estiu)

Si converteix una marca de temps UTC a una hora "local" sense especificar quina zona horària vols dir, obtindràs la zona horària en què estigui configurada la màquina que executa el codi. Això causa bugs quan el mateix codi s'executa en servidors de diferents regions.

Millor pràctica: emmagatzema i transmet marques de temps en UTC, converteix a hora local només a l'hora de mostrar, i sempre sigues explícit sobre quina zona horària estàs buscant.

Quan el resultat sembla incorrecte

Alguns diagnòstics ràpids si la conversió dóna un resultat inesperat:

  • L'any és 55.000+: la marca de temps està en mil·lisegons però la funció esperava segons
  • La data és 1970-01-01: la marca de temps està en segons però la funció esperava mil·lisegons, o la marca de temps és 0 o null
  • L'hora està desfasada unes hores: desajust de zona horària — comprova si estàs comparant sortida UTC amb un rellotge local
  • Marca de temps negativa: vàlida — les marques de temps negatives representen dates anteriors a 1970, que la majoria de sistemes gestionen correctament

Una manera més ràpida de comprovar

Per a comprovacions ràpides — com verificar una marca de temps d'una resposta d'API o un fitxer de registre — el Convertidor de Marca de Temps Unix fa la conversió instantàniament, incloent la detecció automàtica de segons versus mil·lisegons.

És útil quan estàs depurant i necessites confirmar què representa realment una marca de temps sense escriure codi. Per a calcular aritmètica de dates com "quants dies des d'aquesta marca de temps", la calculadora Dies Entre Dates és el pas natural següent.

Articles relacionats

Veure més entrades