- Convertisseur Unix Timestamp en ligne

Qu'est-ce que le Unix Timestamp ?

Le Unix Timestamp (ou Epoch time) est une façon universelle de représenter un instant précis dans le temps. Il exprime le nombre de secondes écoulées depuis le 1er janvier 1970 à 00:00:00 UTC, aussi appelé l'Epoch Unix.

Cette convention est utilisée dans tous les systèmes d'exploitation Unix/Linux, mais aussi dans la quasi-totalité des langages de programmation modernes (JavaScript, PHP, Python, Go, Rust…). C'est un entier simple, universel et indépendant de la langue ou du format d'affichage.

Pourquoi 1970 ?

La date du 1er janvier 1970 a été choisie par les développeurs des systèmes Unix dans les années 1970. À l'époque, cela représentait une date récente, facile à stocker sur des systèmes 32 bits. Cette convention s'est imposée comme standard mondial.

Secondes vs millisecondes : quelle différence ?

Il existe deux variantes du timestamp Unix selon la précision requise :

Comment détecter automatiquement secondes ou ms ?

La règle pratique est simple : si le timestamp comporte 13 chiffres ou plus, il s'agit de millisecondes. En dessous, ce sont des secondes. Notre outil applique cette détection automatique.

// JavaScript — détection automatique
function normalizeTimestamp(ts) {
    // Timestamp en ms si >= 10^12 (13 chiffres)
    return ts >= 1e12 ? ts : ts * 1000;
}

const tsMs = normalizeTimestamp(1714521600);    // → 1714521600000
const tsMs2 = normalizeTimestamp(1714521600000); // → 1714521600000 (inchangé)

Fuseaux horaires et UTC

Le timestamp Unix est toujours basé sur UTC (Coordinated Universal Time). Il ne contient aucune information de fuseau horaire — c'est un point fixe dans le temps. L'affichage dépend du fuseau choisi.

UTC vs GMT vs fuseau local

Conversion avec l'API Intl en JavaScript

// Afficher un timestamp dans un fuseau horaire spécifique
const ts = 1714521600; // secondes
const date = new Date(ts * 1000); // convertir en ms pour le constructeur Date

const options = {
    timeZone: 'Europe/Paris',
    year: 'numeric', month: '2-digit', day: '2-digit',
    hour: '2-digit', minute: '2-digit', second: '2-digit',
    hour12: false
};

const formatter = new Intl.DateTimeFormat('fr-FR', options);
console.log(formatter.format(date));
// → "01/05/2024 02:00:00"

Conversion en JavaScript

JavaScript propose l'objet Date et l'API Intl pour manipuler les timestamps. Voici les opérations les plus courantes :

Obtenir le timestamp actuel

// Timestamp en millisecondes (méthode recommandée)
const nowMs = Date.now();
// → ex: 1714521600000

// Timestamp en secondes (comme Unix standard)
const nowSec = Math.floor(Date.now() / 1000);
// → ex: 1714521600

// Avec l'objet Date
const now = new Date();
const tsMs = now.getTime();       // millisecondes
const tsSec = now.valueOf() / 1000; // secondes (float)

Date → Timestamp

// À partir d'une chaîne ISO
const date = new Date('2024-05-01T00:00:00Z');
const ts = Math.floor(date.getTime() / 1000);
// → 1714521600

// À partir de composants
const date2 = new Date(Date.UTC(2024, 4, 1, 0, 0, 0)); // mois 0-indexé (4 = mai)
const ts2 = Math.floor(date2.getTime() / 1000);
// → 1714521600

Timestamp → Date lisible

const ts = 1714521600; // secondes

// Convertir en objet Date
const date = new Date(ts * 1000); // × 1000 pour ms

// Format ISO 8601
console.log(date.toISOString());
// → "2024-05-01T00:00:00.000Z"

// Format localisé France
console.log(date.toLocaleString('fr-FR', { timeZone: 'Europe/Paris' }));
// → "01/05/2024, 02:00:00"

Temps relatif (il y a X jours)

// Calcul du temps relatif
function timeAgo(ts) {
    const now = Math.floor(Date.now() / 1000);
    const diff = now - ts; // en secondes

    if (diff < 60)        return `il y a ${diff} seconde(s)`;
    if (diff < 3600)      return `il y a ${Math.floor(diff / 60)} minute(s)`;
    if (diff < 86400)     return `il y a ${Math.floor(diff / 3600)} heure(s)`;
    if (diff < 2592000)   return `il y a ${Math.floor(diff / 86400)} jour(s)`;
    if (diff < 31536000)  return `il y a ${Math.floor(diff / 2592000)} mois`;
    return `il y a ${Math.floor(diff / 31536000)} an(s)`;
}

console.log(timeAgo(1714521600));
// → "il y a 1 jour(s)" (si lancé le 02/05/2024)

Conversion PHP et Python

PHP — manipulation des timestamps

<?php
// Timestamp actuel (secondes)
$now = time();
echo $now; // → 1714521600

// Date → Timestamp (avec fuseau)
$date = new DateTime('2024-05-01 00:00:00', new DateTimeZone('Europe/Paris'));
$ts = $date->getTimestamp();
echo $ts; // → 1714514400 (UTC, car Paris = UTC+2)

// Timestamp → Date formatée
$formatted = date('d/m/Y H:i:s', $ts);
echo $formatted; // → "01/05/2024 00:00:00"

// Avec fuseau horaire
date_default_timezone_set('Europe/Paris');
echo date('d/m/Y H:i:s', $ts);
// → "01/05/2024 00:00:00"

// Carbon (Laravel) — plus lisible
// $date = Carbon::createFromTimestamp($ts, 'Europe/Paris');
// echo $date->diffForHumans(); // → "il y a 1 jour"
?>

Python — datetime et timestamps

import time
from datetime import datetime, timezone
import pytz

# Timestamp actuel
ts = int(time.time())
print(ts)  # → 1714521600

# Date → Timestamp
paris_tz = pytz.timezone('Europe/Paris')
dt = datetime(2024, 5, 1, 0, 0, 0, tzinfo=paris_tz)
ts = int(dt.timestamp())
print(ts)  # → 1714514400

# Timestamp → Date lisible (UTC)
dt_utc = datetime.fromtimestamp(ts, tz=timezone.utc)
print(dt_utc.isoformat())
# → "2024-04-30T22:00:00+00:00"

# Timestamp → Date locale
dt_local = datetime.fromtimestamp(ts, tz=paris_tz)
print(dt_local.strftime('%d/%m/%Y %H:%M:%S'))
# → "01/05/2024 00:00:00"

MySQL / PostgreSQL

-- MySQL : date vers timestamp
SELECT UNIX_TIMESTAMP('2024-05-01 00:00:00');
-- → 1714514400 (heure serveur appliquée)

-- MySQL : timestamp vers date
SELECT FROM_UNIXTIME(1714521600);
-- → 2024-05-01 02:00:00 (si serveur sur UTC+2)

-- PostgreSQL : timestamp vers date ISO
SELECT TO_TIMESTAMP(1714521600);
-- → 2024-05-01 00:00:00+00

-- PostgreSQL : date vers timestamp
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2024-05-01 00:00:00 UTC');
-- → 1714521600

Cas d'usage courants

Questions fréquentes