Case calquera tipo de aplicación escrita en JavaScript funciona con horas ou datas en certa medida. Ao principio, isto limitábase á API de data integrada. Esta API inclúe funcións básicas, pero é bastante limitada no que pode facer. As bibliotecas de terceiros como Moment.js e, posteriormente, as API integradas, como as API Intl e a nova API Temporal, engaden moita maior flexibilidade ao traballar con horas e datas. O ascenso e caída do momento.js Moment.js é unha biblioteca JavaScript con poderosas utilidades para traballar con horas e datas. Inclúe funcións que faltan da API de data básica, como a manipulación da zona horaria, e simplifica moitas operacións comúns. Moment tamén inclúe funcións para formatar datas e horas. Converteuse nunha biblioteca moi utilizada en moitas aplicacións diferentes. Non obstante, Moment tamén tivo a súa parte de problemas. É unha gran biblioteca e pode aumentar significativamente o tamaño do paquete dunha aplicación. Debido a que a biblioteca non admite a trebe de árbore (unha característica dos paquetes modernos que pode eliminar as partes non utilizadas das bibliotecas), inclúese toda a biblioteca Moment aínda que só uses unha ou dúas das súas funcións. Outro problema con Moment é o feito de que os obxectos que crea son mutables. A chamada a determinadas funcións nun obxecto Moment ten efectos secundarios e muta o valor dese obxecto. Isto pode provocar un comportamento inesperado ou erros. En 2020, os mantedores de Moment decidiron poñer a biblioteca en modo de mantemento. Non se está a desenvolver ningunha función nova e os mantedores recomendan non usalo para proxectos novos. Hai outras bibliotecas de datas de JavaScript, como date-fns, pero hai un novo reprodutor na cidade, unha API integrada directamente en JavaScript: Temporal. É un novo estándar que enche os ocos da API de Date orixinal e resolve algunhas das limitacións atopadas en Moment e noutras bibliotecas. Que é temporal? Temporal é unha nova API de data e hora que se engade ao estándar ECMAScript, que define JavaScript moderno. A partir de marzo de 20266, chegou á fase 4 do proceso TC39 (o comité que supervisa as propostas e engadidos á linguaxe JavaScript) e incluirase na próxima versión da especificación ECMAScript. Xa se implementou en varios navegadores: Chrome 144+ e Firefox 139+, e esperamos que Safari siga en breve. Tamén está dispoñible un polyfill para navegadores non compatibles e Node.js. A API Temporal crea obxectos que, xeralmente, representan momentos no tempo. Estes poden ser selos de data e tempo completo nunha zona horaria determinada, ou poden ser unha instancia xenérica de tempo de "reloxo de parede" sen ningunha información de data ou zona horaria. Algunhas das principais características de Temporal inclúen:
Horas con ou sen datas. Un obxecto temporal pode representar unha hora específica nunha data específica ou unha hora sen ningunha información de data. Tamén se pode representar unha data específica, sen hora. Soporte de zona horaria. Os obxectos temporais son totalmente conscientes do fuso horario e pódense converter en diferentes zonas horarias. Moment tamén admite zonas horarias, pero require a biblioteca adicional de fusos horarios de momento. Inmutabilidade. Unha vez que se crea un obxecto Temporal, non se pode cambiar. A aritmética horaria ou as conversións de fusos horarios non modifican o obxecto subxacente. Pola contra, xeran un novo obxecto Temporal. Indización baseada en 1. Unha fonte común de erros coa API Date (así como con Moment) é que os meses están indexados en cero. Isto significa que xaneiro é o mes 0, en lugar do mes 1, como todos entendemos na vida real. Temporal soluciona isto mediante a indexación baseada en 1: xaneiro é o mes 1. Está integrado no navegador. Dado que Temporal é unha API do propio navegador, non engade nada ao tamaño do paquete da túa aplicación.
Tamén é importante ter en conta que a API de data non desaparecerá. Aínda que Temporal substitúe a esta API, non se está eliminando nin queda en desuso. Moitas aplicacións romperíanse se os navegadores eliminasen de súpeto a API de data. Non obstante, tamén hai que ter en conta que Moment agora considérase un proxecto legado en modo de mantemento. No resto do artigo, veremos algunhas "receitas" para migrar o código baseado en Moment á nova API temporal. Comezamos a refactorizar! Creación de obxectos de data e hora Antes de poder manipular datas e horas, temos que crear obxectos que os representen. Para crear un obxecto Momento que represente a data e a hora actual, use a función de momento. const agora = momento(); console.log(agora); // Momento<2026-02-18T21:26:29-05:00>
Este obxecto agora pódese formatear ou manipular segundo sexa necesario.
// converte a UTC //aviso: Isto muta o obxecto Momento e pono no modo UTC. console.log(agora.utc()); // Momento<2026-02-19T02:26:29Z>
// imprime unha cadea formateada - teña en conta que agora está a usar a hora UTC console.log(now.format('MM/DD/AAAA hh:mm:ss a')); // 19/02/2026 02:27:07
O principal que hai que recordar sobre Moment é que un obxecto Moment sempre inclúe información sobre a hora e a data. Se só precisa traballar coa información horaria, normalmente está ben, pero pode provocar un comportamento inesperado en situacións como o horario de verán ou os anos bisiestos, onde a data pode ter un efecto nos cálculos do tempo. Temporal é máis flexible. Podes crear un obxecto que represente a data e a hora actual creando un obxecto Temporal.Instant. Isto representa un punto no tempo definido polo tempo transcorrido desde "a época" (medianoite UTC do 1 de xaneiro de 1970). Temporal pode facer referencia a este instante no tempo cunha precisión de nivel de nanosegundos. const agora = Temporal.Agora.instant();
// ver nanosegundos en bruto desde a época console.log(agora.epochNanoseconds); // 1771466342612000000n
// formato para UTC console.log(agora.toString()); // 2026-02-19T01:55:27.844Z
// formato para unha zona horaria determinada console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Os obxectos instantáneos tamén se poden crear para unha hora e data específicas mediante o método from static.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formatear o instante na zona horaria local. Teña en conta que isto só controla // o formato - non muta o obxecto como o fai moment.utc. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Tamén pode crear outros tipos de obxectos temporais, incluíndo:
Temporal.PlainDate: unha data sen información horaria. Temporal.PlainTime: un tempo sen información de data. Temporal.ZonedDateTime: unha data e hora nunha zona horaria específica.
Cada un destes ten un método from que se pode chamar cun obxecto que especifique a data e/ou hora, ou unha cadea de data para analizar. // Só unha cita const hoxe = Temporal.PlainDate.from({ ano: 2026, mes: 2, // nota que estamos a usar 2 para febreiro día: 18 }); console.log(today.toString()); // 18-02-2026
// Só un tempo const lunchTime = Temporal.PlainTime.from({ Hora: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Unha data e hora na zona horaria oriental dos EUA const dueAt = Temporal.ZonedDateTime.from({ TimeZone: 'America/New_York', ano: 2026, mes: 3, día: 1, Hora: 12, minuto: 0, segundo: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Analizando Cubrimos a creación programática de información de data e hora. Agora vexamos a análise. A análise é unha área na que Moment é máis flexible que a API de Temporal incorporada. Podes analizar unha cadea de data pasándoa á función de momento. Cun só argumento, Moment espera unha cadea de data ISO, pero pode usar formatos alternativos se fornece un segundo argumento que especifique o formato de data que se está a utilizar.
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(isoDate); // Momento<2026-02-21T09:00:00-05:00>
console.log(data formato); // Momento<2026-02-21T09:00:00-05:00>
Nas versións máis antigas, Moment faría unha mellor estimación para analizar calquera cadea de data con formato arbitrario. Isto pode levar a resultados imprevisibles. Por exemplo, o 02-03-2026 é o 2 de febreiro ou o 3 de marzo? Por este motivo, as versións máis recentes de Moment amosan un aviso de desaprobación destacado se se chama sen unha cadea de data con formato ISO (a non ser que tamén se dea o segundo argumento co formato desexado). Temporal só analizará unha cadea de data con formato especificamente. A cadea debe cumprir co formato ISO 8601 ou a súa extensión, RFC 9557. Se se pasa unha cadea de data non conforme a un método from, Temporal lanzará un RangeError.
// Usando unha cadea de data RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 21-02-2026T09:00:00-05:00
// Usando unha cadea de data descoñecida const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Erro temporal: carácter non válido ao analizar o valor do ano.
Os requisitos exactos da cadea de data dependen do tipo de obxecto temporal que esteas creando. No exemplo anterior, Temporal.Instant require unha ISO completaCadea de data 8601 ou RFC 9557 que especifica a data e a hora cunha compensación de zona horaria, pero tamén pode crear obxectos PlainDate ou PlainTime utilizando só un subconxunto do formato de data. const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 21-02-2026
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
Teña en conta que estas cadeas aínda deben cumprir co formato esperado, ou producirase un erro.
// Usando cadeas de tempo non conformes. Todos estes xerarán un RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Consello profesional: manexar cadeas non ISO Debido a que Temporal prioriza a fiabilidade, non tentará adiviñar o formato dunha cadea como 02-01-2026. Se a túa fonte de datos usa tales cadeas, terás que facer algunha manipulación de cadeas para reorganizar os valores nunha cadea ISO como 2026-02-01 antes de tentar usalo con Temporal.
Formato Unha vez que teñas un obxecto Momento ou Temporal, probablemente queiras convertelo nunha cadea formateada nalgún momento. Este é un caso no que Moment é un pouco máis conciso. Chama o método de formato do obxecto cunha cadea de tokens que describen o formato de data desexado. data constante = momento();
console.log(date.format('MM/DD/AAAA')); // 22/02/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 22 de febreiro de 2026, 20:18:30
Por outra banda, Temporal esixe que sexas un pouco máis detallado. Os obxectos temporais, como Instant, teñen un método toLocaleString que acepta varias opcións de formato especificadas como propiedades dun obxecto.
const date = Temporal.Now.instant();
// sen argumentos, obteremos o formato predeterminado para a configuración rexional actual console.log(date.toLocaleString()); // 22/02/2026, 20:23:36 (supoñendo unha configuración rexional de en-US)
// pasar opcións de formato para xerar unha cadea de formato personalizado console.log(date.toLocaleString('en-US', { mes: 'longo', día: 'numérico', ano: 'numérico', hora: "2 díxitos", minuto: '2 díxitos' })); // 22 de febreiro de 2026 ás 20:23
// só pasa os campos que queiras na cadea de formato console.log(date.toLocaleString('en-US', { mes: 'curto', día: 'numérico' })); // 22 de febreiro
O formato de data temporal usa realmente a API Intl.DateTimeFormat (que xa está dispoñible nos navegadores modernos) baixo o capó. Isto significa que pode crear un obxecto DateTimeFormat reutilizable coas súas opcións de formato personalizadas e, a continuación, pasar os obxectos temporais ao seu método de formato. Debido a isto, non admite formatos de data personalizados como o fai Moment. Se precisas algo como "Q1 2026" ou outro formato especializado, é posible que necesites algún código de formato de data personalizado ou buscar unha biblioteca de terceiros. const formatter = new Intl.DateTimeFormat('en-US', { mes: "2 díxitos", día: "2 díxitos", ano: 'numérico' });
const date = Temporal.Now.instant(); console.log(formatter.format(data)); // 22/02/2026
Os tokens de formato de Moment son máis sinxelos de escribir, pero non son compatibles coa localización. O formato encadea "código duro" cousas como orde mes/día. A vantaxe de usar un obxecto de configuración, como fai Temporal, é que se adaptará automaticamente a calquera configuración rexional e utilizará o formato correcto. const date = Temporal.Now.instant();
const formatOptions = { mes: 'numérico', día: 'numérico', ano: 'numérico' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22/02/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Cálculos de datas En moitas aplicacións, terás que rematar realizando algúns cálculos nunha data. Pode querer sumar ou restar unidades de tempo (días, horas, segundos, etc.). Por exemplo, se tes a data actual, quizais queiras mostrarlle ao usuario a data dentro dunha semana. Os obxectos de momento teñen métodos como sumar e restar que realizan estas operacións. Estas funcións toman un valor e unha unidade, por exemplo: add(7, 'días'). Non obstante, unha diferenza moi importante entre Momento e Temporal é que ao realizar estes cálculos de data, o obxecto subxacente é modificado e pérdese o seu valor orixinal. const agora = momento();
console.log(agora); // Momento<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'días'); console.log (semana seguinte); // Momento<2026-03-03T20:08:36-05:00>
// Gotcha - o obxecto orixinal foi mutado console.log(agora); // Momento<2026-03-03T20:08:36-05:00>
Para evitar perder a data orixinal, podes chamar a clonar no obxecto Momento para crear unha copia. const agora= momento(); const nextWeek = agora.clone().add(7, 'días');
console.log(agora); // Momento<2026-02-24T20:12:55-05:00>
console.log (semana seguinte); // Momento<2026-03-03T20:12:55-05:00>
Por outra banda, os obxectos temporais son inmutables. Unha vez que creas un obxecto como un Instant, PlainDate, etc., o valor dese obxecto nunca cambiará. Os obxectos temporais tamén teñen métodos de suma e resta. Temporal é un pouco esixente sobre as unidades de tempo que se poden engadir a que tipos de obxectos. Por exemplo, non podes engadir días a un Instant:
const agora = Temporal.Agora.instant(); const nextWeek = agora.engadir({ días: 7}); // RangeError: Erro temporal: a unidade máis grande non pode ser unha unidade de data
Isto débese a que os obxectos instantáneos representan un momento específico no tempo UTC e son independentes do calendario. Dado que a duración dun día pode cambiar en función das regras do fuso horario, como o horario de verán, este cálculo non está dispoñible nun Instant. Non obstante, pode realizar esta operación noutro tipo de obxectos, como PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(agora.toLocaleString()); // 24/02/2026, 20:23:59
const nextWeek = agora.engadir({ días: 7});
// Teña en conta que o PlainDateTime orixinal permanece sen cambios console.log(agora.toLocaleString()); // 24/02/2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/03/2026, 20:23:59
Tamén podes calcular canto tempo hai entre dous obxectos Momentais ou Temporais. Coa función diff de Moment, cómpre proporcionar unha unidade para a granularidade, se non, devolverá a diferenza en milisegundos. data const1 = momento('2026-02-21T09:00:00'); const date2 = momento('2026-02-22T10:30:00');
console.log(data2.diff(data1)); // 91800000
console.log(data2.diff(data1, 'días')); // 1
Para facelo cun obxecto Temporal, pode pasar outro obxecto Temporal aos seus métodos ata ou desde. Isto devolve un obxecto Temporal.Duration que contén información sobre a diferenza horaria. O obxecto Duración ten propiedades para cada compoñente da diferenza e tamén pode xerar unha cadea de duración ISO 8601 que representa a diferenza horaria.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// maiorUnidade especifica a maior unidade de tempo a representar // no cálculo da duración const diff = data2.desde(data1, {unidade maior: 'día'});
console.log(días diferentes); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (cadena de duración ISO 8601: 1 día, 1 hora, 30 minutos)
Comparando datas e horarios Momento e Temporal permítenche comparar datas e horas para determinar cal é o anterior, pero adoptar enfoques diferentes coa API. Moment ofrece métodos como isBefore, isAfter e isSame para comparar dous obxectos Moment. data const1 = momento('2026-02-21T09:00:00'); const date2 = momento('2026-02-22T10:30:00');
console.log(data1.isBefore(data2)); // verdadeiro
Temporal usa un método de comparación estático para realizar unha comparación entre dous obxectos do mesmo tipo. Devolve -1 se a primeira data é anterior á segunda, 0 se son iguais ou 1 se a primeira data vén despois da segunda. O seguinte exemplo mostra como comparar dous obxectos PlainDate. Ambos os argumentos de Temporal.PlainDate.compare deben ser obxectos PlainDate.
const date1 = Temporal.PlainDate.from({ ano: 2026, mes: 2, día: 24}); const date2 = Temporal.PlainDate.from({ ano: 2026, mes: 3, día: 24});
// data1 é anterior a data2, polo que -1 console.log(Temporal.PlainDate.compare(data1, data2));
// Erro se tentamos comparar dous obxectos de diferentes tipos console.log(Temporal.PlainDate.compare(data1, Temporal.Now.instant())); // TypeError: Erro temporal: campos PlainDate non válidos proporcionados.
En particular, isto facilita a ordenación cronolóxica dunha matriz de obxectos temporais. // Unha matriz de obxectos Temporal.PlainDate datas const = [ ... ];
// use Temporal.PlainDate.compare como función de comparación datas.sort(Temporal.PlainDate.compare);
Conversións de fuso horario A biblioteca principal Moment non admite conversións de fusos horarios. Se necesitas esta funcionalidade, tamén debes instalar o paquete momento-zona horaria. Este paquete non se pode axitar nunha árbore e, polo tanto, pode aumentar significativamente o tamaño do paquete. Unha vez que instales momento-timezone, podes converter obxectos Moment en diferentes zonas horarias co método tz. Do mesmo xeito que con outras operacións Moment, isto muta o subxacenteobxecto. // Asumindo a hora do leste dos EUA const agora = momento(); console.log(agora); // Momento<2026-02-28T20:08:20-05:00>
// Converter a hora do Pacífico. // Pérdese o tempo oriental orixinal. now.tz('America/Los_Angeles'); console.log(agora); // Momento<2026-02-28T17:08:20-08:00>
A funcionalidade do fuso horario está integrada na API de Temporal cando se usa un obxecto Temporal.ZonedDateTime. Estes obxectos inclúen un método withTimeZone que devolve un novo ZonedDateTime que representa o mesmo momento no tempo, pero no fuso horario especificado. // De novo, asumindo a hora do leste dos EUA const now = Temporal.Now.zonedDateTimeISO(); console.log(agora.toLocaleString()); // 28/02/2026, 20:12:02 EST
// Converter a hora do Pacífico const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28/02/2026, 17:12:02 PST
// O obxecto orixinal permanece sen cambios console.log(agora.toLocaleString()); // 28/02/2026, 20:12:02 EST
Nota: Os valores con formato devoltos por toLocaleString dependen da configuración rexional, como indica o nome. O código de mostra desenvolveuse na configuración rexional en-EU, polo que o formato é o seguinte: 2/28/2026, 5:12:02 PM PST. Noutro lugar, isto pode ser diferente. Por exemplo, na configuración rexional en-GB, obtería algo así como 28/2/2026, 17:12:02 GMT-8. Unha refactorización do mundo real Supoñamos que estamos a construír unha aplicación para programar eventos en zonas horarias. Parte desta aplicación é unha función, getEventTimes, que leva unha cadea ISO 8601 que representa a hora e data do evento, unha zona horaria local e unha zona horaria de destino. A función crea cadeas de data e hora formateadas para o evento en ambos os fusos horarios. Se a función recibe unha cadea de entrada que non é unha cadea de data/hora válida, xerará un erro. Aquí está a implementación orixinal, usando Moment (tamén require o uso do paquete momento-zona horaria).
importar momento desde 'momento-zona horaria';
función getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Crea o momento inicial na zona horaria do usuario const eventTime = momento.tz( inputString, momento.ISO_8601, // Espere unha cadea ISO 8601 verdadeiro, // análise estrita userTimeZone );
// Lanza un erro se o inputString non representa unha data válida se (!eventTime.isValid()) { throw new Error('Introdución de data/hora non válida'); }
// 2. Calcula o tempo obxectivo // CRÍTICA: Debemos clonar, ou "eventTime" cambia para sempre! const targetTime = eventTime.clone().tz(targetTimeZone);
devolver { local: eventTime.format(timeFormat), destino: targetTime.format(timeFormat), }; }
const schedule = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_York', "Europa/Londres", );
console.log(schedule.local); // 5 de marzo de 2026, 15:00:00 EST
console.log(schedule.target); // 5 de marzo de 2026, 20:00:00 GMT
Neste exemplo, estamos a usar un formato de data esperado ISO 8601, que está integrado de xeito útil en Moment. Tamén estamos a usar unha análise estrita, o que significa que Moment non tentará adiviñar cunha cadea de data que non coincida co formato. Se se pasa unha cadea de data non ISO, dará lugar a un obxecto de data non válido e lanzamos un erro. A implementación de Temporal parece semellante, pero ten algunhas diferenzas clave.
función getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Analiza a entrada directamente nun Instant e despois crea // un ZonedDateTime na zona do usuario. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Converter á zona de destino // Isto devolve automaticamente un obxecto NOVO; 'eventTime' é seguro. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formatear usando Intl (integrado) opcións const = { ano: 'numérico', mes: 'curto', día: 'numérico', hora: 'numérico', minuto: "2 díxitos", segundo: "2 díxitos", timeZoneName: 'curto' };
devolver { local: eventTime.toLocaleString(navigator.language, opcións), destino: targetTime.toLocaleString(navigator.language, opcións) }; }
const schedule = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_York', "Europa/Londres", );
console.log(schedule.local); // 5 de marzo de 2026, 15:00:00 EST
console.log(schedule.target); // 5 de marzo de 2026, 20:00:00 GMT
Con Moment, temos que especificar explícitamente unha cadea de formato para as cadeas de data resultantes. Independentemente da localización ou localización do usuario, as horas do evento sempre terán o formato do 5 de marzo de 2026 ás 3:00:00pm EST. Ademais, non temos que lanzar unha excepción explícitamente. Se se pasa unha cadea non válida a Temporal.Instant.from, Temporal lanzará a excepción para nós. Unha cousa a ter en conta é que aínda cunha análise estrita, a versión de Moment aínda é máis indulgente. Temporal require a compensación da zona horaria ao final da cadea. Tamén debes ter en conta que, dado que estamos a usar navigator.language, este código só se executará nun entorno de navegador, xa que o navegador non está definido nun entorno Node.js. A implementación de Temporal usa a configuración rexional actual do navegador (navigator.language), polo que o usuario obterá automaticamente o formato das horas dos eventos no seu formato de hora local. Na rexión de EE. UU., é o 5 de marzo de 2026 ás 15:00, EST. Non obstante, se o usuario está en Londres, por exemplo, as horas dos eventos formataranse como 5 de marzo de 2026, 15:00:00 GMT-5. Resumo
Acción Momento.js Temporal Hora actual momento () Temporal.Now.zonedDateTimeISO() Analizando ISO momento (str) Temporal.Instant.from(str) Engadir tempo .add(7, 'días') (muta) .add({ días: 7}) (novo obxecto) Diferenza .diff(outro, 'horas') .desde(outros).horas Fuso horario .tz('Zona/Nome') .withTimeZone('Zona/Nome')
A primeira vista, a sintaxe pode ser lixeiramente diferente (e no caso de Temporal, ás veces máis detallada e máis estrita), a sintaxe, pero hai varias vantaxes fundamentais ao usar Temporal fronte a Moment.js:
Ser máis explícito significa menos sorpresas e erros non desexados. O momento pode parecer máis indulgente, pero implica "suposicións", que ás veces pode dar lugar a datas incorrectas. Se dá Temporal algo non válido, arroxa un erro. Se se executa o código, sabes que tes unha data válida. Moment pode engadir un tamaño significativo ao paquete da aplicación, especialmente se estás a usar o paquete momento-zona horaria. Temporal non engade nada (unha vez que se envía nos teus navegadores de destino). A inmutabilidade dáche a confianza de que nunca perderás nin sobrescribirás datos ao realizar operacións e conversións de datas. Diferentes representacións de tempo (Instant, PlainDateTime, ZonedDateTime) segundo os teus requisitos, onde Moment é sempre un envoltorio arredor dunha marca de tempo UTC. Temporal usa as API de Intl para o formato de data, o que significa que podes ter un formato compatible coa configuración rexional sen ter que especificar explícitamente tokens.
Notas sobre o Polyfill Como se mencionou anteriormente, hai un Polyfill Temporal dispoñible, distribuído como un paquete npm chamado @js-temporal/polyfill. Se queres usar Temporal hoxe, necesitarás este polyfill para admitir navegadores como Safari que aínda non enviaron a API. A mala noticia con isto é que aumentará o tamaño do paquete. A boa noticia é que aínda engade moito menos que o momento ou o momento-zona horaria. Aquí tes unha comparación dos tamaños dos paquetes informados por Bundlephobia.com, un sitio web que presenta información sobre os tamaños dos paquetes npm (faga clic no nome de cada paquete para ver a análise de Bundlephobia):
Paquete Minificado Minimizado e comprimido @js-temporal/polyfill 154,1 kB 44,1 kB momento 294,4 kB 75,4 kB momento-zona horaria 1 MB 114,2 kB
O polyfill tamén tivo históricamente algúns problemas de rendemento en torno ao uso da memoria e, no momento de escribir, considérase que está nun estado alfa. Debido a isto, é posible que non queira usalo na produción ata que alcance un estado máis maduro. A outra boa noticia é que esperamos que o polyfill non sexa necesario moito máis tempo (a menos que necesites admitir navegadores máis antigos, por suposto). No momento de escribir este artigo, Temporal presentouse en Chrome, Edge e Firefox. Aínda non está listo en Safari, aínda que parece estar dispoñible cunha marca de tempo de execución na última vista previa tecnolóxica.
