Zeichenkette ist ein ISO-formatiertes Datum

JavaScriptJavaScriptBeginner
Jetzt üben

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

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab werden wir untersuchen, wie man feststellt, ob eine gegebene Zeichenkette (string) eine gültige Datumszeichenkette im vereinfachten erweiterten ISO-Format (ISO 8601) ist. Wir werden den Date-Konstruktor und seine zugehörigen Methoden verwenden, um aus der Zeichenkette ein Date-Objekt zu erstellen und seine Gültigkeit zu überprüfen. Am Ende des Labs werden Sie besser verstehen, wie man mit Datumsangaben in JavaScript arbeitet und wie man diese mithilfe des ISO-Formats validiert.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL javascript(("JavaScript")) -.-> javascript/BasicConceptsGroup(["Basic Concepts"]) javascript(("JavaScript")) -.-> javascript/AdvancedConceptsGroup(["Advanced 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{{"Zeichenkette ist ein ISO-formatiertes Datum"}} javascript/cond_stmts -.-> lab-28422{{"Zeichenkette ist ein ISO-formatiertes Datum"}} javascript/functions -.-> lab-28422{{"Zeichenkette ist ein ISO-formatiertes Datum"}} javascript/error_handle -.-> lab-28422{{"Zeichenkette ist ein ISO-formatiertes Datum"}} end

Verständnis des ISO-Datumsformats und von JavaScript-Date-Objekten

Bevor wir mit dem Codieren beginnen, lernen wir zunächst, was das ISO 8601-Datumsformat ist und wie JavaScript mit Datumsangaben umgeht.

Das ISO 8601-Datumsformat

Das ISO 8601-Format ist ein internationaler Standard zur Darstellung von Daten und Zeiten. Das vereinfachte erweiterte ISO-Format sieht wie folgt aus:

YYYY-MM-DDTHH:mm:ss.sssZ

Dabei bedeuten:

  • YYYY steht für das Jahr (vier Ziffern)
  • MM steht für den Monat (zwei Ziffern)
  • DD steht für den Tag (zwei Ziffern)
  • T ist ein Literalzeichen, das Datum und Zeit trennt
  • HH steht für die Stunden (zwei Ziffern)
  • mm steht für die Minuten (zwei Ziffern)
  • ss steht für die Sekunden (zwei Ziffern)
  • sss steht für die Millisekunden (drei Ziffern)
  • Z gibt die UTC-Zeitzone (Zulu-Zeit) an

Beispielsweise repräsentiert 2023-05-12T14:30:15.123Z den 12. Mai 2023, 14:30:15.123 Uhr UTC.

Das JavaScript-Date-Objekt

JavaScript bietet ein eingebautes Date-Objekt für die Arbeit mit Daten und Zeiten. Wenn Sie ein neues Date-Objekt erstellen, können Sie ihm einen ISO-formatierte Zeichenkette übergeben:

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

Öffnen wir das Terminal und üben die Arbeit mit Date-Objekten:

  1. Öffnen Sie das Terminal, indem Sie auf das Terminal-Menü oben im WebIDE klicken.
  2. Geben Sie node ein und drücken Sie die Eingabetaste, um die Node.js interaktive Shell zu starten.
  3. Erstellen Sie ein neues Date-Objekt für die aktuelle Zeit:
const now = new Date();
console.log(now);
node-prompt
  1. Konvertieren Sie dieses Date-Objekt in eine ISO-Zeichenkette:
const isoString = now.toISOString();
console.log(isoString);

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

2023-05-12T14:30:15.123Z
  1. Erstellen Sie ein Date-Objekt aus einer ISO-Zeichenkette:
const dateFromIso = new Date("2023-05-12T14:30:15.123Z");
console.log(dateFromIso);
node-prompt

Dies zeigt, wie JavaScript ISO-formatierte Zeichenketten analysieren und daraus Date-Objekte erstellen kann.

Erstellen einer Funktion zur Validierung von ISO-formatierte Datumszeichenketten

In diesem Schritt werden wir eine JavaScript-Funktion erstellen, die prüft, ob eine gegebene Zeichenkette im gültigen ISO 8601-Format vorliegt.

Erstellen der Validierungsfunktion

Erstellen wir eine neue JavaScript-Datei für unseren ISO-Datum-Validator:

  1. Klicken Sie im WebIDE auf das Explorer-Symbol in der linken Seitenleiste.
  2. Klicken Sie mit der rechten Maustaste im Dateiexplorer und wählen Sie "Neue Datei".
  3. Benennen Sie die Datei isISODate.js und drücken Sie die Eingabetaste.
  4. Fügen Sie den folgenden Code zur Datei hinzu:
/**
 * 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) => {
  // Create a Date object from the input string
  const d = new Date(val);

  // Check if the date is valid (not NaN) and if the ISO string matches the original
  return !Number.isNaN(d.valueOf()) && d.toISOString() === val;
};

// Export the function so we can use it elsewhere
module.exports = isISOString;

Untersuchen wir, wie diese Funktion funktioniert:

  1. new Date(val) erstellt ein Date-Objekt aus der Eingabezeichenkette.
  2. d.valueOf() gibt den numerischen Zeitstempelwert (Millisekunden seit dem 1. Januar 1970) zurück.
  3. Number.isNaN(d.valueOf()) prüft, ob das Datum ungültig ist (NaN steht für "Not a Number").
  4. d.toISOString() === val überprüft, ob das Konvertieren des Date-Objekts zurück in eine ISO-Zeichenkette mit der ursprünglichen Eingabe übereinstimmt.

Testen unserer Funktion

Jetzt erstellen wir eine einfache Testdatei, um unsere Funktion zu testen:

  1. Erstellen Sie eine weitere Datei mit dem Namen testISO.js.
  2. Fügen Sie den folgenden Code hinzu:
// Import our isISOString function
const isISOString = require("./isISODate");

// Test with a valid ISO formatted date
console.log("Testing a valid ISO date:");
console.log("2020-10-12T10:10:10.000Z");
console.log("Result:", isISOString("2020-10-12T10:10:10.000Z"));
console.log();

// Test with an invalid format
console.log("Testing a non-ISO date:");
console.log("2020-10-12");
console.log("Result:", isISOString("2020-10-12"));
  1. Führen Sie die Testdatei mit Node.js aus:
node testISO.js

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Testing a valid ISO date:
2020-10-12T10:10:10.000Z
Result: true

Testing a non-ISO date:
2020-10-12
Result: false

Dies zeigt, dass unsere Funktion korrekt erkennt, dass "2020-10-12T10:10:10.000Z" ein gültiges ISO-formatiertes Datum ist, während "2020-10-12" es nicht ist.

Testen mit verschiedenen Datumsformaten

Nachdem wir nun unsere grundlegende Validierungsfunktion haben, lassen Sie uns sie mit verschiedenen Datumsformaten testen, um zu verstehen, wie sie auf verschiedene Eingaben reagiert.

Erstellen einer Testsuite

Erstellen wir eine umfassende Testsuite, um verschiedene Datumsformate zu untersuchen:

  1. Erstellen Sie eine neue Datei mit dem Namen dateTester.js.
  2. Fügen Sie den folgenden Code hinzu:
// 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. Führen Sie die Testsuite im Terminal aus:
node dateTester.js

Sie sollten eine Ausgabe sehen, die zeigt, welche Zeichenketten gültige ISO-Daten sind und welche nicht.

Verständnis der Ergebnisse

Lassen Sie uns analysieren, was jeden Testfall gültig oder ungültig macht:

  1. 2023-05-12T14:30:15.123Z – Dies ist gültig, da es dem vollständigen ISO 8601-Format mit dem UTC-Zeitzonenindikator (Z) entspricht.

  2. 2020-10-12T10:10:10.000Z – Dies ist ebenfalls gültig, wobei die Millisekunden explizit auf 000 gesetzt sind.

  3. 2023-05-12 – Dies ist ein gültiges Datum, aber nicht im ISO-Format, da der Zeitanteil fehlt.

  4. 2023-05-12T14:30:15Z – Dies scheint ein ISO-Format zu sein, fehlt aber an den Millisekunden, die im strengen ISO-Format erforderlich sind.

  5. 2023-05-12T14:30:15+01:00 – Hier wird ein Zeitzonenoffset (+01:00) anstelle von 'Z' verwendet. Obwohl dies gemäß ISO 8601 gültig ist, erfordert unsere Funktion das genaue Format, das von toISOString() erzeugt wird, das immer 'Z' verwendet.

  6. 2023-13-12T14:30:15.123Z – Dies ist ein ungültiges Datum (der Monat 13 existiert nicht), daher wird new Date() ein ungültiges Date-Objekt erstellen.

  7. Hello World – Dies ist überhaupt kein Datum, daher wird new Date() ein ungültiges Date-Objekt erstellen.

Unsere Validierungsfunktion prüft speziell zwei Bedingungen:

  1. Die Zeichenkette muss zu einem gültigen Datum geparst werden (nicht NaN).
  2. Wenn dieses Datum wieder in eine ISO-Zeichenkette umgewandelt wird, muss es exakt mit der ursprünglichen Eingabe übereinstimmen.

Dieser Ansatz stellt sicher, dass wir das genaue ISO-Format validieren, das von JavaScripts toISOString()-Methode erzeugt wird.

Umgang mit Randfällen und Verbesserung unserer Funktion

In diesem letzten Schritt werden wir unsere isISOString-Funktion verbessern, um Randfälle zu behandeln und sie robuster zu machen.

Häufige Randfälle

Bei der Validierung von Daten in realen Anwendungen müssen Sie verschiedene unerwartete Eingaben behandeln. Lassen Sie uns einige Randfälle untersuchen:

  1. Leere Zeichenketten
  2. Nicht-Zeichenketten-Werte (null, undefined, Zahlen, Objekte)
  3. Verschiedene Zeitzonenrepräsentationen

Verbessern unserer Funktion

Lassen Sie uns die Datei isISODate.js aktualisieren, um diese Randfälle zu behandeln:

  1. Öffnen Sie die Datei isISODate.js im WebIDE.
  2. Ersetzen Sie den vorhandenen Code durch diese verbesserte Version:
/**
 * 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;

Diese verbesserte Funktion macht nun Folgendes:

  1. Prüft, ob die Eingabe eine Zeichenkette ist, bevor sie verarbeitet wird.
  2. Behandelt leere Zeichenketten.
  3. Nutzt einen try-catch-Block, um alle Fehler zu behandeln, die auftreten könnten.
  4. Führt weiterhin unsere Kernvalidierungslogik aus.

Testen unserer verbesserten Funktion

Lassen Sie uns eine letzte Testdatei erstellen, um unsere verbesserte Funktion mit Randfällen zu überprüfen:

  1. Erstellen Sie eine neue Datei mit dem Namen edgeCaseTester.js.
  2. Fügen Sie den folgenden Code hinzu:
// 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. Führen Sie die Testdatei aus:
node edgeCaseTester.js

Anwendungen in der Realität

In einer realen Anwendung könnte unsere isISOString-Funktion in Szenarien wie diesen verwendet werden:

  1. Validierung von Benutzereingaben in einem Datumsfeld.
  2. Prüfung von Daten, die von externen APIs empfangen werden.
  3. Sicherstellung eines konsistenten Datumsformats in einer Datenbank.
  4. Datenvalidierung vor der Verarbeitung.

Beispielsweise in einer Formularvalidierungsfunktion:

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 };
}

Die verbesserte Funktion ist nun robust genug, um unerwartete Eingaben zu behandeln und eine zuverlässige Validierung von ISO-formatierten Datumszeichenketten bereitzustellen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie überprüfen können, ob eine Zeichenkette im vereinfachten erweiterten ISO-Format (ISO 8601) vorliegt. Hier ist, was Sie erreicht haben:

  1. Sie haben sich über das ISO 8601-Datumsformat und seine Struktur informiert.
  2. Sie verstehen, wie JavaScript-Date-Objekte mit ISO-formatierten Zeichenketten funktionieren.
  3. Sie haben eine Funktion erstellt, um zu überprüfen, ob eine Zeichenkette genau im ISO-Format vorliegt.
  4. Sie haben die Funktion mit verschiedenen Datumsformaten getestet.
  5. Sie haben die Funktion verbessert, um Randfälle zu behandeln und sie robuster zu machen.

Diese Fähigkeit ist besonders nützlich, wenn Sie mit APIs, Datenbanken oder jedem System arbeiten, bei dem eine konsistente Datumsformatierung wichtig ist. Das ISO 8601-Format wird weit verbreitet verwendet, da es Mehrdeutigkeiten vermeidet und eine standardisierte Möglichkeit bietet, Daten und Zeiten darzustellen.

Wichtige Erkenntnisse aus diesem Lab:

  • Das ISO 8601-Format folgt einem bestimmten Muster: YYYY-MM-DDTHH:mm:ss.sssZ
  • Die Methode Date.prototype.toISOString() in JavaScript gibt immer Daten in diesem Format aus.
  • Die Validierung von Daten erfordert die Überprüfung sowohl der Gültigkeit als auch des Formats.
  • Ein richtiger Umgang mit Fehlern macht Validierungsfunktionen robuster.

Sie können nun dieses Wissen anwenden, um zuverlässigere Anwendungen zu entwickeln, die Daten und Zeitangaben korrekt verarbeiten.