Epoch Time: La Base des Timestamps Unix

October 19, 2025 • 5 min de lecture

Written by Simon Meier

Qu'est-ce que l'Epoch Time exactement ?

Si tu as déjà travaillé avec des dates et des heures en programmation, tu as probablement rencontré les timestamps Unix. Mais qu'est-ce que c'est vraiment, et pourquoi les utilise-t-on ?

L'Unix epoch time (aussi appelé Unix time, POSIX time, ou simplement "epoch") représente un moment précis dans le temps sous forme du nombre de secondes écoulées depuis le 1er janvier 1970, à minuit UTC (Temps Universel Coordonné). Ce moment spécifique est connu comme "l'époque Unix" ou "epoch zéro".

Exemple rapide : Si le timestamp Unix actuel est 1728773400, cela signifie qu'exactement 1 728 773 400 secondes se sont écoulées depuis minuit le 1er janvier 1970.

Pourquoi le 1er janvier 1970 ?

Cette date peut sembler arbitraire, mais elle a été choisie lors du développement d'Unix au début des années 1970 aux Bell Labs. Les développeurs avaient besoin d'un point de départ cohérent pour leur système de suivi du temps, et le 1er janvier 1970 était proche de la période où ils travaillaient sur le projet. C'est devenu la norme universelle depuis.

Comprendre le format

Les timestamps Unix existent en différents formats selon la précision nécessaire :

Secondes (10 chiffres) : Le format standard, comme 1728773400
Millisecondes (13 chiffres) : Pour plus de précision, comme 1728773400000
Microsecondes (16 chiffres) : Pour un timing ultra-précis, comme 1728773400000000

Intervalles de temps courants en secondes

Comprendre ces intervalles courants peut t'aider à travailler avec les timestamps de manière plus intuitive :

Période de temps	Secondes	Calcul rapide
1 heure	3 600	60 × 60
1 jour	86 400	24 × 3 600
1 semaine	604 800	7 × 86 400
1 mois (moy)	2 629 743	30,44 × 86 400
1 an (moy)	31 556 926	365,24 × 86 400

Le problème de l'an 2038 (Y2038)

Voici quelque chose d'important : de nombreux systèmes stockent les timestamps Unix sous forme d'entier signé 32 bits. Cela crée un problème similaire au bug de l'an 2000.

Un entier signé 32 bits ne peut compter que jusqu'à 2 147 483 647 secondes. Une fois qu'on atteint le 19 janvier 2038 à 03:14:07 UTC, ce compteur débordera et reviendra à un nombre négatif, causant potentiellement des pannes système et des bugs.

Important : Les systèmes modernes passent aux timestamps 64 bits, qui ne déborderont pas avant 292 milliards d'années. Assure-toi que tes applications utilisent des entiers 64 bits pour le stockage des timestamps !

Obtenir l'Epoch Time actuel

Chaque langage de programmation a sa propre façon de récupérer le timestamp Unix actuel. Voici les méthodes les plus courantes :

Développement Web

JavaScript

// Obtenir le timestamp en millisecondes, diviser par 1000 pour les secondes
const timestamp = Math.floor(Date.now() / 1000);

// Méthode alternative
const timestamp = Math.floor(new Date().getTime() / 1000);

PHP

// Simple et direct
$timestamp = time();

// Utiliser DateTime (plus flexible)
$timestamp = (new DateTime())->getTimestamp();

Langages Backend

Python

import time

# Obtenir le timestamp actuel
timestamp = int(time.time())

# Utiliser le module datetime
from datetime import datetime
timestamp = int(datetime.now().timestamp())

Java

// Retourne les millisecondes, diviser par 1000 pour les secondes
long timestamp = System.currentTimeMillis() / 1000;

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

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

// Versions plus anciennes
var epoch = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;

Ruby

# Obtenir le timestamp actuel
timestamp = Time.now.to_i

# Alternative
timestamp = Time.new.to_i

import "time"

// Obtenir le timestamp Unix actuel
timestamp := time.Now().Unix()

