Casi cualquier tipo de aplicación escrita en JavaScript funciona con horas o fechas de alguna manera. Al principio, esto se limitaba a la API de fecha integrada. Esta API incluye una funcionalidad básica, pero lo que puede hacer es bastante limitada. Las bibliotecas de terceros como Moment.js y las API integradas posteriores, como las API Intl y la nueva API Temporal, agregan mucha mayor flexibilidad para trabajar con horas y fechas. El ascenso y la caída de Moment.js Moment.js es una biblioteca de JavaScript con potentes utilidades para trabajar con horas y fechas. Incluye funciones que faltan en la API de fecha básica, como la manipulación de la zona horaria, y simplifica muchas operaciones comunes. Moment también incluye funciones para formatear fechas y horas. Se convirtió en una biblioteca ampliamente utilizada en muchas aplicaciones diferentes. Sin embargo, Moment también tuvo sus problemas. Es una biblioteca grande y puede aumentar significativamente el tamaño del paquete de una aplicación. Debido a que la biblioteca no admite la vibración de árboles (una característica de los paquetes modernos que pueden eliminar partes no utilizadas de las bibliotecas), se incluye toda la biblioteca Moment incluso si solo usa una o dos de sus funciones. Otro problema con Moment es el hecho de que los objetos que crea son mutables. Llamar a ciertas funciones en un objeto Moment tiene efectos secundarios y muta el valor de ese objeto. Esto puede provocar errores o comportamientos inesperados. En 2020, los mantenedores de Moment decidieron poner la biblioteca en modo de mantenimiento. No se están desarrollando nuevas funciones y los encargados de su mantenimiento recomiendan no utilizarlo para nuevos proyectos. Hay otras bibliotecas de fechas de JavaScript, como date-fns, pero hay un nuevo jugador en la ciudad, una API integrada directamente en JavaScript: Temporal. Es un nuevo estándar que llena los huecos de la API Date original y resuelve algunas de las limitaciones encontradas en Moment y otras bibliotecas. ¿Qué es temporal? Temporal es una nueva API de fecha y hora que se agrega al estándar ECMAScript, que define JavaScript moderno. En marzo de 20266, alcanzó la Etapa 4 del proceso TC39 (el comité que supervisa las propuestas y adiciones al lenguaje JavaScript) y se incluirá en la próxima versión de la especificación ECMAScript. Ya se ha implementado en varios navegadores: Chrome 144+ y Firefox 139+, y se espera que Safari lo haga pronto. También hay disponible un polyfill para navegadores no compatibles y Node.js. La API Temporal crea objetos que, generalmente, representan momentos en el tiempo. Pueden ser marcas de tiempo y fecha completas en una zona horaria determinada, o pueden ser una instancia genérica de la hora del "reloj de pared" sin ninguna zona horaria o información de fecha. Algunas de las características principales de Temporal incluyen:
Horas con o sin fechas. Un objeto temporal puede representar una hora específica en una fecha específica o una hora sin ninguna información de fecha. También se puede representar una fecha concreta, sin hora. Soporte de zona horaria. Los objetos temporales reconocen completamente la zona horaria y se pueden convertir entre diferentes zonas horarias. Moment también admite zonas horarias, pero requiere la biblioteca adicional de zona horaria de momento. Inmutabilidad. Una vez creado un objeto temporal, no se puede cambiar. Las conversiones de aritmética horaria o zona horaria no modifican el objeto subyacente. En cambio, generan un nuevo objeto temporal. Indexación basada en 1. Una fuente común de errores con la API Date (así como con Moment) es que los meses están indexados a cero. Esto significa que enero es el mes 0, en lugar del mes 1, como todos entendemos en la vida real. Temporal soluciona este problema mediante el uso de indexación basada en 1: enero es el mes 1. Está integrado en el navegador. Dado que Temporal es una API en el propio navegador, no agrega nada al tamaño del paquete de su aplicación.
También es importante tener en cuenta que la API de fecha no desaparecerá. Si bien Temporal reemplaza esta API, no se eliminará ni quedará obsoleta. Muchas aplicaciones se romperían si los navegadores eliminaran repentinamente la API de fecha. Sin embargo, también tenga en cuenta que Moment ahora se considera un proyecto heredado en modo de mantenimiento. En el resto del artículo, veremos algunas "recetas" para migrar código basado en Moment a la nueva API temporal. ¡Comencemos a refactorizar! Crear objetos de fecha y hora Antes de que podamos manipular fechas y horas, tenemos que crear objetos que las representen. Para crear un objeto Momento que represente la fecha y hora actuales, utilice la función momento. constante ahora = momento(); console.log(ahora); // Momento<2026-02-18T21:26:29-05:00>
Este objeto ahora se puede formatear o manipular según sea necesario.
// convertir a UTC //Advertencia: ¡Esto muta el objeto Momento y lo pone en modo UTC! console.log(now.utc()); // Momento<2026-02-19T02:26:29Z>
// imprime una cadena formateada - tenga en cuenta que ahora está usando la hora UTC console.log(now.format('MM/DD/AAAA hh:mm:ss a')); // 19/02/2026 02:27:07 am
Lo clave que hay que recordar sobre Momento es que un objeto Momento siempre incluye información sobre la hora y la fecha. Si solo necesita trabajar con información de hora, esto suele estar bien, pero puede causar comportamientos inesperados en situaciones como el horario de verano o los años bisiestos, donde la fecha puede tener un efecto en los cálculos de hora. Temporal es más flexible. Puede crear un objeto que represente la fecha y hora actuales creando un objeto Temporal.Instant. Esto representa un punto en el tiempo definido por el tiempo desde “la época” (medianoche UTC del 1 de enero de 1970). Temporal puede hacer referencia a este instante en el tiempo con una precisión de nivel de nanosegundos. constante ahora = Temporal.Now.instant();
// ver nanosegundos en bruto desde la época console.log(ahora.epochNanosegundos); // 1771466342612000000n
// formato para UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// formato para una zona horaria particular console.log(now.toString({ timeZone: 'América/Nueva_York' })); // 2026-02-18T20:56:57.905-05:00
Los objetos Temporal.Instant también se pueden crear para una fecha y hora específicas utilizando el método estático from.
const miInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formatee el instante en la zona horaria local. Tenga en cuenta que esto sólo controla // el formato: no muta el objeto como lo hace moment.utc. console.log(myInstant.toString({ timeZone: 'América/Nueva_York' })); // 2026-02-18T21:10:00-05:00
También puedes crear otros tipos de objetos temporales, incluidos:
Temporal.PlainDate: una fecha sin información de hora. Temporal.PlainTime: una hora sin información de fecha. Temporal.ZonedDateTime: una fecha y hora en una zona horaria específica.
Cada uno de estos tiene un método from que se puede llamar con un objeto que especifica la fecha y/u hora, o una cadena de fecha para analizar. // Sólo una cita const hoy = Temporal.PlainDate.from({ año: 2026, mes: 2, // tenga en cuenta que estamos usando 2 para febrero día: 18 }); console.log(hoy.toString()); // 2026-02-18
// Sólo un momento const hora del almuerzo = Temporal.PlainTime.from({ hora: 12 }); console.log(horadelalmuerzo.toString()); // 12:00:00
// Una fecha y hora en la zona horaria del este de EE. UU. const dueAt = Temporal.ZonedDateTime.from({ zona horaria: 'América/Nueva_York', año: 2026, mes: 3, día: 1, hora: 12, minuto: 0, segundo: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[América/Nueva_York]
Analizando Hemos cubierto la creación programática de información de fecha y hora. Ahora veamos el análisis. El análisis es un área en la que Moment es más flexible que la API temporal integrada. Puede analizar una cadena de fecha pasándola a la función de momento. Con un solo argumento, Moment espera una cadena de fecha ISO, pero puede usar formatos alternativos si proporciona un segundo argumento que especifique el formato de fecha que se está utilizando.
const isoDate = momento('2026-02-21T09:00:00'); const formattedDate = momento('21/2/26 9:00:00', 'M/D/AA h:mm:ss');
console.log(isoFecha); // Momento<2026-02-21T09:00:00-05:00>
console.log(fechaformateada); // Momento<2026-02-21T09:00:00-05:00>
En versiones anteriores, Moment haría la mejor suposición al analizar cualquier cadena de fecha formateada arbitrariamente. Esto podría conducir a resultados impredecibles. Por ejemplo, ¿el 03-02-2026 es 2 de febrero o 3 de marzo? Por este motivo, las versiones más recientes de Moment muestran una advertencia de obsolescencia destacada si se llama sin una cadena de fecha con formato ISO (a menos que también se proporcione el segundo argumento con el formato deseado). Temporal solo analizará una cadena de fecha formateada específicamente. La cadena debe cumplir con el formato ISO 8601 o su extensión, RFC 9557. Si se pasa una cadena de fecha que no cumple con un método from, Temporal generará un RangeError.
// Usando una cadena de fecha RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[América/Nueva_York]'); console.log(myDate.toString({ timeZone: 'América/Nueva_York' })); // 2026-02-21T09:00:00-05:00
// Usando una cadena de fecha desconocida const otra fecha = Temporal.Instant.from('21/02/26 9:00:00'); // RangeError: error temporal: carácter no válido al analizar el valor del año.
Los requisitos exactos de la cadena de fecha dependen del tipo de objeto temporal que esté creando. En el ejemplo anterior, Temporal.Instant requiere una ISO completaCadena de fecha 8601 o RFC 9557 que especifica la fecha y la hora con un desplazamiento de zona horaria, pero también puede crear objetos PlainDate o PlainTime usando solo un subconjunto del formato de fecha. const miFecha = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const miHora = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
Tenga en cuenta que estas cadenas aún deben cumplir con el formato esperado o se generará un error.
// Utilizando cadenas de tiempo no conformes. Todos estos arrojarán un RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 a.m.');
Consejo profesional: manejo de cadenas que no son ISO Debido a que Temporal prioriza la confiabilidad, no intentará adivinar el formato de una cadena como 01-02-2026. Si su fuente de datos utiliza dichas cadenas, deberá realizar alguna manipulación de cadenas para reorganizar los valores en una cadena ISO como 2026-02-01 antes de intentar usarla con Temporal.
Formato Una vez que tenga un objeto Momento o Temporal, probablemente querrá convertirlo en una cadena formateada en algún momento. Este es un caso en el que Moment es un poco más conciso. Llamas al método de formato del objeto con una cadena de tokens que describen el formato de fecha deseado. fecha constante = momento();
console.log(date.format('MM/DD/AAAA')); // 22/02/2026
console.log(date.format('MMMM Hacer AAAA, h:mm:ss a')); // 22 de febrero de 2026, 20:18:30 horas
Por otro lado, Temporal requiere que seas un poco más detallado. Los objetos temporales, como Instant, tienen un método toLocaleString que acepta varias opciones de formato especificadas como propiedades de un objeto.
fecha constante = Temporal.Now.instant();
// sin argumentos, obtendremos el formato predeterminado para la configuración regional actual console.log(date.toLocaleString()); // 22/02/2026, 8:23:36 p. m. (asumiendo una configuración regional de en-US)
// pasar opciones de formato para generar una cadena de formato personalizado console.log(date.toLocaleString('en-US', { mes: 'largo', día: 'numérico', año: 'numérico', hora: '2 dígitos', minuto: '2 dígitos' })); // 22 de febrero de 2026 a las 20:23
// pasa solo los campos que deseas en la cadena de formato console.log(date.toLocaleString('en-US', { mes: 'corto', día: 'numérico' })); // 22 de febrero
El formato de fecha temporal en realidad utiliza la API Intl.DateTimeFormat (que ya está disponible en los navegadores modernos) internamente. Eso significa que puede crear un objeto DateTimeFormat reutilizable con sus opciones de formato personalizadas y luego pasar objetos temporales a su método de formato. Debido a esto, no admite formatos de fecha personalizados como lo hace Moment. Si necesita algo como 'Q1 2026' u otro formato especializado, es posible que necesite algún código de formato de fecha personalizado o busque una biblioteca de terceros. formateador constante = nuevo Intl.DateTimeFormat('en-US', { mes: '2 dígitos', día: '2 dígitos', año: 'numérico' });
fecha constante = Temporal.Now.instant(); console.log(formatter.format(fecha)); // 22/02/2026
Los tokens de formato de Moment son más sencillos de escribir, pero no son compatibles con la configuración regional. El formato incluye elementos de "código rígido" como el orden mes/día. La ventaja de utilizar un objeto de configuración, como lo hace Temporal, es que se adaptará automáticamente a cualquier ubicación determinada y utilizará el formato correcto. fecha constante = Temporal.Now.instant();
opciones de formato constantes = { mes: 'numérico', día: 'numérico', año: 'numérico' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22/02/2026
console.log(date.toLocaleString('es-GB', formatOptions)); // 22/02/2026
Cálculos de fecha En muchas aplicaciones, tendrás que terminar realizando algunos cálculos en una fecha. Es posible que desees sumar o restar unidades de tiempo (días, horas, segundos, etc.). Por ejemplo, si tiene la fecha actual, es posible que desee mostrarle al usuario la fecha dentro de 1 semana. Los objetos de momento tienen métodos como sumar y restar que realizan estas operaciones. Estas funciones toman un valor y una unidad, por ejemplo: add(7, 'días'). Sin embargo, una diferencia muy importante entre Momento y Temporal es que al realizar estos cálculos de fecha, el objeto subyacente se modifica y se pierde su valor original. constante ahora = momento();
console.log(ahora); // Momento<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'días'); console.log(próxima semana); // Momento<2026-03-03T20:08:36-05:00>
// Te tengo: el objeto original fue mutado console.log(ahora); // Momento<2026-03-03T20:08:36-05:00>
Para evitar perder la fecha original, puede llamar a clonar el objeto Momento para crear una copia. constante ahora= momento(); const nextWeek = now.clone().add(7, 'días');
console.log(ahora); // Momento<2026-02-24T20:12:55-05:00>
console.log(próxima semana); // Momento<2026-03-03T20:12:55-05:00>
Por otro lado, los objetos temporales son inmutables. Una vez que haya creado un objeto como Instant, PlainDate, etc., el valor de ese objeto nunca cambiará. Los objetos temporales también tienen métodos de suma y resta. Temporal es un poco exigente en cuanto a qué unidades de tiempo se pueden agregar a qué tipos de objetos. Por ejemplo, no puedes agregar días a un Instante:
constante ahora = Temporal.Now.instant(); const próxima semana = ahora.add({ días: 7 }); // RangeError: Error temporal: la unidad más grande no puede ser una unidad de fecha
Esto se debe a que los objetos instantáneos representan un momento específico en UTC y son independientes del calendario. Debido a que la duración de un día puede cambiar según las reglas de la zona horaria, como el horario de verano, este cálculo no está disponible en un Instant. Sin embargo, puedes realizar esta operación en otros tipos de objetos, como PlainDateTime: const ahora = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
const próxima semana = ahora.add({ días: 7 });
// Tenga en cuenta que el PlainDateTime original permanece sin cambios console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
También puede calcular cuánto tiempo hay entre dos objetos Momento o Temporal. Con la función de diferencia de Moment, debe proporcionar una unidad para la granularidad; de lo contrario, devolverá la diferencia en milisegundos. fecha constante1 = momento('2026-02-21T09:00:00'); fecha constante2 = momento('2026-02-22T10:30:00');
console.log(fecha2.diff(fecha1)); // 91800000
console.log(date2.diff(date1, 'días')); // 1
Para hacer esto con un objeto temporal, puede pasar otro objeto temporal a sus métodos hasta o desde. Esto devuelve un objeto Temporal.Duration que contiene información sobre la diferencia horaria. El objeto Duración tiene propiedades para cada componente de la diferencia y también puede generar una cadena de duración ISO 8601 que representa la diferencia horaria.
fecha constante1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); fecha constante2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// unidad más grande especifica la unidad de tiempo más grande para representar // en el cálculo de la duración const diff = fecha2.since(fecha1, {unidadmásgrande: 'día'});
console.log(diff.días); // 1
console.log(diff.horas); // 1
console.log(diff.minutos); // 30
console.log(diff.toString()); // P1DT1H30M // (cadena de duración ISO 8601: 1 día, 1 hora, 30 minutos)
Comparación de fechas y horas Tanto Moment como Temporal le permiten comparar fechas y horas para determinar cuál viene antes que el otro, pero adoptan enfoques diferentes con la API. Moment proporciona métodos como isBefore, isAfter e isSame para comparar dos objetos Moment. fecha constante1 = momento('2026-02-21T09:00:00'); fecha constante2 = momento('2026-02-22T10:30:00');
console.log(fecha1.isBefore(fecha2)); // verdadero
Temporal utiliza un método de comparación estática para realizar una comparación entre dos objetos del mismo tipo. Devuelve -1 si la primera fecha es anterior a la segunda, 0 si son iguales o 1 si la primera fecha es posterior a la segunda. El siguiente ejemplo muestra cómo comparar dos objetos PlainDate. Ambos argumentos de Temporal.PlainDate.compare deben ser objetos PlainDate.
fecha const1 = Temporal.PlainDate.from({ año: 2026, mes: 2, día: 24 }); fecha const2 = Temporal.PlainDate.from({ año: 2026, mes: 3, día: 24 });
// la fecha1 viene antes de la fecha2, por lo que -1 console.log(Temporal.PlainDate.compare(fecha1, fecha2));
// Error si intentamos comparar dos objetos de diferentes tipos console.log(Temporal.PlainDate.compare(fecha1, Temporal.Now.instant())); // TypeError: Error temporal: se proporcionaron campos PlainDate no válidos.
En particular, esto facilita la clasificación cronológica de una serie de objetos temporales. // Una matriz de objetos Temporal.PlainDate fechas constantes = [...];
// usa Temporal.PlainDate.compare como función de comparación fechas.sort(Temporal.PlainDate.compare);
Conversiones de zona horaria La biblioteca principal de Moment no admite conversiones de zona horaria. Si necesita esta funcionalidad, también necesita instalar el paquete moment-timezone. Este paquete no se puede modificar en forma de árbol y, por lo tanto, puede aumentar significativamente el tamaño de su paquete. Una vez que haya instalado moment-timezone, puede convertir objetos Moment a diferentes zonas horarias con el método tz. Al igual que con otras operaciones Moment, esto muta el subyacenteobjeto. // Suponiendo la hora del este de EE. UU. constante ahora = momento(); console.log(ahora); // Momento<2026-02-28T20:08:20-05:00>
// Convertir a hora del Pacífico. // La hora oriental original se ha perdido. now.tz('América/Los_Angeles'); console.log(ahora); // Momento<2026-02-28T17:08:20-08:00>
La funcionalidad de zona horaria está integrada en la API temporal cuando se utiliza un objeto Temporal.ZonedDateTime. Estos objetos incluyen un método withTimeZone que devuelve un nuevo ZonedDateTime que representa el mismo momento en el tiempo, pero en la zona horaria especificada. // Nuevamente, asumiendo la hora del este de EE. UU. const ahora = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28/02/2026, 8:12:02 p. m. EST
// Convertir a hora del Pacífico const nowPacific = now.withTimeZone('América/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28/02/2026, 17:12:02 hora del Pacífico
// El objeto original permanece sin cambios console.log(now.toLocaleString()); // 28/02/2026, 8:12:02 p. m. EST
Nota: Los valores formateados devueltos por toLocaleString dependen, como su nombre indica, de la configuración regional. El código de muestra se desarrolló en la configuración regional en-US, por lo que el formato es este: 28/02/2026, 5:12:02 p.m. PST. En otro lugar, esto puede ser diferente. Por ejemplo, en la configuración regional en-GB, obtendría algo como 28/2/2026, 17:12:02 GMT-8. Una refactorización del mundo real Supongamos que estamos creando una aplicación para programar eventos en zonas horarias. Parte de esta aplicación es una función, getEventTimes, que toma una cadena ISO 8601 que representa la hora y fecha del evento, una zona horaria local y una zona horaria de destino. La función crea cadenas formateadas de fecha y hora para el evento en ambas zonas horarias. Si a la función se le proporciona una cadena de entrada que no es una cadena de fecha/hora válida, generará un error. Aquí está la implementación original, usando Moment (que también requiere el uso del paquete moment-timezone).
importar momento desde 'momento-zona horaria';
función getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, AAAA, h:mm:ss a z';
// 1. Crea el momento inicial en la zona horaria del usuario constante EventTime = momento.tz( cadena de entrada, moment.ISO_8601, // Espera una cadena ISO 8601 verdadero, // análisis estricto usuarioTimeZone );
// Lanza un error si inputString no representa una fecha válida si (!eventTime.isValid()) { throw new Error('Entrada de fecha/hora no válida'); }
// 2. Calcular el tiempo objetivo // CRÍTICO: ¡Debemos clonar, o 'eventTime' cambiará para siempre! const targetTime = eventTime.clone().tz(targetTimeZone);
devolver { local: eventTime.format(timeFormat), objetivo: targetTime.format(timeFormat), }; }
programación constante = getEventTimes( '2026-03-05T15:00-05:00', 'América/Nueva_York', 'Europa/Londres', );
console.log(horario.local); // 5 de marzo de 2026, 3:00:00 p. m. EST
console.log(programa.objetivo); // 5 de marzo de 2026, 8:00:00 p. m. GMT
En este ejemplo, utilizamos un formato de fecha esperado de ISO 8601, que está útilmente integrado en Moment. También utilizamos un análisis estricto, lo que significa que Moment no intentará adivinar con una cadena de fecha que no coincida con el formato. Si se pasa una cadena de fecha que no sea ISO, se generará un objeto de fecha no válido y se generará un error. La implementación temporal parece similar, pero tiene algunas diferencias clave.
función getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Analiza la entrada directamente en un Instant, luego crea // un ZonedDateTime en la zona del usuario. instante constante = Temporal.Instant.from(inputString); const eventTime = instante.toZonedDateTimeISO(userTimeZone);
// 2. Convertir a la zona objetivo // Esto devuelve automáticamente un objeto NUEVO; 'eventTime' es seguro. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formatear usando Intl (integrado) opciones constantes = { año: 'numérico', mes: 'corto', día: 'numérico', hora: 'numérico', minuto: '2 dígitos', segundo: '2 dígitos', nombre de zona horaria: 'corto' };
devolver { local: eventTime.toLocaleString(navigator.language, opciones), destino: targetTime.toLocaleString(navigator.idioma, opciones) }; }
programación constante = getEventTimes( '2026-03-05T15:00-05:00', 'América/Nueva_York', 'Europa/Londres', );
console.log(horario.local); // 5 de marzo de 2026, 3:00:00 p. m. EST
console.log(programa.objetivo); // 5 de marzo de 2026, 8:00:00 p. m. GMT
Con Moment, tenemos que especificar explícitamente una cadena de formato para las cadenas de fecha resultantes. Independientemente de la ubicación o la configuración regional del usuario, los horarios del evento siempre tendrán el formato 5 de marzo de 2026, 3:00:00pm EST. Además, no tenemos que lanzar una excepción explícitamente. Si se pasa una cadena no válida a Temporal.Instant.from, Temporal generará la excepción por nosotros. Una cosa a tener en cuenta es que incluso con un análisis estricto, la versión Moment es aún más indulgente. Temporal requiere el desplazamiento de la zona horaria al final de la cadena. También debe tener en cuenta que, dado que utilizamos navigator.language, este código solo se ejecutará en un entorno de navegador, ya que navigator no está definido en un entorno Node.js. La implementación temporal utiliza la configuración regional actual del navegador (navigator.language), por lo que el usuario obtendrá automáticamente las horas de los eventos formateadas en su formato de hora local. En la configuración regional en EE. UU., es el 5 de marzo de 2026 a las 3:00:00 p. m. EST. Sin embargo, si el usuario está en Londres, por ejemplo, la hora del evento tendrá el formato 5 de marzo de 2026, 15:00:00 GMT-5. Resumen
acción Momento.js temporales Hora actual momento() Temporal.Now.zonedDateTimeISO() Analizando ISO momento (cadena) Temporal.Instantáneo.desde(str) Agregar tiempo .add(7, 'días') (muta) .add({ días: 7 }) (nuevo objeto) diferencia .diff(otro, 'horas') .desde(otras).horas Zona horaria .tz('Zona/Nombre') .withTimeZone('Zona/Nombre')
A primera vista, la diferencia puede ser una sintaxis ligeramente diferente (y en el caso de Temporal, a veces más detallada y más estricta), pero existen varias ventajas clave al usar Temporal sobre Moment.js:
Ser más explícito significa menos sorpresas y errores no deseados. El momento puede parecer más indulgente, pero implica “conjeturas” que a veces pueden resultar en fechas incorrectas. Si le da a Temporal algo no válido, arroja un error. Si el código se ejecuta, sabrá que tiene una fecha válida. Moment puede agregar un tamaño significativo al paquete de la aplicación, especialmente si está utilizando el paquete moment-timezone. Temporal no agrega nada (una vez que se envía a los navegadores de destino). La inmutabilidad le brinda la confianza de que nunca perderá ni sobrescribirá datos al realizar operaciones y conversiones de fechas. Diferentes representaciones de tiempo (Instant, PlainDateTime, ZonedDateTime) según sus requisitos, donde Moment siempre es un contenedor alrededor de una marca de tiempo UTC. Temporal utiliza las API internacionales para el formato de fechas, lo que significa que puede tener un formato que tenga en cuenta la configuración regional sin tener que especificar tokens explícitamente.
Notas sobre el Polyfill Como se mencionó anteriormente, hay un polyfill temporal disponible, distribuido como un paquete npm llamado @js-temporal/polyfill. Si desea utilizar Temporal hoy, necesitará este polyfill para admitir navegadores como Safari que aún no han enviado la API. La mala noticia con esto es que aumentará el tamaño de su paquete. La buena noticia es que todavía agrega significativamente menos que el momento o la zona horaria del momento. Aquí hay una comparación de los tamaños de los paquetes según lo informado por Bundlephobia.com, un sitio web que presenta información sobre los tamaños de los paquetes npm (haga clic en el nombre de cada paquete para ver el análisis de Bundlephobia):
Paquete Minimizado Minimizado y comprimido @js-temporal/polyfill 154,1 kB 44,1 kB momento 294,4 kB 75,4 kB momento-zona horaria 1MB 114,2 kB
Históricamente, el polyfill también ha tenido algunos problemas de rendimiento relacionados con el uso de la memoria y, en el momento de escribir este artículo, se considera que está en estado alfa. Debido a esto, es posible que no desees utilizarlo en producción hasta que alcance un estado más maduro. La otra buena noticia es que, con suerte, el polyfill no será necesario por mucho más tiempo (a menos que necesites admitir navegadores más antiguos, por supuesto). Al momento de escribir este artículo, Temporal se envió en Chrome, Edge y Firefox. Aún no está listo en Safari, aunque parece estar disponible con un indicador de tiempo de ejecución en la última Vista previa tecnológica.
