Convertissez des secondes/millisecondes epoch en dates lisibles, et inversement. Confidentialite native (100% cote client).
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)
- 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:00Z ou 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 (le Z final 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,000 pour 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.
