MakeTimestamp logo
MakeTimestamp

Guides

Qu'est-ce qu'un Unix Timestamp ? Guide Complet du Temps Epoch

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écisionChiffresExempleDescription
Secondes101704067200Unix timestamp standard
Millisecondes131704067200000Utilisé en JavaScript, Java
Microsecondes161704067200000000Systèmes haute précision
Nanosecondes191704067200000000000Chronométrage ultra-précis

Unix Timestamp dans Différents Langages de Programmation

JavaScript / Node.js

// Obtenir l'Unix timestamp actuel (millisecondes)
const timestamp = Date.now();
console.log(timestamp); // 1704067200000

// Obtenir l'Unix timestamp en secondes
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // 1704067200

// Convertir Unix timestamp en Date
const date = new Date(1704067200000);
console.log(date); // 2024-01-01T00:00:00.000Z

// Convertir Date en Unix timestamp
const timestamp2 = new Date('2024-01-01').getTime();
console.log(timestamp2); // 1704067200000

Python

import time
from datetime import datetime

# Obtenir l'Unix timestamp actuel
timestamp = time.time()
print(timestamp)  # 1704067200.123456

# Obtenir l'Unix timestamp (entier)
timestamp_int = int(time.time())
print(timestamp_int)  # 1704067200

# Convertir Unix timestamp en datetime
dt = datetime.fromtimestamp(1704067200)
print(dt)  # 2024-01-01 00:00:00

# Convertir datetime en Unix timestamp
timestamp2 = datetime(2024, 1, 1).timestamp()
print(timestamp2)  # 1704067200.0

PHP

<?php
// Obtenir l'Unix timestamp actuel
$timestamp = time();
echo $timestamp; // 1704067200

// Convertir Unix timestamp en date
$date = date('Y-m-d H:i:s', 1704067200);
echo $date; // 2024-01-01 00:00:00

// Convertir date en Unix timestamp
$timestamp2 = strtotime('2024-01-01');
echo $timestamp2; // 1704067200
?>

Java

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;

// Obtenir l'Unix timestamp actuel (secondes)
long timestamp = Instant.now().getEpochSecond();
System.out.println(timestamp); // 1704067200

// Obtenir l'Unix timestamp (millisecondes)
long timestampMillis = System.currentTimeMillis();
System.out.println(timestampMillis); // 1704067200000

// Convertir Unix timestamp en LocalDateTime
LocalDateTime dateTime = LocalDateTime.ofEpochSecond(
    1704067200, 0, ZoneOffset.UTC
);
System.out.println(dateTime); // 2024-01-01T00:00:00

// Convertir LocalDateTime en Unix timestamp
long timestamp2 = dateTime.toEpochSecond(ZoneOffset.UTC);
System.out.println(timestamp2); // 1704067200

Go

package main

import (
    "fmt"
    "time"
)

func main() {
    // Obtenir l'Unix timestamp actuel
    timestamp := time.Now().Unix()
    fmt.Println(timestamp) // 1704067200

    // Convertir Unix timestamp en Time
    t := time.Unix(1704067200, 0)
    fmt.Println(t) // 2024-01-01 00:00:00 +0000 UTC

    // Convertir Time en Unix timestamp
    timestamp2 := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC).Unix()
    fmt.Println(timestamp2) // 1704067200
}

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 :

const debut = 1704067200; // 1er Jan, 2024
const fin = 1704153600;   // 2 Jan, 2024
const 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 :

const timestamps = [1704153600, 1704067200, 1704240000];
timestamps.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 :

CREATE TABLE utilisateurs (
    id INT PRIMARY KEY,
    nom_utilisateur VARCHAR(50),
    cree_a BIGINT,
    mis_a_jour_a BIGINT
);

2. Réponses API

Incluez des timestamps dans les réponses API :

{
  "id": 123,
  "message": "Bonjour le Monde",
  "timestamp": 1704067200,
  "cree_a": 1704067200
}

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 :

const cacheExpiry = Date.now() / 1000 + 3600; // Expire dans 1 heure

5. Gestion de Sessions

Suivez les timestamps de session utilisateur :

const sessionStart = Math.floor(Date.now() / 1000);
const 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 :

function isValidTimestamp(timestamp) {
    const min = 0; // Époque Unix
    const max = 2147483647; // Année 2038 pour 32 bits
    return timestamp >= min && timestamp <= max;
}

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 :

# Unix timestamp actuel
date +%s

# Convertir Unix timestamp en date
date -d @1704067200

# Convertir date en Unix timestamp
date -d "2024-01-01" +%s

Windows PowerShell :

powershell
# Unix timestamp actuel
[int][double]::Parse((Get-Date -UFormat %s))

# Convertir Unix timestamp en date
[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 !