MakeTimestamp logo
MakeTimestamp

Guides

Guide du Format ISO 8601 : Standard de Date, Heure et Fuseau Horaire

Qu'est-ce que ISO 8601 ?

ISO 8601 est un standard international pour représenter les dates et heures dans un format clair et non ambigu. Publié par l'Organisation internationale de normalisation (ISO), ce standard élimine la confusion causée par les différents formats de date dans le monde (comme MM/JJ/AAAA vs JJ/MM/AAAA) et fournit une méthode cohérente pour échanger les informations de date et d'heure.

Le format ISO 8601 est largement utilisé dans les APIs, bases de données et applications web car il est :

  • Non ambigu : Pas de confusion sur l'ordre jour/mois
  • Triable : Le tri lexicographique fonctionne correctement
  • Lisible par machine : Facile à analyser par les ordinateurs
  • Lisible par l'homme : Toujours compréhensible par les humains
  • Universel : Fonctionne dans tous les fuseaux horaires et locales

Pourquoi utiliser le format ISO 8601 ?

Quand vous voyez une date comme 03/04/2024, cela signifie-t-il le 4 mars ou le 3 avril ? Différents pays interprètent cela différemment. ISO 8601 résout ce problème en utilisant le format 2024-04-03, qui est toujours non ambigu : année-mois-jour.

// Formats ambigus (évitez ceux-ci)
"03/04/2024"  // Est-ce le 4 mars ou le 3 avril ?
"4-3-24"      // Est-ce 2024 ou 1924 ?

// Format ISO 8601 (recommandé)
"2024-04-03"  // Toujours le 3 avril 2024
"2024-04-03T14:30:00Z"  // 3 avril 2024, 14:30 UTC

Formats de Date ISO 8601

Format de Date de Base

Le format de date ISO 8601 standard suit le modèle : AAAA-MM-JJ

Exemples :

  • 2024-01-15 - 15 janvier 2024
  • 2024-12-31 - 31 décembre 2024
  • 2025-06-07 - 7 juin 2025
# Exemple Python
from datetime import date

aujourdhui = date(2024, 4, 15)
date_iso = aujourdhui.isoformat()  # "2024-04-15"
print(f"Date ISO 8601 : {date_iso}")

Format Étendu vs Basique

ISO 8601 prend en charge deux formats :

  1. Format étendu (avec séparateurs) : 2024-04-15
  2. Format basique (compact) : 20240415

La plupart des applications utilisent le format étendu car il est plus lisible.

// Exemple JavaScript
const date = new Date('2024-04-15');

// Format étendu (recommandé)
const etendu = date.toISOString().split('T')[0];  // "2024-04-15"

// Format basique (compact)
const basique = etendu.replace(/-/g, '');  // "20240415"

Formats d'Heure ISO 8601

Format d'Heure de Base

Le format d'heure ISO 8601 standard suit : HH:MM:SS ou HH:MM:SS.sss

Exemples :

  • 14:30:00 - 14:30:00
  • 09:05:30 - 09:05:30
  • 23:59:59.999 - 23:59:59.999 avec millisecondes

Secondes Fractionnaires

ISO 8601 prend en charge les secondes fractionnaires avec une précision variable :

  • 14:30:00.5 - Demi-seconde
  • 14:30:00.123 - Millisecondes (3 chiffres)
  • 14:30:00.123456 - Microsecondes (6 chiffres)
  • 14:30:00.123456789 - Nanosecondes (9 chiffres)

Formats DateTime ISO 8601

Date et Heure Combinées

Pour représenter à la fois la date et l'heure, ISO 8601 utilise un séparateur T : AAAA-MM-JJTHH:MM:SS

Exemples :

  • 2024-04-15T14:30:00 - 15 avril 2024 à 14:30 (heure locale)
  • 2024-12-31T23:59:59 - 31 décembre 2024 à 23:59:59

Le Séparateur "T"

Le caractère T sépare la date de l'heure. Il est requis dans le format standard, bien que certains systèmes acceptent un espace à la place pour la lisibilité.

Désignateurs de Fuseau Horaire ISO 8601

L'une des fonctionnalités les plus puissantes d'ISO 8601 est son support pour les informations de fuseau horaire.

Heure UTC (Désignateur Z)

Le suffixe Z indique UTC (Temps Universel Coordonné), également appelé "heure Zulu" :

  • 2024-04-15T14:30:00Z - 14:30 UTC

