Cadena es una fecha en formato ISO

JavaScriptJavaScriptBeginner
Practicar Ahora

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

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, exploraremos cómo determinar si una cadena dada es una cadena de fecha válida en el formato ISO extendido simplificado (ISO 8601). Utilizaremos el constructor Date y sus métodos asociados para crear un objeto Date a partir de la cadena y comprobar su validez. Al final del laboratorio, tendrás una mejor comprensión de cómo trabajar con fechas en JavaScript y cómo validarlas utilizando el formato ISO.


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{{"Cadena es una fecha en formato ISO"}} javascript/cond_stmts -.-> lab-28422{{"Cadena es una fecha en formato ISO"}} javascript/functions -.-> lab-28422{{"Cadena es una fecha en formato ISO"}} javascript/error_handle -.-> lab-28422{{"Cadena es una fecha en formato ISO"}} end

Comprender el formato de fecha ISO y los objetos Date de JavaScript

Antes de comenzar a codificar, entendamos qué es el formato de fecha ISO 8601 y cómo JavaScript maneja las fechas.

El formato de fecha ISO 8601

El formato ISO 8601 es un estándar internacional para representar fechas y horas. El formato ISO extendido simplificado tiene el siguiente aspecto:

YYYY-MM-DDTHH:mm:ss.sssZ

Donde:

  • YYYY representa el año (cuatro dígitos)
  • MM representa el mes (dos dígitos)
  • DD representa el día (dos dígitos)
  • T es un carácter literal que separa la fecha y la hora
  • HH representa las horas (dos dígitos)
  • mm representa los minutos (dos dígitos)
  • ss representa los segundos (dos dígitos)
  • sss representa los milisegundos (tres dígitos)
  • Z indica la zona horaria UTC (hora Zulu)

Por ejemplo, 2023-05-12T14:30:15.123Z representa el 12 de mayo de 2023, a las 2:30:15.123 PM UTC.

El objeto Date de JavaScript

JavaScript proporciona un objeto Date incorporado para trabajar con fechas y horas. Cuando creas un nuevo objeto Date, puedes pasarle una cadena en formato ISO:

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

Abriremos la terminal y practicaremos el trabajo con objetos Date:

  1. Abre la Terminal haciendo clic en el menú Terminal en la parte superior del WebIDE
  2. Escribe node y presiona Enter para iniciar la shell interactiva de Node.js
  3. Crea un nuevo objeto Date para la hora actual:
const now = new Date();
console.log(now);
node-prompt
  1. Convierte este objeto Date en una cadena ISO:
const isoString = now.toISOString();
console.log(isoString);

Deberías ver una salida similar a:

2023-05-12T14:30:15.123Z
  1. Crea una fecha a partir de una cadena ISO:
const dateFromIso = new Date("2023-05-12T14:30:15.123Z");
console.log(dateFromIso);
node-prompt

Esto demuestra cómo JavaScript puede analizar y crear objetos Date a partir de cadenas en formato ISO.

Crear una función para validar cadenas de fechas en formato ISO

En este paso, crearemos una función de JavaScript que verifique si una cadena dada está en un formato ISO 8601 válido.

Crear la función de validación

Creemos un nuevo archivo de JavaScript para nuestro validador de fechas ISO:

  1. En el WebIDE, haz clic en el icono del Explorador en la barra lateral izquierda.
  2. Haz clic derecho en el explorador de archivos y selecciona "Nuevo archivo".
  3. Nombrar el archivo isISODate.js y presionar Enter.
  4. Agrega el siguiente código al archivo:
