Vérifier si une chaîne de caractères est une date au format ISO

JavaScriptJavaScriptBeginner
Pratiquer maintenant

This tutorial is from open-source community. Access the source code

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire (lab), nous allons explorer comment déterminer si une chaîne de caractères donnée est une chaîne de caractères de date valide au format ISO simplifié étendu (ISO 8601). Nous utiliserons le constructeur Date et ses méthodes associées pour créer un objet Date à partir de la chaîne de caractères et vérifier sa validité. À la fin du laboratoire, vous aurez une meilleure compréhension de la manipulation des dates en JavaScript et de la validation de celles-ci au format ISO.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL javascript(("JavaScript")) -.-> javascript/AdvancedConceptsGroup(["Advanced Concepts"]) javascript(("JavaScript")) -.-> javascript/BasicConceptsGroup(["Basic Concepts"]) javascript/BasicConceptsGroup -.-> javascript/data_types("Data Types") javascript/BasicConceptsGroup -.-> javascript/cond_stmts("Conditional Statements") javascript/BasicConceptsGroup -.-> javascript/functions("Functions") javascript/AdvancedConceptsGroup -.-> javascript/error_handle("Error Handling") subgraph Lab Skills javascript/data_types -.-> lab-28422{{"Vérifier si une chaîne de caractères est une date au format ISO"}} javascript/cond_stmts -.-> lab-28422{{"Vérifier si une chaîne de caractères est une date au format ISO"}} javascript/functions -.-> lab-28422{{"Vérifier si une chaîne de caractères est une date au format ISO"}} javascript/error_handle -.-> lab-28422{{"Vérifier si une chaîne de caractères est une date au format ISO"}} end

Comprendre le format de date ISO et les objets Date en JavaScript

Avant de commencer à coder, comprenons ce que représente le format de date ISO 8601 et comment JavaScript gère les dates.

Le format de date ISO 8601

Le format ISO 8601 est une norme internationale pour représenter les dates et les heures. Le format ISO simplifié étendu ressemble à ceci :

YYYY-MM-DDTHH:mm:ss.sssZ

Où :

  • YYYY représente l'année (quatre chiffres)
  • MM représente le mois (deux chiffres)
  • DD représente le jour (deux chiffres)
  • T est un caractère littéral séparant la date et l'heure
  • HH représente les heures (deux chiffres)
  • mm représente les minutes (deux chiffres)
  • ss représente les secondes (deux chiffres)
  • sss représente les millisecondes (trois chiffres)
  • Z indique le fuseau horaire UTC (heure Zulu)

Par exemple, 2023-05-12T14:30:15.123Z représente le 12 mai 2023, à 14 h 30 min 15 s et 123 millisecondes UTC.

L'objet Date en JavaScript

JavaScript fournit un objet Date intégré pour travailler avec les dates et les heures. Lorsque vous créez un nouvel objet Date, vous pouvez lui passer une chaîne de caractères formatée selon le standard ISO :

const date = new Date("2023-05-12T14:30:15.123Z");

Ouvrons le terminal et pratiquons le travail avec les objets Date :

  1. Ouvrez le Terminal en cliquant sur le menu Terminal en haut de l'IDE Web.
  2. Tapez node et appuyez sur Entrée pour démarrer le shell interactif Node.js.
  3. Créez un nouvel objet Date pour l'heure actuelle :
const now = new Date();
console.log(now);
node-prompt
  1. Convertissez cet objet Date en une chaîne de caractères au format ISO :
const isoString = now.toISOString();
console.log(isoString);

Vous devriez voir une sortie similaire à :

2023-05-12T14:30:15.123Z
  1. Créez un objet Date à partir d'une chaîne de caractères au format ISO :
const dateFromIso = new Date("2023-05-12T14:30:15.123Z");
console.log(dateFromIso);
node-prompt

Cela démontre comment JavaScript peut analyser et créer des objets Date à partir de chaînes de caractères formatées selon le standard ISO.

Création d'une fonction pour valider les chaînes de caractères de date au format ISO

Dans cette étape, nous allons créer une fonction JavaScript qui vérifie si une chaîne de caractères donnée est au format ISO 8601 valide.

Création de la fonction de validation

Créons un nouveau fichier JavaScript pour notre validateur de date ISO :

  1. Dans l'IDE Web, cliquez sur l'icône de l'Explorateur dans la barre latérale gauche.
  2. Cliquez avec le bouton droit dans l'explorateur de fichiers et sélectionnez "Nouveau fichier".
  3. Nommez le fichier isISODate.js et appuyez sur Entrée.
  4. Ajoutez le code suivant au fichier :
/**
 * Vérifie si une chaîne de caractères est une chaîne de caractères de date formatée selon le standard ISO 8601 valide
 * @param {string} val - La chaîne de caractères à vérifier
 * @return {boolean} - Retourne true si la chaîne de caractères est au format ISO, false sinon
 */