Z est un raccourci pour +00:00.

// Exemple JavaScript
const dateUtc = new Date('2024-04-15T14:30:00Z');
console.log(dateUtc.toISOString());  // "2024-04-15T14:30:00.000Z"

// Préférez toujours ISO 8601 avec Z pour les heures UTC
const timestamp = Date.now();
const chaineIso = new Date(timestamp).toISOString();
console.log(chaineIso);  // "2024-04-15T14:30:00.123Z"

Décalages de Fuseau Horaire

Pour les heures non UTC, spécifiez le décalage par rapport à UTC : ±HH:MM

Exemples :

  • 2024-04-15T14:30:00+05:30 - 14:30 en Inde (UTC+5:30)
  • 2024-04-15T14:30:00-04:00 - 14:30 en heure d'été de l'Est (UTC-4)
  • 2024-04-15T14:30:00+00:00 - Identique à Z (UTC)
# Exemple Python avec fuseau horaire
from datetime import datetime, timezone, timedelta

# Heure UTC
heure_utc = datetime(2024, 4, 15, 14, 30, 0, tzinfo=timezone.utc)
print(heure_utc.isoformat())  # "2024-04-15T14:30:00+00:00"

# Fuseau horaire personnalisé (UTC+5:30)
ist = timezone(timedelta(hours=5, minutes=30))
heure_ist = datetime(2024, 4, 15, 14, 30, 0, tzinfo=ist)
print(heure_ist.isoformat())  # "2024-04-15T14:30:00+05:30"

Format de Durée ISO 8601

ISO 8601 définit une notation spécifique pour les durées utilisant le préfixe P (pour "période").

Format de Durée : P[n]Y[n]M[n]DT[n]H[n]M[n]S

  • P : Désignateur de durée (requis)
  • Y : Années
  • M : Mois (avant T)
  • D : Jours
  • T : Désignateur de temps (sépare les composants date et temps)
  • H : Heures
  • M : Minutes (après T)
  • S : Secondes

Exemples de Durée

P3Y6M4DT12H30M5S  = 3 ans, 6 mois, 4 jours, 12 heures, 30 minutes, 5 secondes
P1Y               = 1 an
P6M               = 6 mois
P7D               = 7 jours
PT2H30M           = 2 heures, 30 minutes
PT45S             = 45 secondes
P1DT12H           = 1 jour, 12 heures

ISO 8601 vs RFC 3339

RFC 3339 est un profil d'ISO 8601 couramment utilisé sur internet. Les principales différences :

CaractéristiqueISO 8601RFC 3339
FormatAAAA-MM-JJTHH:MM:SS±HH:MMIdentique
UTCZ ou +00:00Les deux autorisés
Secondes fractionnairesOptionnel, toute précisionOptionnel, toute précision
SéparateursPeuvent être omis (format basique)Requis (format étendu)

La plupart des APIs modernes utilisent RFC 3339, qui est un sous-ensemble strict d'ISO 8601.

Meilleures Pratiques ISO 8601 pour Développeurs

1. Toujours Utiliser UTC pour le Stockage

// ✅ Bien - Stocker en UTC
const timestamp = new Date().toISOString();  // "2024-04-15T14:30:00.123Z"

// ❌ Mal - Stocker l'heure locale
const heureLocale = new Date().toString();  // "Mon Apr 15 2024 14:30:00 GMT+0500"

2. Inclure les Informations de Fuseau Horaire

# ✅ Bien - Inclut le fuseau horaire
"2024-04-15T14:30:00+05:30"

# ❌ Mal - Fuseau horaire manquant
"2024-04-15T14:30:00"

3. Utiliser le Format Étendu

// ✅ Bien - Format étendu
"2024-04-15T14:30:00Z"

// ❌ Mal - Format basique (difficile à lire)
"20240415T143000Z"

4. Valider les Chaînes ISO 8601

// Validation JavaScript
function estISO8601Valide(chaineDate) {
    const regexIso8601 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
    if (!regexIso8601.test(chaineDate)) return false;

    const date = new Date(chaineDate);
    return !isNaN(date.getTime());
}

console.log(estISO8601Valide("2024-04-15T14:30:00Z"));  // true
console.log(estISO8601Valide("2024-04-15 14:30:00"));   // false

Erreurs Courantes ISO 8601 à Éviter

1. Séparateur T Manquant

// ❌ Incorrect
"2024-04-15 14:30:00Z"

