Qu'est-ce qu'un Unix Timestamp ?
Un Unix timestamp (également connu sous le nom de temps Unix, temps POSIX ou temps Epoch) est un système de suivi du temps sous forme d'un seul nombre. Il représente le nombre de secondes qui se sont écoulées depuis le 1er janvier 1970, 00:00:00 UTC, en excluant les secondes intercalaires. Ce moment dans le temps est appelé l'époque Unix.
Par exemple, l'Unix timestamp 1704067200 représente le 1er janvier 2024, 00:00:00 UTC.
Caractéristiques Principales
- Simple : Un seul nombre pour représenter n'importe quel moment dans le temps
- Universel : Fonctionne de la même manière dans tous les fuseaux horaires et systèmes
- Efficace : Facile à stocker, comparer et calculer
- Standardisé : Largement adopté dans les langages de programmation et bases de données
Pourquoi l'Unix Timestamp commence-t-il le 1er janvier 1970 ?
L'Unix timestamp commence le 1er janvier 1970 car c'est à cette époque que le système d'exploitation Unix était en cours de développement. Les développeurs avaient besoin d'un point de référence pour leur système de temps, et ils ont choisi une date récente et ronde facile à retenir.
Cette date est connue sous le nom d'époque Unix ou temps epoch. Tous les Unix timestamps sont calculés comme le nombre de secondes depuis ce moment.
Contexte Historique
- 1969-1970 : Développement du système d'exploitation Unix chez Bell Labs
- Besoin de simplicité : Les développeurs voulaient un moyen simple de suivre le temps
- Systèmes 32 bits : Conçu à l'origine pour fonctionner avec des entiers 32 bits
- Adoption large : Est devenu le standard pour le chronométrage informatique
Comment fonctionne l'Unix Timestamp
Concept de Base
L'Unix timestamp est simplement un compteur qui s'incrémente de 1 chaque seconde :
Époque Unix (Début) : 0 → 1er janvier 1970, 00:00:00 UTC
Après 1 seconde : 1 → 1er janvier 1970, 00:00:01 UTC
Après 1 heure : 3600 → 1er janvier 1970, 01:00:00 UTC
Après 1 jour : 86400 → 2 janvier 1970, 00:00:00 UTC
Après 1 an : 31536000 → 1er janvier 1971, 00:00:00 UTC
Aujourd'hui (2025) : ~1735689600 → Heure actuelle
Niveaux de Précision
Les Unix timestamps peuvent avoir différents niveaux de précision :
| Précision | Chiffres | Exemple | Description |
|---|---|---|---|
| Secondes | 10 | 1704067200 | Unix timestamp standard |
| Millisecondes | 13 | 1704067200000 | Utilisé en JavaScript, Java |
| Microsecondes | 16 | 1704067200000000 | Systèmes haute précision |
| Nanosecondes | 19 | 1704067200000000000 | Chronométrage ultra-précis |
Unix Timestamp dans Différents Langages de Programmation
JavaScript / Node.js
JAVASCRIPT1// Obtenir l'Unix timestamp actuel (millisecondes) 2const timestamp = Date.now(); 3console.log(timestamp); // 1704067200000 4 5// Obtenir l'Unix timestamp en secondes 6const timestampSeconds = Math.floor(Date.now() / 1000); 7console.log(timestampSeconds); // 1704067200 8 9// Convertir Unix timestamp en Date 10const date = new Date(1704067200000); 11console.log(date); // 2024-01-01T00:00:00.000Z 12 13// Convertir Date en Unix timestamp 14const timestamp2 = new Date('2024-01-01').getTime(); 15console.log(timestamp2); // 1704067200000
Python
PYTHON1import time 2from datetime import datetime 3 4# Obtenir l'Unix timestamp actuel 5timestamp = time.time() 6print(timestamp) # 1704067200.123456 7 8# Obtenir l'Unix timestamp (entier) 9timestamp_int = int(time.time()) 10print(timestamp_int) # 1704067200 11 12# Convertir Unix timestamp en datetime 13dt = datetime.fromtimestamp(1704067200) 14print(dt) # 2024-01-01 00:00:00 15 16# Convertir datetime en Unix timestamp 17timestamp2 = datetime(2024, 1, 1).timestamp() 18print(timestamp2) # 1704067200.0
PHP
PHP1<?php 2// Obtenir l'Unix timestamp actuel 3$timestamp = time(); 4echo $timestamp; // 1704067200 5 6// Convertir Unix timestamp en date 7$date = date('Y-m-d H:i:s', 1704067200); 8echo $date; // 2024-01-01 00:00:00 9 10// Convertir date en Unix timestamp 11$timestamp2 = strtotime('2024-01-01'); 12echo $timestamp2; // 1704067200 13?>
Java
JAVA1import java.time.Instant; 2import java.time.LocalDateTime; 3import java.time.ZoneOffset; 4 5// Obtenir l'Unix timestamp actuel (secondes) 6long timestamp = Instant.now().getEpochSecond(); 7System.out.println(timestamp); // 1704067200 8 9// Obtenir l'Unix timestamp (millisecondes) 10long timestampMillis = System.currentTimeMillis(); 11System.out.println(timestampMillis); // 1704067200000 12 13// Convertir Unix timestamp en LocalDateTime 14LocalDateTime dateTime = LocalDateTime.ofEpochSecond( 15 1704067200, 0, ZoneOffset.UTC 16); 17System.out.println(dateTime); // 2024-01-01T00:00:00 18 19// Convertir LocalDateTime en Unix timestamp 20long timestamp2 = dateTime.toEpochSecond(ZoneOffset.UTC); 21System.out.println(timestamp2); // 1704067200
Go
GO1package main 2 3import ( 4 "fmt" 5 "time" 6) 7 8func main() { 9 // Obtenir l'Unix timestamp actuel 10 timestamp := time.Now().Unix() 11 fmt.Println(timestamp) // 1704067200 12 13 // Convertir Unix timestamp en Time 14 t := time.Unix(1704067200, 0) 15 fmt.Println(t) // 2024-01-01 00:00:00 +0000 UTC 16 17 // Convertir Time en Unix timestamp 18 timestamp2 := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC).Unix() 19 fmt.Println(timestamp2) // 1704067200 20}
Avantages de l'Unix Timestamp
1. Simplicité
Un seul nombre est plus facile à manipuler que des chaînes de date/heure complexes.
2. Indépendance du Fuseau Horaire
Les Unix timestamps sont toujours en UTC, éliminant la confusion des fuseaux horaires.
3. Calculs Faciles
Calculez les différences de temps par simple soustraction :
JAVASCRIPT1const debut = 1704067200; // 1er Jan, 2024 2const fin = 1704153600; // 2 Jan, 2024 3const difference = fin - debut; // 86400 secondes = 1 jour
4. Stockage Efficace
Stocker un seul entier est plus efficace que stocker des chaînes de date.
5. Tri et Comparaison
Facile à trier et comparer les timestamps :
JAVASCRIPT1const timestamps = [1704153600, 1704067200, 1704240000]; 2timestamps.sort((a, b) => a - b); // Ordre chronologique
Limitations de l'Unix Timestamp
1. Problème de l'Année 2038
Sur les systèmes 32 bits, les Unix timestamps déborderont le 19 janvier 2038, 03:14:07 UTC. C'est parce que les entiers signés 32 bits ne peuvent représenter que des valeurs jusqu'à 2 147 483 647.
Solution : Utiliser des timestamps 64 bits, qui peuvent représenter des dates très loin dans le futur.
2. Secondes Intercalaires
Les Unix timestamps ignorent les secondes intercalaires, qui sont parfois ajoutées à l'UTC pour tenir compte de la rotation irrégulière de la Terre.
3. Limitations de Précision
Les Unix timestamps standard (secondes) peuvent ne pas être assez précis pour certaines applications. Utilisez les millisecondes ou microsecondes pour une précision supérieure.
4. Lisibilité Humaine
Les Unix timestamps ne sont pas lisibles par les humains. Vous devez les convertir pour afficher des dates significatives.
Cas d'Utilisation Courants
1. Timestamps de Base de Données
Stockez les temps de création et modification efficacement :
SQL1CREATE TABLE utilisateurs ( 2 id INT PRIMARY KEY, 3 nom_utilisateur VARCHAR(50), 4 cree_a BIGINT, 5 mis_a_jour_a BIGINT 6);
2. Réponses API
Incluez des timestamps dans les réponses API :
JSON1{ 2 "id": 123, 3 "message": "Bonjour le Monde", 4 "timestamp": 1704067200, 5 "cree_a": 1704067200 6}
3. Fichiers de Log
Suivez quand les événements se produisent :
[1704067200] INFO: Utilisateur connecté
[1704067205] WARNING: Tentative de connexion échouée
[1704067210] ERROR: Échec de connexion à la base de données
4. Cache et Expiration
Définissez les temps d'expiration du cache :
JAVASCRIPT1const cacheExpiry = Date.now() / 1000 + 3600; // Expire dans 1 heure
5. Gestion de Sessions
Suivez les timestamps de session utilisateur :
JAVASCRIPT1const sessionStart = Math.floor(Date.now() / 1000); 2const sessionExpiry = sessionStart + 1800; // 30 minutes
Meilleures Pratiques
1. Toujours Utiliser UTC
Stockez les Unix timestamps en UTC pour éviter les problèmes de fuseau horaire.
2. Choisissez la Précision Appropriée
- Utilisez les secondes pour la plupart des applications
- Utilisez les millisecondes pour les applications web (JavaScript)
- Utilisez les microsecondes ou nanosecondes pour le chronométrage haute précision
3. Utilisez des Entiers 64 bits
Évitez le problème de l'Année 2038 en utilisant des timestamps 64 bits.
4. Validez les Timestamps
Vérifiez si les timestamps sont dans des plages raisonnables :
JAVASCRIPT1function isValidTimestamp(timestamp) { 2 const min = 0; // Époque Unix 3 const max = 2147483647; // Année 2038 pour 32 bits 4 return timestamp >= min && timestamp <= max; 5}
5. Documentez la Précision
Documentez toujours si vos timestamps sont en secondes, millisecondes ou autres unités.
Conversion des Unix Timestamps
Outils en Ligne
Utilisez MakeTimestamp.com↗ pour convertir les Unix timestamps en dates lisibles et vice versa.
Ligne de Commande
Linux/Mac :
BASH1# Unix timestamp actuel 2date +%s 3 4# Convertir Unix timestamp en date 5date -d @1704067200 6 7# Convertir date en Unix timestamp 8date -d "2024-01-01" +%s
Windows PowerShell :
POWERSHELL1# Unix timestamp actuel 2[int][double]::Parse((Get-Date -UFormat %s)) 3 4# Convertir Unix timestamp en date 5[DateTimeOffset]::FromUnixTimeSeconds(1704067200).DateTime
Concepts Associés
ISO 8601
Un format de date/heure standardisé : 2024-01-01T00:00:00Z
RFC 3339
Format de timestamp Internet : 2024-01-01T00:00:00+00:00
Temps POSIX
Un autre nom pour le temps Unix, défini par le standard POSIX.
Temps Epoch
Terme général pour le temps mesuré depuis un point de départ spécifique (époque).
Questions Fréquentes
Que représente Unix timestamp 0 ?
Unix timestamp 0 représente l'époque Unix : 1er janvier 1970, 00:00:00 UTC.
Les Unix timestamps peuvent-ils être négatifs ?
Oui ! Les Unix timestamps négatifs représentent des dates avant le 1er janvier 1970. Par exemple, -86400 représente le 31 décembre 1969.
Pourquoi certains timestamps ont-ils 13 chiffres ?
Les timestamps de 13 chiffres sont en millisecondes (couramment utilisés en JavaScript), tandis que les timestamps de 10 chiffres sont en secondes.
Comment convertir entre secondes et millisecondes ?
- Secondes en millisecondes : Multiplier par 1000
- Millisecondes en secondes : Diviser par 1000
Que se passe-t-il après l'Année 2038 ?
Sur les systèmes 64 bits, les Unix timestamps peuvent représenter des dates jusqu'à l'année 292 277 026 596. Sur les systèmes 32 bits, vous devrez mettre à niveau ou utiliser des représentations de temps alternatives.
Les Unix timestamps sont-ils affectés par les fuseaux horaires ?
Non ! Les Unix timestamps sont toujours en UTC. Les fuseaux horaires ne s'appliquent que lors de l'affichage du timestamp comme une date lisible par l'homme.
Résumé
L'Unix timestamp est un moyen simple, efficace et universel de représenter le temps sous forme d'un seul nombre. Il compte les secondes depuis le 1er janvier 1970 (l'époque Unix) et est largement utilisé en programmation, bases de données et APIs.
Points Clés :
- Unix timestamp = secondes depuis le 1er janvier 1970, 00:00:00 UTC
- Simple, universel et efficace pour le suivi du temps
- Disponible en plusieurs niveaux de précision (secondes, millisecondes, etc.)
- Attention au problème de l'Année 2038 sur les systèmes 32 bits
- Stockez toujours les timestamps en UTC
Prêt à travailler avec les Unix timestamps ? Essayez notre Convertisseur Unix Timestamp↗ pour convertir entre timestamps et dates lisibles instantanément !