const isISOString = (val) => {
  // Crée un objet Date à partir de la chaîne de caractères d'entrée
  const d = new Date(val);

  // Vérifie si la date est valide (pas NaN) et si la chaîne de caractères ISO correspond à l'original
  return !Number.isNaN(d.valueOf()) && d.toISOString() === val;
};

// Exporte la fonction pour pouvoir l'utiliser ailleurs
module.exports = isISOString;

Examinons comment cette fonction fonctionne :

  1. new Date(val) crée un objet Date à partir de la chaîne de caractères d'entrée.
  2. d.valueOf() retourne la valeur numérique du timestamp (en millisecondes depuis le 1er janvier 1970).
  3. Number.isNaN(d.valueOf()) vérifie si la date est invalide (NaN signifie "Not a Number").
  4. d.toISOString() === val vérifie que la conversion de l'objet Date en une chaîne de caractères ISO correspond à l'entrée originale.

Test de notre fonction

Maintenant, créons un fichier de test simple pour tester notre fonction :

  1. Créez un autre fichier nommé testISO.js.
  2. Ajoutez le code suivant :
// Importe notre fonction isISOString
const isISOString = require("./isISODate");

// Teste avec une date formatée selon le standard ISO valide
console.log("Test d'une date ISO valide :");
console.log("2020-10-12T10:10:10.000Z");
console.log("Résultat :", isISOString("2020-10-12T10:10:10.000Z"));
console.log();

// Teste avec un format invalide
console.log("Test d'une date non ISO :");
console.log("2020-10-12");
console.log("Résultat :", isISOString("2020-10-12"));
  1. Exécutez le fichier de test en utilisant Node.js :
node testISO.js

Vous devriez voir une sortie similaire à :

Test d'une date ISO valide :
2020-10-12T10:10:10.000Z
Résultat : true

Test d'une date non ISO :
2020-10-12
Résultat : false

Cela montre que notre fonction identifie correctement que "2020-10-12T10:10:10.000Z" est une date formatée selon le standard ISO valide, tandis que "2020-10-12" ne l'est pas.

Test avec différents formats de date

Maintenant que nous avons notre fonction de validation de base, testons-la avec différents formats de date pour comprendre son comportement avec diverses entrées.

Création d'une suite de tests

Créons une suite de tests complète pour examiner différents formats de date :

  1. Créez un nouveau fichier nommé dateTester.js.
  2. Ajoutez le code suivant :
// Import our isISOString function
const isISOString = require("./isISODate");

// Function to test different date strings
function testDate(description, dateString) {
  console.log(`Testing: ${description}`);
  console.log(`Input: "${dateString}"`);
  console.log(`Is ISO Format: ${isISOString(dateString)}`);
  console.log("-----------------------");
}

// Valid ISO date examples
testDate("Standard ISO date with timezone Z", "2023-05-12T14:30:15.123Z");
testDate("ISO date with zero milliseconds", "2020-10-12T10:10:10.000Z");

// Invalid or non-ISO format examples
testDate("Date only (no time component)", "2023-05-12");
testDate("Date and time without milliseconds", "2023-05-12T14:30:15Z");
testDate(
  "Date with time zone offset instead of Z",
  "2023-05-12T14:30:15+01:00"
);
testDate("Invalid date (month 13 does not exist)", "2023-13-12T14:30:15.123Z");
testDate("Non-date string", "Hello World");
  1. Exécutez la suite de tests dans le terminal :
node dateTester.js

Vous devriez voir une sortie indiquant quelles chaînes de caractères sont des dates ISO valides et lesquelles ne le sont pas.

Compréhension des résultats

Analysons ce qui rend chaque cas de test valide ou invalide :

  1. 2023-05-12T14:30:15.123Z - C'est valide car il suit le format ISO 8601 complet avec l'indicateur de fuseau horaire UTC (Z).

  2. 2020-10-12T10:10:10.000Z - C'est également valide, avec les millisecondes explicitement définies sur 000.

  3. 2023-05-12 - C'est une date valide, mais pas au format ISO car elle manque de la composante horaire.

  4. 2023-05-12T14:30:15Z - Cela semble être au format ISO, mais il manque les millisecondes, qui sont requises dans le format ISO strict.

  5. 2023-05-12T14:30:15+01:00 - Cela utilise un décalage de fuseau horaire (+01:00) au lieu de 'Z'. Bien que cela soit valide selon l'ISO 8601, notre fonction exige le format exact produit par toISOString(), qui utilise toujours 'Z'.

  6. 2023-13-12T14:30:15.123Z - C'est une date invalide (le mois 13 n'existe pas), donc new Date() créera un objet Date invalide.

  7. Hello World - Ce n'est pas du tout une date, donc new Date() créera un objet Date invalide.

Notre fonction de validation vérifie spécifiquement deux conditions :

  1. La chaîne de caractères doit être analysée en une date valide (pas NaN).
  2. Lorsque cette date est convertie en une chaîne de caractères ISO, elle doit correspondre exactement à l'entrée originale.

Cette approche garantit que nous validons le format ISO exact produit par la méthode toISOString() de JavaScript.