// ✅ Correct
"2024-04-15T14:30:00Z"

2. Format de Fuseau Horaire Incorrect

# ❌ Incorrect - Deux-points manquants dans le décalage
"2024-04-15T14:30:00+0530"

# ✅ Correct - Deux-points dans le décalage
"2024-04-15T14:30:00+05:30"

3. Mélanger les Formats de Date

// ❌ Incorrect - Format américain
"04/15/2024T14:30:00Z"

// ✅ Correct - ISO 8601
"2024-04-15T14:30:00Z"

4. Omettre les Zéros de Tête

# ❌ Incorrect
"2024-4-5T9:5:0Z"

# ✅ Correct
"2024-04-05T09:05:00Z"

ISO 8601 dans Différents Langages de Programmation

JavaScript / TypeScript

// Heure actuelle en ISO 8601
const maintenant = new Date().toISOString();
console.log(maintenant);  // "2024-04-15T14:30:00.123Z"

// Analyser une chaîne ISO 8601
const date = new Date("2024-04-15T14:30:00Z");

Python

from datetime import datetime, timezone

# Heure actuelle en ISO 8601
maintenant = datetime.now(timezone.utc).isoformat()
print(maintenant)  # "2024-04-15T14:30:00.123456+00:00"

# Analyser une chaîne ISO 8601
dt = datetime.fromisoformat("2024-04-15T14:30:00+00:00")

Java

import java.time.Instant;
import java.time.ZonedDateTime;

// Heure actuelle en ISO 8601
String maintenant = Instant.now().toString();
System.out.println(maintenant);  // "2024-04-15T14:30:00.123Z"

// Analyser une chaîne ISO 8601
ZonedDateTime dt = ZonedDateTime.parse("2024-04-15T14:30:00Z");

Go

package main

import (
    "fmt"
    "time"
)

func main() {
    // Heure actuelle en ISO 8601
    maintenant := time.Now().UTC().Format(time.RFC3339)
    fmt.Println(maintenant)  // "2024-04-15T14:30:00Z"

    // Analyser une chaîne ISO 8601
    dt, _ := time.Parse(time.RFC3339, "2024-04-15T14:30:00Z")
    fmt.Println(dt)
}

Questions Fréquentes

Que signifie le "T" dans ISO 8601 ?

Le T est un séparateur entre les composants date et heure. Il signifie "Time" (Temps) et est requis par le standard ISO 8601 pour éviter toute ambiguïté.

ISO 8601 est-il identique à RFC 3339 ?

RFC 3339 est un profil (sous-ensemble) d'ISO 8601 conçu pour une utilisation sur internet. RFC 3339 est plus strict et nécessite toujours le format étendu avec séparateurs.

Pourquoi ISO 8601 utilise-t-il l'ordre AAAA-MM-JJ ?

Cet ordre (de la plus grande à la plus petite unité) permet un tri naturel. Quand vous triez les dates ISO 8601 alphabétiquement, elles se trient automatiquement chronologiquement.

Quel fuseau horaire dois-je utiliser pour stocker les horodatages ?

Stockez toujours les horodatages en UTC (avec le désignateur Z) dans les bases de données et APIs. Convertissez en heure locale uniquement lors de l'affichage à l'utilisateur.

Conclusion

ISO 8601 est le standard de référence pour représenter les dates et heures dans les systèmes logiciels. En suivant le format ISO 8601, vous assurez que vos horodatages sont non ambigus, triables et compatibles avec les systèmes du monde entier.

Points clés :

  • Utilisez AAAA-MM-JJTHH:MM:SSZ pour les heures UTC
  • Incluez les informations de fuseau horaire (Z ou ±HH:MM)
  • Stockez les horodatages en UTC, affichez en heure locale
  • Validez les chaînes ISO 8601 avant de les analyser
  • Utilisez le format étendu (avec séparateurs) pour la lisibilité

Maîtriser le format ISO 8601 est essentiel pour tout développeur travaillant avec les dates et heures !

Essayez notre Convertisseur ISO 8601 pour convertir entre les formats !

Mise a jour

Seule une chaine ISO 8601 avec Z ou un decalage numerique correspond a un timestamp Unix unique. Avant de convertir 2024-01-01T00:00:00, definissez UTC ou un fuseau local.

Essayez

Testez votre conversion de timestamp

Résultat de date

Besoin de plus d'options ? Convertisseur ISO 8601

Tutoriels associés