Le zero est une date de naissance
Un timestamp de 0 correspond exactement au debut de l'epoch Unix : 1970-01-01T00:00:00Z (UTC).
Debut de l'epoch
Convertisseur de timestamp (UNIX ↔ Date)
Entrees et actions
Epoch actuel :
s · ms
Resultat
Resultat :
Conversion en lot (une valeur par ligne)
5 faits amusants sur les timestamps UNIX
Comptez les chiffres
10 chiffres = secondes ; 13 chiffres = millisecondes. Ajoutez ou retirez trois zeros pour passer de l'un a l'autre.
Secondes vs ms
Meme instant, horloges differentes
Les timestamps sont independants du fuseau. Londres, New York ou Tokyo affichent des heures locales differentes, mais c'est le meme instant.
Agnostique au fuseau
Le probleme de 2038
Le 2038-01-19 03:14:07 UTC, les compteurs 32 bits en secondes debordent. Les systemes modernes 64 bits evitent ce probleme.
Limite 32 bits
"Z" signifie Zulu (UTC)
En ISO-8601, le Z final (ex. 2025-03-01T10:30:00Z) signifie UTC, soit la meme heure partout.
ISO-8601
A propos de UNIX / temps epoch
Un timestamp UNIX (souvent appele temps epoch) est un nombre unique qui compte le temps ecoule
depuis l'epoch Unix : 1970-01-01T00:00:00Z (UTC). Il est tres utilise dans les journaux, bases de donnees
et API car il est compact, triable et independant du fuseau horaire.
Faits rapides
- Secondes vs millisecondes vs nanosecondes :
- 10 chiffres → secondes (ex.
1700000000) - 13 chiffres → millisecondes (ex.
1700000000000) - 16 chiffres → microsecondes (ex.
1700000000000000) - 19 chiffres → nanosecondes (souvent issues de systemes haute precision)
- 10 chiffres → secondes (ex.
- Independant du fuseau : le nombre represente un instant absolu ; seul son affichage change selon le fuseau/heure d'ete.
- Les valeurs negatives representent des dates avant 1970-01-01 (ex.
-31536000→ 1969-01-01T00:00:00Z). - Limite Y2038 (secondes 32 bits) :
2147483647→ 2038-01-19T03:14:07Z. Les systemes modernes en 64 bits ne sont pas touches.
Exemples courants
| Signification | Secondes | Millisecondes | UTC (ISO-8601) |
|---|---|---|---|
| Debut de l'epoch | 0 |
0 |
1970-01-01T00:00:00Z |
| Un milliard de secondes | 1000000000 |
1000000000000 |
2001-09-09T01:46:40Z |
| Limite 2038 (32 bits) | 2147483647 |
2147483647000 |
2038-01-19T03:14:07Z |
| Exemple ere actuelle | 1600000000 |
1600000000000 |
2020-09-13T12:26:40Z |
Fuseaux horaires et heure d'ete
- Un timestamp est stocke en UTC. Quand vous l'affichez en « Europe/London » ou « America/New_York », seule la chaine affichee change.
- Les changements d'heure d'ete ne modifient pas le timestamp sous-jacent ; ils modifient l'affichage de l'heure locale.
- Pour des chaines sans ambiguite, privilegiez ISO-8601 comme
2025-03-01T10:30:00Zou avec un decalage (ex.+01:00).
Conseils de parsing
- Les navigateurs interpretent une date sans fuseau dans le fuseau local de l'utilisateur :
2025-03-01 10:30:00→ heure locale2025-03-01T10:30:00Z→ UTC (leZfinal signifie Zulu/UTC)2025-03-01T10:30:00+05:30→ UTC+5:30
- Si vous collez un nombre a 10 chiffres (secondes) alors que vous attendez des millisecondes, multipliez par 1000.
- Si vous collez une valeur a 19 chiffres (nanosecondes), divisez par
1,000,000pour obtenir des millisecondes.
Quand utiliser chaque unite ?
- Secondes : de nombreuses API cote serveur, bases de donnees et outils en ligne de commande.
- Millisecondes : JavaScript
Date, navigateurs, et la plupart du code cote client. - Nanosecondes : journaux/telemetrie haute precision ; convertissez en ms pour JS
Date.
Temps epoch par langage (recettes rapides)
Extraits prets a copier-coller pour les taches courantes : obtenir l'epoch courant, convertir une date lisible en epoch, et convertir un epoch en date.
JavaScript (Navigateur et Node)
// epoch actuel
const s = Math.floor(Date.now() / 1000); // secondes
const ms = Date.now(); // millisecondes
// date -> epoch
const dt = new Date("2025-03-01T10:30:00Z");
const epochSeconds = Math.floor(dt.getTime() / 1000);
// epoch -> date
const d1 = new Date(1700000000 * 1000); // secondes → ms
const d2 = new Date(1700000000000); // ms
Python
import time, datetime, calendar
# epoch actuel
sec = time.time() # secondes decimales
ms = round(time.time()*1000)
# date -> epoch (UTC)
dt = datetime.datetime(2025, 3, 1, 10, 30, tzinfo=datetime.timezone.utc)
epoch_seconds = int(dt.timestamp())
# epoch -> date (UTC)
dt2 = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)
Java
import java.time.*;
long sec = Instant.now().getEpochSecond(); // epoch actuel (s)
long ms = Instant.now().toEpochMilli(); // epoch actuel (ms)
// date -> epoch
Instant ins = Instant.parse("2025-03-01T10:30:00Z");
long epochSeconds = ins.getEpochSecond();
// epoch -> date
Instant ins2 = Instant.ofEpochSecond(1700000000);
ZonedDateTime zdt = ins2.atZone(ZoneId.of("UTC"));
C# (.NET)
using System;
long sec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
long ms = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
// date -> epoch
var dto = new DateTimeOffset(2025, 3, 1, 10, 30, 0, TimeSpan.Zero);
long epochSeconds = dto.ToUnixTimeSeconds();
// epoch -> date
var dto2 = DateTimeOffset.FromUnixTimeSeconds(1700000000); // UTC
Go
package main
import ("fmt"; "time")
func main() {
sec := time.Now().Unix() // secondes
ms := time.Now().UnixMilli() // millisecondes
// date -> epoch (UTC)
t, _ := time.Parse(time.RFC3339, "2025-03-01T10:30:00Z")
fmt.Println(t.Unix())
// epoch -> date
t2 := time.Unix(1700000000, 0).UTC()
fmt.Println(t2.Format(time.RFC3339))
}
PHP
// epoch actuel
$sec = time(); // secondes
$ms = round(microtime(true)*1000);
// date -> epoch (UTC recommande)
$dt = new DateTime("2025-03-01T10:30:00Z");
$epoch = $dt->getTimestamp();
// epoch -> date
$dt2 = (new DateTime())->setTimestamp(1700000000)->setTimezone(new DateTimeZone("UTC"));
echo $dt2->format(DATE_RFC3339);
Ruby
# epoch actuel
s = Time.now.to_i # seconds
ms = (Time.now.to_f*1000).to_i
# date -> epoch (UTC)
t = Time.utc(2025,3,1,10,30,0)
s2 = t.to_i
# epoch -> date
t2 = Time.at(1700000000).utc
Rust
use std::time::{SystemTime, UNIX_EPOCH, Duration};
// epoch actuel
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let sec = now.as_secs();
let ms = now.as_millis();
// epoch -> date (exemple avec chrono)
use chrono::{DateTime, Utc, TimeZone};
let d: DateTime<Utc> = Utc.timestamp_opt(1_700_000_000, 0).unwrap();
Kotlin
import java.time.Instant
import java.time.ZoneId
val sec = Instant.now().epochSecond
val ms = Instant.now().toEpochMilli()
// date -> epoch
val ins = Instant.parse("2025-03-01T10:30:00Z")
val epochSeconds = ins.epochSecond
// epoch -> date
val zdt = Instant.ofEpochSecond(1700000000).atZone(ZoneId.of("UTC"))
Swift
import Foundation
let sec = Int(Date().timeIntervalSince1970) // secondes
let ms = Int(Date().timeIntervalSince1970 * 1000)
// date -> epoch (ISO8601)
let iso = ISO8601DateFormatter().date(from: "2025-03-01T10:30:00Z")!
let epoch = Int(iso.timeIntervalSince1970)
// epoch -> date
let d = Date(timeIntervalSince1970: 1700000000)
C++ (C++11+)
#include <chrono>
using namespace std::chrono;
// epoch actuel
auto now = system_clock::now();
auto sec = duration_cast<seconds>(now.time_since_epoch()).count();
auto ms = duration_cast<milliseconds>(now.time_since_epoch()).count();
// epoch → time_point
auto tp = system_clock::time_point{seconds{1700000000}};
Bash / shell Unix
# epoch actuel
date +%s # seconds
python3 - <<'PY'\nimport time; print(round(time.time()*1000))\nPY # ms fallback
# date -> epoch (UTC)
date -u -d "2025-03-01 10:30:00" +%s
# epoch -> date (local or -u for UTC)
date -d @1700000000
PowerShell
# epoch actuel
$sec = [int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))
$ms = [int]([DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds())
# epoch -> date
[DateTimeOffset]::FromUnixTimeSeconds(1700000000).UtcDateTime
PostgreSQL
-- current epoch (seconds)
SELECT EXTRACT(EPOCH FROM NOW());
-- date → epoch (UTC)
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-03-01 10:30:00+00');
-- epoch → timestamp
SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'UTC';
MySQL / MariaDB
-- current epoch
SELECT UNIX_TIMESTAMP();
-- date → epoch (suppose une chaine UTC si suffixee par 'Z')
SELECT UNIX_TIMESTAMP('2025-03-01 10:30:00');
-- epoch → datetime
SELECT FROM_UNIXTIME(1700000000);
Conseil : privilegiez les chaines ISO-8601 (ex. 2025-03-01T10:30:00Z) pour un UTC sans ambiguite. Si une API attend des secondes mais que vous avez des millisecondes, divisez par 1000 (et multipliez pour l'inverse).
FAQ
Un timestamp UNIX est-il affecte par les fuseaux horaires?
Non. Le timestamp encode un instant absolu ; seul son affichage change selon le fuseau horaire ou l'heure d'ete.
Secondes ou millisecondes : que dois-je utiliser ?
Les services cote serveur et API utilisent souvent les secondes ; les navigateurs et JavaScript utilisent generalement les millisecondes. Cet outil gere les deux.
Puis-je copier les resultats en ISO-8601 ?
Oui. Utilisez la sortie UTC pour des chaines ISO-8601 comme YYYY-MM-DDTHH:mm:ssZ.
Est-ce prive ?
Oui. Tout est calcule dans votre navigateur, sans requetes reseau pour les conversions.