Gestion des cas limites et amélioration de notre fonction

Dans cette étape finale, nous allons améliorer notre fonction isISOString pour gérer les cas limites et la rendre plus robuste.

Cas limites courants

Lors de la validation de données dans des applications réelles, vous devez gérer diverses entrées inattendues. Examinons quelques cas limites :

  1. Chaînes de caractères vides
  2. Valeurs non chaînes de caractères (null, undefined, nombres, objets)
  3. Différentes représentations de fuseaux horaires

Amélioration de notre fonction

Mettons à jour notre fichier isISODate.js pour gérer ces cas limites :

  1. Ouvrez le fichier isISODate.js dans l'IDE Web.
  2. Remplacez le code existant par cette version améliorée :
/**
 * Checks if a string is a valid ISO 8601 formatted date string
 * @param {string} val - The string to check
 * @return {boolean} - Returns true if the string is in ISO format, false otherwise
 */
const isISOString = (val) => {
  // Check if input is a string
  if (typeof val !== "string") {
    return false;
  }

  // Check if string is empty
  if (val.trim() === "") {
    return false;
  }

  try {
    // Create a Date object from the input string
    const d = new Date(val);

    // Check if the date is valid and if the ISO string matches the original
    return !Number.isNaN(d.valueOf()) && d.toISOString() === val;
  } catch (error) {
    // If any error occurs during validation, return false
    return false;
  }
};

// Export the function
module.exports = isISOString;

Cette fonction améliorée fait maintenant ce qui suit :

  1. Vérifie si l'entrée est une chaîne de caractères avant de la traiter.
  2. Gère les chaînes de caractères vides.
  3. Utilise un bloc try-catch pour gérer les erreurs qui pourraient survenir.
  4. Effectue toujours notre logique de validation principale.

Test de notre fonction améliorée

Créons un dernier fichier de test pour vérifier notre fonction améliorée avec les cas limites :

  1. Créez un nouveau fichier nommé edgeCaseTester.js.
  2. Ajoutez le code suivant :
// Import our improved isISOString function
const isISOString = require("./isISODate");

// Function to test and display results
function testCase(description, value) {
  console.log(`Testing: ${description}`);
  console.log(`Input: ${value === "" ? "(empty string)" : value}`);
  console.log(`Type: ${typeof value}`);
  console.log(`Is ISO Format: ${isISOString(value)}`);
  console.log("-----------------------");
}

// Test with various edge cases
testCase("Valid ISO date", "2023-05-12T14:30:15.123Z");
testCase("Empty string", "");
testCase("Null value", null);
testDate("Undefined value", undefined);
testCase("Number value", 12345);
testCase("Object value", {});
testCase("Current date as ISO string", new Date().toISOString());
  1. Exécutez le fichier de test :
node edgeCaseTester.js

Application dans le monde réel

Dans une application réelle, notre fonction isISOString pourrait être utilisée dans des scénarios tels que :

  1. Validation de l'entrée utilisateur dans un champ de date.
  2. Vérification des dates reçues depuis des API externes.
  3. Garantie d'un format de date cohérent dans une base de données.
  4. Validation des données avant traitement.

Par exemple, dans une fonction de validation de formulaire :

function validateForm(formData) {
  // Other validations...

  if (formData.startDate && !isISOString(formData.startDate)) {
    return {
      valid: false,
      error: "Start date must be in ISO format"
    };
  }

  // More validations...

  return { valid: true };
}

La fonction améliorée est maintenant suffisamment robuste pour gérer les entrées inattendues et fournir une validation fiable pour les chaînes de caractères de date au format ISO.

Résumé

Dans ce laboratoire, vous avez appris à valider si une chaîne de caractères est au format ISO simplifié étendu (ISO 8601). Voici ce que vous avez accompli :

  1. Appris le format de date ISO 8601 et sa structure
  2. Compris le fonctionnement des objets Date de JavaScript avec les chaînes de caractères au format ISO
  3. Créé une fonction pour valider si une chaîne de caractères est au format ISO exact
  4. Testé la fonction avec différents formats de date
  5. Amélioré la fonction pour gérer les cas limites et la rendre plus robuste

Cette compétence est particulièrement utile lorsque vous travaillez avec des API, des bases de données ou tout système où un formatage cohérent des dates est important. Le format ISO 8601 est largement utilisé car il évite l'ambiguïté et offre une manière standardisée de représenter les dates et les heures.

Points clés de ce laboratoire :

  • Le format ISO 8601 suit un modèle spécifique : YYYY-MM-DDTHH:mm:ss.sssZ
  • La méthode Date.prototype.toISOString() de JavaScript produit toujours des dates au format ISO 8601
  • La validation des dates nécessite de vérifier à la fois la validité et le format
  • Une gestion appropriée des erreurs rend les fonctions de validation plus robustes

Vous pouvez maintenant appliquer ces connaissances pour construire des applications plus fiables qui gèrent correctement les données de date et d'heure.