Timestamp Unix expliqué : Guide complet de l'heure Epoch

Si vous avez déjà débogué une réponse API, configuré un journal serveur ou travaillé avec des bases de données, vous avez forcément rencontré un timestamp Unix. Ces longues suites numériques comme 1700000000 peuvent sembler mystérieuses, mais elles représentent en réalité l'un des moyens les plus simples et universels de noter un instant précis.

Ce guide explique ce que sont les timestamps Unix, le fonctionnement de l'heure epoch, et comment convertir entre timestamps et dates lisibles — avec des exemples concrets et réutilisables.

Qu'est-ce qu'un timestamp Unix ?

Un timestamp Unix est un nombre unique qui représente le total de secondes écoulées depuis le 1er janvier 1970 à 00:00:00 UTC. Ce point de départ s'appelle l'epoch Unix.

Par exemple, le timestamp 1700000000 correspond au 14 novembre 2023 à 22:13:20 UTC. Au lieu de gérer séparément les années, mois, jours, heures, minutes et secondes, un timestamp rassemble tout cela en un seul entier.

Aussi appelé heure Unix, heure epoch ou heure POSIX, ce système est utilisé dans pratiquement tous les langages de programmation, systèmes d'exploitation et bases de données.

L'epoch Unix expliqué

L'epoch Unix est le jeudi 1er janvier 1970, 00:00:00 UTC — le moment à partir duquel tous les timestamps Unix commencent à compter.

Pourquoi 1970 ? Lorsque Unix a été développé aux Bell Labs au début des années 1970, les créateurs avaient besoin d'un point de référence. Le 1er janvier 1970 a été choisi comme date de départ pratique — suffisamment récente pour être pertinente, et coïncidant avec le début d'une année.

Chaque seconde écoulée depuis ce moment ajoute un au timestamp. Nous avons actuellement dépassé les 1,76 milliard de secondes depuis l'epoch.

Secondes vs millisecondes

L'une des sources de confusion les plus fréquentes est la différence entre secondes et millisecondes :

Précision	Chiffres	Exemple	Utilisé par
Secondes	10	1700000000	Python, PHP, la plupart des API
Millisecondes	13	1700000000000	JavaScript, Java, de nombreuses API web

Règle simple : si votre timestamp a 10 chiffres, il est en secondes. S'il en a 13, il est en millisecondes. Pour convertir, multipliez ou divisez par 1 000.

Comment convertir un timestamp Unix en date

Convertir un timestamp en date lisible est simple avec les bons outils.

Avec notre convertisseur : Entrez le timestamp dans notre Convertisseur de Timestamp Unix et obtenez la date instantanément.

En code :

// JavaScript (attend des millisecondes)
const date = new Date(1700000000 * 1000);
console.log(date.toISOString());
// Résultat : "2023-11-14T22:13:20.000Z"

# Python
import datetime
dt = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)
print(dt.isoformat())
# Résultat : "2023-11-14T22:13:20+00:00"

// PHP
echo date('Y-m-d H:i:s', 1700000000);
// Résultat : "2023-11-14 22:13:20"

Comment convertir une date en timestamp Unix

L'opération inverse — convertir une date en timestamp — est tout aussi courante.

// JavaScript
const timestamp = Math.floor(
  new Date("2024-01-15T12:00:00Z").getTime() / 1000
);
console.log(timestamp); // 1705320000

# Python
import datetime
dt = datetime.datetime(2024, 1, 15, 12, 0, 0, tzinfo=datetime.timezone.utc)
print(int(dt.timestamp()))  # 1705320000

// PHP
echo strtotime("2024-01-15T12:00:00+00:00");
// Résultat : 1705320000

Exemples de timestamps Unix

Voici quelques timestamps notables pour référence :

Timestamp	Date (UTC)	Signification
0	1er janv. 1970 00:00:00	L'epoch Unix
1000000000	9 sept. 2001 01:46:40	Le milliardième seconde
1234567890	13 févr. 2009 23:31:30	Valeur de test populaire
1700000000	14 nov. 2023 22:13:20	Un nombre rond récent
2000000000	18 mai 2033 03:33:20	Un jalon futur
2147483647	19 janv. 2038 03:14:07	Valeur max signée 32 bits

Formats de timestamps courants

Les timestamps Unix ne sont qu'une façon de représenter les dates. Voici le même instant dans différents formats :

Format	Exemple
Timestamp Unix	1700000000
ISO 8601	2023-11-14T22:13:20Z
RFC 2822	Tue, 14 Nov 2023 22:13:20 +0000
RFC 3339	2023-11-14T22:13:20+00:00
Lisible	14 novembre 2023 22:13:20

L'ISO 8601 est le format le plus utilisé dans les API et les systèmes modernes. Le suffixe Z signifie « heure Zulu » (UTC).