// Pour les millisecondes
milliseconds := time.Now().UnixMilli()

Requêtes de base de données

MySQL

-- Obtenir le timestamp actuel
SELECT UNIX_TIMESTAMP();

-- Obtenir le timestamp d'une date spécifique
SELECT UNIX_TIMESTAMP('2025-10-12 14:30:00');

PostgreSQL

-- Obtenir le timestamp actuel
SELECT EXTRACT(EPOCH FROM NOW());

-- À partir d'une date spécifique
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-10-12 14:30:00');

SQLite

-- Obtenir le timestamp actuel
SELECT STRFTIME('%s', 'now');

-- À partir d'une date spécifique
SELECT STRFTIME('%s', '2025-10-12 14:30:00');

Ligne de commande

Unix/Linux Shell

# Obtenir le timestamp actuel
date +%s

# Convertir une date spécifique en timestamp
date +%s -d "2025-10-12 14:30:00"

# Pour l'heure UTC/GMT, utiliser -ud au lieu de -d
date +%s -ud "2025-10-12 14:30:00"

PowerShell

# Obtenir le timestamp actuel
[int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))

Convertir DEPUIS Epoch vers une date lisible

Une fois que tu as un timestamp Unix, tu auras souvent besoin de le reconvertir en format de date lisible :

JavaScript

// Convertir le timestamp en objet Date
const date = new Date(timestamp * 1000); // Multiplier par 1000 pour les millisecondes

// Le formater
console.log(date.toLocaleString()); // Format local
console.log(date.toISOString());    // Format ISO 8601

PHP

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

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

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

Python

from datetime import datetime

# Convertir en objet datetime
dt = datetime.fromtimestamp(timestamp)

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

# Pour UTC
dt_utc = datetime.utcfromtimestamp(timestamp)

MySQL

-- Convertir le timestamp en datetime
SELECT FROM_UNIXTIME(1728773400);

-- Avec un format personnalisé
SELECT FROM_UNIXTIME(1728773400, '%Y-%m-%d %H:%i:%s');

Convertir DEPUIS une date lisible vers Epoch

L'opération inverse est tout aussi importante :

JavaScript

// Parser une chaîne de date en timestamp
const timestamp = Math.floor(new Date('2025-10-12 14:30:00').getTime() / 1000);

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

PHP

// Parser la plupart des textes de date en anglais
$timestamp = strtotime('15 November 2025');
$timestamp = strtotime('next Monday');
$timestamp = strtotime('+1 week');

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

Python

from datetime import datetime
import time

# Parser une chaîne de date
dt = datetime.strptime('2025-10-12 14:30:00', '%Y-%m-%d %H:%M:%S')
timestamp = int(dt.timestamp())

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

Bonnes pratiques

Lorsque tu travailles avec des timestamps Unix dans tes applications :

Utilise toujours des entiers 64 bits pour éviter le problème Y2038
Stocke les timestamps en UTC dans ta base de données, convertis en heure locale uniquement pour l'affichage
Sois cohérent avec ta précision (secondes vs millisecondes) dans toute ton application
Documente ton format – indique clairement si tu utilises des secondes ou des millisecondes
Considère les bibliothèques avec gestion des fuseaux horaires pour les opérations complexes de date/heure
Ne stocke jamais l'heure locale sous forme de timestamp sans information de fuseau horaire

Conclusion

Les timestamps Unix sont un concept fondamental en programmation que chaque développeur devrait comprendre. Ils fournissent un moyen simple et universel de représenter le temps qui fonctionne sur tous les systèmes et langages de programmation.

Que tu construises une application web, que tu travailles avec des bases de données, ou que tu aies simplement besoin de planifier des tâches, comprendre l'epoch time te facilitera grandement la vie. Utilise notre outil Convertisseur de Timestamp Unix pour convertir rapidement entre timestamps et dates lisibles !

Essaie maintenant : Rends-toi sur notre outil de conversion pour t'entraîner à travailler avec les timestamps Unix en temps réel !