MakeTimestamp logo
MakeTimestamp

Guides

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

const detecterPrecision = (raw) => {
  const len = raw.length;
  if (len === 10) return { value: Number(raw) * 1000, unit: "ms" };
  if (len === 13) return { value: Number(raw), unit: "ms" };
  if (len === 16) return { value: Number(raw) / 1000, unit: "ms" }; // µs → ms
  if (len === 19) return { value: Number(raw) / 1_000_000, unit: "ms" }; // ns → ms
  throw new Error("Longueur invalide");
};

const versIso = (raw, tz = "UTC") => {
  const { value } = detecterPrecision(raw);
  return new Date(value).toISOString(); // Compatible RFC 3339
};

console.log(versIso("1704067200"));      // 10 chiffres -> secondes
console.log(versIso("1704067200000"));   // 13 chiffres -> millisecondes

Python

from datetime import datetime, timezone, timedelta

def vers_iso(raw: str, offset_minutes: int = 0) -> str:
    longueur = len(raw)
    if longueur == 10:
        ts = int(raw)
    elif longueur == 13:
        ts = int(raw) / 1000
    elif longueur == 16:
        ts = int(raw) / 1_000_000
    elif longueur == 19:
        ts = int(raw) / 1_000_000_000
    else:
        raise ValueError("Longueur invalide")

    tz = timezone(timedelta(minutes=offset_minutes))
    return datetime.fromtimestamp(ts, tz=tz).isoformat()

print(vers_iso("1704067200", 0))     # UTC
print(vers_iso("1704067200000", 60)) # UTC+01:00

Go

package main

import (
    "fmt"
    "strconv"
    "time"
)

func parseEpoch(raw string) (time.Time, error) {
    switch len(raw) {
    case 10:
        sec, _ := strconv.ParseInt(raw, 10, 64)
        return time.Unix(sec, 0).UTC(), nil
    case 13:
        ms, _ := strconv.ParseInt(raw, 10, 64)
        return time.Unix(0, ms*int64(time.Millisecond)).UTC(), nil
    case 16:
        us, _ := strconv.ParseInt(raw, 10, 64)
        return time.Unix(0, us*int64(time.Microsecond)).UTC(), nil
    case 19:
        ns, _ := strconv.ParseInt(raw, 10, 64)
        return time.Unix(0, ns).UTC(), nil
    }
    return time.Time{}, fmt.Errorf("longueur invalide")
}

func main() {
    t, _ := parseEpoch("1704067200")
    fmt.Println(t.Format(time.RFC3339)) // 2024-01-01T00:00:00Z
}

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