Le timestamp Unix en programmation

Chaque langage majeur fournit un support intégré pour travailler avec les timestamps.

JavaScript

// Timestamp actuel (millisecondes — diviser par 1000 pour des secondes)
const maintenant = Math.floor(Date.now() / 1000);

// Timestamp vers date
const date = new Date(1700000000 * 1000);

// Date vers timestamp
const ts = Math.floor(new Date("2024-06-15").getTime() / 1000);

Python

import datetime

# Timestamp actuel
maintenant = int(datetime.datetime.now().timestamp())

# Timestamp vers date
dt = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)

# Date vers timestamp
ts = int(datetime.datetime(2024, 6, 15, tzinfo=datetime.timezone.utc).timestamp())

PHP

// Timestamp actuel
$maintenant = time();

// Timestamp vers date
echo date('Y-m-d H:i:s', 1700000000);

// Date vers timestamp
$ts = strtotime("2024-06-15");

Erreurs courantes

1. Confondre secondes et millisecondes L'erreur la plus fréquente. Le Date.getTime() de JavaScript renvoie des millisecondes, tandis que time.time() en Python renvoie des secondes. Vérifiez toujours l'unité attendue par votre outil — un nombre à 13 chiffres signifie des millisecondes.

2. Ignorer les fuseaux horaires Les timestamps Unix sont toujours en UTC. Si vous affichez un timestamp sans préciser de fuseau horaire, il sera par défaut en UTC. Utilisez les fonctions de localisation de votre langage pour convertir en heure locale.

3. Le problème de l'an 2038 Le 19 janvier 2038, les timestamps signés sur 32 bits vont déborder (2 147 483 647 est la valeur maximale). La plupart des systèmes modernes utilisent des entiers 64 bits, donc ce n'est pas un problème pratique — mais c'est bon à savoir si vous travaillez avec des systèmes anciens.

4. Oublier les secondes intercalaires Les timestamps Unix ignorent les secondes intercalaires. Chaque jour est traité comme exactement 86 400 secondes. Pour la plupart des applications, cela n'a pas d'importance, mais les systèmes haute précision doivent en tenir compte.

Essayez notre convertisseur gratuit

Besoin de convertir rapidement un timestamp en date — ou l'inverse ? Notre Convertisseur de Timestamp Unix gère les deux directions instantanément. Entrez une valeur, obtenez votre résultat et copiez-le en un clic.

Il est parfait pour déboguer des réponses API, vérifier des entrées de base de données ou convertir des timestamps de fichiers journaux. Consultez aussi notre guide Qu'est-ce qu'un timestamp ? pour approfondir le sujet.

Questions fréquentes

Qu'est-ce qu'un timestamp Unix ? Un timestamp Unix est le nombre de secondes écoulées depuis le 1er janvier 1970 (l'epoch Unix). C'est une manière universelle, indépendante du fuseau horaire, de représenter n'importe quel instant sous forme d'entier.

Comment obtenir le timestamp Unix actuel ? En JavaScript : Math.floor(Date.now() / 1000). En Python : int(time.time()). En PHP : time(). Tous renvoient les secondes actuelles depuis l'epoch.

Pourquoi JavaScript utilise-t-il des millisecondes ? L'objet Date de JavaScript a été conçu pour une précision à la milliseconde, utile pour les applications web. Multipliez les secondes par 1 000 ou divisez les millisecondes par 1 000 pour convertir.

Les timestamps Unix sont-ils affectés par les fuseaux horaires ? Non. Les timestamps sont toujours en UTC. Les fuseaux horaires n'interviennent que lorsque vous convertissez un timestamp en date lisible pour l'afficher.

Que se passe-t-il après 2038 ? Les timestamps signés sur 32 bits débordent le 19 janvier 2038. Les systèmes modernes sur 64 bits peuvent représenter des dates sur des milliards d'années, donc ce n'est pas un problème pratique pour les logiciels actuels.

Comment convertir des millisecondes en secondes ? Divisez par 1 000. Par exemple, 1700000000000 millisecondes équivaut à 1700000000 secondes.

Conclusion

Les timestamps Unix sont un concept fondamental en informatique. Ils offrent une manière simple et universelle de représenter le temps, fonctionnant sur tous les langages, plateformes et bases de données. Que vous convertissiez des timestamps en code, déboguiez des fichiers journaux ou soyez simplement curux de savoir ce que signifie 1700000000, comprendre l'heure epoch est une compétence essentielle pour tout développeur.

Mettez en favoris notre Convertisseur de Timestamp Unix pour des conversions rapides, et consultez le Calculateur de différence de dates et le Calculateur d'âge pour d'autres outils liés aux dates.