/**
 * 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;

Examinemos cómo funciona esta función:

  1. new Date(val) crea un objeto Date a partir de la cadena de entrada.
  2. d.valueOf() devuelve el valor numérico de la marca de tiempo (milisegundos desde el 1 de enero de 1970).
  3. Number.isNaN(d.valueOf()) verifica si la fecha es inválida (NaN significa "No es un número").
  4. d.toISOString() === val verifica que convertir la fecha de nuevo a una cadena ISO coincida con la entrada original.

Probar nuestra función

Ahora, creemos un archivo de prueba simple para probar nuestra función:

  1. Crea otro archivo llamado testISO.js.
  2. Agrega el siguiente código:
// 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. Ejecuta el archivo de prueba utilizando Node.js:
node testISO.js

Deberías ver una salida similar a:

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

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

Esto muestra que nuestra función identifica correctamente que "2020-10-12T10:10:10.000Z" es una fecha en formato ISO válida, mientras que "2020-10-12" no lo es.

Pruebas con diversos formatos de fecha

Ahora que tenemos nuestra función de validación básica, probémosla con diferentes formatos de fecha para entender cómo se comporta con diversas entradas.

Crear un conjunto de pruebas

Creemos un conjunto de pruebas completo para examinar diferentes formatos de fecha:

  1. Crea un nuevo archivo llamado dateTester.js.
  2. Agrega el siguiente código:
// 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. Ejecuta el conjunto de pruebas en la terminal:
node dateTester.js

Deberías ver una salida que muestre qué cadenas son fechas ISO válidas y cuáles no.

Comprender los resultados

Analicemos qué hace que cada caso de prueba sea válido o inválido:

  1. 2023-05-12T14:30:15.123Z - Esto es válido porque sigue el formato ISO 8601 completo con el indicador de zona horaria UTC (Z).

  2. 2020-10-12T10:10:10.000Z - Esto también es válido, con los milisegundos establecidos explícitamente en 000.

  3. 2023-05-12 - Esta es una fecha válida, pero no está en formato ISO porque le falta la componente de tiempo.

  4. 2023-05-12T14:30:15Z - Esto parece ser un formato ISO, pero le faltan los milisegundos, que son obligatorios en el formato ISO estricto.

  5. 2023-05-12T14:30:15+01:00 - Esto utiliza un desplazamiento de zona horaria (+01:00) en lugar de 'Z'. Si bien esto es válido según ISO 8601, nuestra función requiere el formato exacto producido por toISOString(), que siempre utiliza 'Z'.

  6. 2023-13-12T14:30:15.123Z - Esta es una fecha inválida (el mes 13 no existe), por lo que new Date() creará un objeto Date inválido.

  7. Hello World - Esto no es una fecha en absoluto, por lo que new Date() creará un objeto Date inválido.

Nuestra función de validación comprueba específicamente dos condiciones:

  1. La cadena debe convertirse en una fecha válida (no NaN).
  2. Cuando esa fecha se convierte de nuevo en una cadena ISO, debe coincidir exactamente con la entrada original.

Este enfoque asegura que estamos validando el formato ISO exacto producido por el método toISOString() de JavaScript.

Manejo de casos extremos y mejora de nuestra función

En este último paso, mejoraremos nuestra función isISOString para manejar casos extremos y hacerla más robusta.

Casos extremos comunes

Al validar datos en aplicaciones reales, es necesario manejar diversas entradas inesperadas. Examinemos algunos casos extremos:

  1. Cadenas vacías
  2. Valores no de tipo cadena (null, undefined, números, objetos)
  3. Diferentes representaciones de zonas horarias

Mejorar nuestra función

Actualicemos nuestro archivo isISODate.js para manejar estos casos extremos:

  1. Abre el archivo isISODate.js en el WebIDE.
  2. Reemplaza el código existente con esta versión mejorada:
/**
 * 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;

Esta función mejorada ahora:

  1. Comprueba si la entrada es una cadena antes de procesarla.
  2. Maneja cadenas vacías.
  3. Utiliza un bloque try-catch para manejar cualquier error que pueda ocurrir.
  4. Todavía realiza nuestra lógica de validación principal.

Probar nuestra función mejorada

Creemos un último archivo de prueba para verificar nuestra función mejorada con casos extremos:

  1. Crea un nuevo archivo llamado edgeCaseTester.js.
  2. Agrega el siguiente código:
// 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. Ejecuta el archivo de prueba:
node edgeCaseTester.js

Aplicación en el mundo real

En una aplicación real, nuestra función isISOString podría utilizarse en escenarios como:

  1. Validar la entrada del usuario en un campo de fecha.
  2. Verificar fechas recibidas de APIs externas.
  3. Asegurar un formato de fecha consistente en una base de datos.
  4. Validar datos antes de procesarlos.

Por ejemplo, en una función de validación de formulario:

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 función mejorada ahora es lo suficientemente robusta para manejar entradas inesperadas y proporcionar una validación confiable para cadenas de fechas en formato ISO.

Resumen

En este laboratorio (lab), has aprendido cómo validar si una cadena está en el formato ISO simplificado extendido (ISO 8601). Esto es lo que has logrado:

  1. Aprendiste sobre el formato de fecha ISO 8601 y su estructura.
  2. Comprendiste cómo funcionan los objetos Date de JavaScript con cadenas en formato ISO.
  3. Creaste una función para validar si una cadena está en el formato ISO exacto.
  4. Probaste la función con diversos formatos de fecha.
  5. Mejoraste la función para manejar casos extremos y hacerla más robusta.

Esta habilidad es especialmente útil cuando se trabaja con APIs, bases de datos o cualquier sistema donde la consistencia en el formato de fechas es importante. El formato ISO 8601 se utiliza ampliamente porque evita la ambigüedad y proporciona una forma estandarizada de representar fechas y horas.

Principales conclusiones de este laboratorio:

  • El formato ISO 8601 sigue un patrón específico: YYYY-MM-DDTHH:mm:ss.sssZ
  • El método Date.prototype.toISOString() de JavaScript siempre devuelve fechas en este formato.
  • Validar fechas requiere comprobar tanto la validez como el formato.
  • Un manejo adecuado de errores hace que las funciones de validación sean más robustas.

Ahora puedes aplicar este conocimiento para construir aplicaciones más confiables que manejen correctamente los datos de fecha y hora.