Convertisseur Timestamp vers ISO 8601 (Secondes, Millisecondes, Nanosecondes)

Pourquoi cette page

Vous recevez souvent des horodatages en secondes (10 chiffres), millisecondes (13), microsecondes (16) ou nanosecondes (19). Cette page vous donne des règles complètes, des extraits prêts à l'emploi et des liens vers le convertisseur complet pour transformer n'importe quel epoch en ISO 8601 / RFC 3339 sans deviner la précision.

Démarrage rapide (flux MVP)

1. Collez l'horodatage (nous détectons automatiquement la longueur et la précision).
2. Choisissez le fuseau horaire : UTC ou décalage personnalisé (ex., UTC+01:00).
3. Obtenez la sortie ISO 8601 / RFC 3339, puis copiez en un clic.
4. Besoin de l'intégrer ? Copiez un extrait de code ci-dessous.

Essayez l'outil interactif : Convertisseur Timestamp → ISO et Constructeur de Format.

Règles d'entrée et validation

• Détection de longueur : 10=secondes, 13=ms, 16=µs, 19=ns.
• Caractères autorisés : chiffres uniquement ; rejeter espaces et lettres.
• Plage : doit être dans les limites sûres de la plateforme (vérifier 32-bit vs 64-bit ; voir FAQ).
• Fuseau horaire : UTC par défaut ; décalages personnalisés comme +01:00, -05:30.
• DST : la sortie utilise ISO 8601 avec décalage ; UTC évite les surprises DST.

Extraits de code

JavaScript / Node.js

Copy
JAVASCRIPT
1const detecterPrecision = (raw) => {
2  const len = raw.length;
3  if (len === 10) return { value: Number(raw) * 1000, unit: "ms" };
4  if (len === 13) return { value: Number(raw), unit: "ms" };
5  if (len === 16) return { value: Number(raw) / 1000, unit: "ms" }; // µs → ms
6  if (len === 19) return { value: Number(raw) / 1_000_000, unit: "ms" }; // ns → ms
7  throw new Error("Longueur invalide");
8};
9
10const versIso = (raw, tz = "UTC") => {
11  const { value } = detecterPrecision(raw);
12  return new Date(value).toISOString(); // Compatible RFC 3339
13};
14
15console.log(versIso("1704067200"));      // 10 chiffres -> secondes
16console.log(versIso("1704067200000"));   // 13 chiffres -> millisecondes

Python

Copy
PYTHON
1from datetime import datetime, timezone, timedelta
2
3def vers_iso(raw: str, offset_minutes: int = 0) -> str:
4    longueur = len(raw)
5    if longueur == 10:
6        ts = int(raw)
7    elif longueur == 13:
8        ts = int(raw) / 1000
9    elif longueur == 16:
10        ts = int(raw) / 1_000_000
11    elif longueur == 19:
12        ts = int(raw) / 1_000_000_000
13    else:
14        raise ValueError("Longueur invalide")
15
16    tz = timezone(timedelta(minutes=offset_minutes))
17    return datetime.fromtimestamp(ts, tz=tz).isoformat()
18
19print(vers_iso("1704067200", 0))     # UTC
20print(vers_iso("1704067200000", 60)) # UTC+01:00

Go

Copy
GO
1package main
2
3import (
4    "fmt"
5    "strconv"
6    "time"
7)
8
9func parseEpoch(raw string) (time.Time, error) {
10    switch len(raw) {
11    case 10:
12        sec, _ := strconv.ParseInt(raw, 10, 64)
13        return time.Unix(sec, 0).UTC(), nil
14    case 13:
15        ms, _ := strconv.ParseInt(raw, 10, 64)
16        return time.Unix(0, ms*int64(time.Millisecond)).UTC(), nil
17    case 16:
18        us, _ := strconv.ParseInt(raw, 10, 64)
19        return time.Unix(0, us*int64(time.Microsecond)).UTC(), nil
20    case 19:
21        ns, _ := strconv.ParseInt(raw, 10, 64)
22        return time.Unix(0, ns).UTC(), nil
23    }
24    return time.Time{}, fmt.Errorf("longueur invalide")
25}
26
27func main() {
28    t, _ := parseEpoch("1704067200")
29    fmt.Println(t.Format(time.RFC3339)) // 2024-01-01T00:00:00Z
30}

FAQ

• Et si je ne connais pas la précision ? Comptez les chiffres : 10=s, 13=ms, 16=µs, 19=ns.
• Dois-je toujours utiliser UTC ? Oui pour le stockage ; convertissez en heure locale uniquement pour l'affichage.
• Cela gère-t-il les années bissextiles et le DST ? Oui, les bibliothèques de date le gèrent automatiquement.

Outils et guides connexes

• Convertisseur Unix Timestamp
• Convertisseur par Lots
• Constructeur de Format
• Guide ISO 8601
• Niveaux de Précision