Gairebé qualsevol tipus d'aplicació escrita en JavaScript funciona amb hores o dates d'alguna manera. Al principi, això es limitava a l'API Date incorporada. Aquesta API inclou una funcionalitat bàsica, però és força limitada en el que pot fer. Les biblioteques de tercers com Moment.js, i posteriorment les API integrades, com ara les API Intl i la nova API temporal, afegeixen una flexibilitat molt més gran per treballar amb hores i dates. L'ascens i la caiguda del moment.js Moment.js és una biblioteca de JavaScript amb potents utilitats per treballar amb hores i dates. Inclou funcions que falten de l'API de data bàsica, com ara la manipulació de la zona horària, i simplifica moltes operacions habituals. Moment també inclou funcions per donar format a dates i hores. Es va convertir en una biblioteca àmpliament utilitzada en moltes aplicacions diferents. Tanmateix, Moment també va tenir la seva part de problemes. És una biblioteca gran i pot augmentar significativament la mida del paquet d'una aplicació. Com que la biblioteca no admet tree shaking (una característica dels paquets moderns que pot eliminar parts no utilitzades de les biblioteques), s'inclou tota la biblioteca Moment encara que només utilitzeu una o dues de les seves funcions. Un altre problema amb Moment és el fet que els objectes que crea són mutables. Cridar determinades funcions en un objecte Moment té efectes secundaris i muta el valor d'aquest objecte. Això pot provocar un comportament inesperat o errors. El 2020, els mantenedors de Moment van decidir posar la biblioteca en mode de manteniment. No s'està fent cap desenvolupament de noves funcions, i els mantenedors recomanen que no l'utilitzin per a projectes nous. Hi ha altres biblioteques de dates de JavaScript, com ara date-fns, però hi ha un nou jugador a la ciutat, una API integrada directament a JavaScript: Temporal. És un nou estàndard que omple els forats de l'API de Date original i soluciona algunes de les limitacions que es troben a Moment i altres biblioteques. Què és el temporal? Temporal és una nova API de data i hora que s'afegeix a l'estàndard ECMAScript, que defineix JavaScript modern. A partir del març de 20266, ha arribat a l'etapa 4 del procés TC39 (el comitè que supervisa les propostes i les addicions al llenguatge JavaScript) i s'inclourà a la propera versió de l'especificació ECMAScript. Ja s'ha implementat en diversos navegadors: Chrome 144+ i Firefox 139+, i s'espera que Safari segueixi aviat. També hi ha disponible un polyfill per a navegadors no compatibles i Node.js. L'API temporal crea objectes que, generalment, representen moments en el temps. Aquests poden ser segells de data i temps complet en una zona horària determinada, o poden ser una instància genèrica de l'hora del "rellotge de paret" sense cap informació de data o zona horària. Algunes de les característiques principals de Temporal inclouen:
Temps amb o sense dates. Un objecte temporal pot representar una hora específica en una data específica, o una hora sense cap informació de data. També es pot representar una data concreta, sense hora. Compatibilitat amb la zona horària. Els objectes temporals són totalment conscients de la zona horària i es poden convertir en diferents zones horàries. Moment també admet zones horàries, però requereix la biblioteca addicional de fus horari de moment. Immutabilitat. Un cop creat un objecte temporal, no es pot canviar. L'aritmètica horària o les conversions de zona horària no modifiquen l'objecte subjacent. En canvi, generen un nou objecte temporal. Indexació basada en 1. Una font comuna d'errors amb l'API Date (així com amb Moment) és que els mesos estan indexats zero. Això vol dir que gener és el mes 0, en lloc del mes 1, com tots entenem a la vida real. Temporal ho soluciona mitjançant la indexació basada en 1: gener és el mes 1. Està integrat al navegador. Com que Temporal és una API del propi navegador, no afegeix res a la mida del paquet de l'aplicació.
També és important tenir en compte que l'API de dates no desapareixerà. Tot i que Temporal substitueix aquesta API, no s'està eliminant ni està en desús. Moltes aplicacions es trencarien si els navegadors eliminessin de sobte l'API Date. Tanmateix, també tingueu en compte que Moment es considera ara un projecte heretat en mode de manteniment. A la resta de l'article, veurem algunes "receptes" per migrar el codi basat en Moment a la nova API temporal. Comencem a refactoritzar! Creació d'objectes de data i hora Abans de poder manipular dates i hores, hem de crear objectes que les representin. Per crear un objecte Moment que representi la data i l'hora actuals, utilitzeu la funció de moment. const ara = moment(); console.log(ara); // Moment<2026-02-18T21:26:29-05:00>
Aquest objecte ara es pot formatar o manipular segons sigui necessari.
// Converteix a UTC //advertència: això muta l'objecte Moment i el posa en mode UTC! console.log(now.utc()); // Moment<2026-02-19T02:26:29Z>
// imprimeix una cadena formatada - tingueu en compte que ara fa servir l'hora UTC console.log(now.format('MM/DD/AAAA hh:mm:ss a')); // 19/02/2026 02:27:07
La clau a recordar sobre Moment és que un objecte Moment sempre inclou informació sobre l'hora i la data. Si només necessiteu treballar amb informació de l'hora, normalment està bé, però pot provocar un comportament inesperat en situacions com ara l'horari d'estiu o els anys de traspàs, on la data pot tenir un efecte en els càlculs de l'hora. El temporal és més flexible. Podeu crear un objecte que representi la data i l'hora actuals creant un objecte Temporal.Instant. Això representa un punt en el temps definit pel temps des de "l'època" (mitjanit UTC de l'1 de gener de 1970). Temporal pot fer referència a aquest instant en el temps amb una precisió de nivell de nanosegons. const ara = Temporal.Now.instant();
// veure nanosegons en brut des de l'època console.log(now.epochNanoseconds); // 1771466342612000000n
// format per a UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// format per a una zona horària determinada console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Els objectes temporals.Instant també es poden crear per a una data i hora específiques utilitzant el mètode from static.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formateu l'instant a la zona horària local. Tingueu en compte que això només controla // el format: no muta l'objecte com ho fa moment.utc. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
També podeu crear altres tipus d'objectes temporals, com ara:
Temporal.PlainDate: una data sense informació de l'hora. Temporal.PlainTime: una hora sense informació de data. Temporal.ZonedDateTime: una data i hora en una zona horària específica.
Cadascun d'ells té un mètode from que es pot cridar amb un objecte que especifiqui la data i/o l'hora, o una cadena de data per analitzar. // Només una cita const avui = Temporal.PlainDate.from({ any: 2026, mes: 2, // nota que estem utilitzant 2 per al febrer dia: 18 }); console.log(avui.toString()); // 18-02-2026
// Només un temps const lunchTime = Temporal.PlainTime.from({ hora: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Una data i hora a la zona horària oriental dels EUA const dueAt = Temporal.ZonedDateTime.from({ TimeZone: 'Amèrica/New_York', any: 2026, mes: 3, dia: 1, hores: 12, minut: 0, segon: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amèrica/Nova_York]
Anàlisi Hem tractat la creació programàtica d'informació de data i hora. Ara mirem l'anàlisi. L'anàlisi és una àrea on Moment és més flexible que l'API Temporal integrada. Podeu analitzar una cadena de data passant-la a la funció de moment. Amb un sol argument, Moment espera una cadena de data ISO, però podeu utilitzar formats alternatius si proporcioneu un segon argument que especifiqui el format de data que s'utilitza.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/AA h:mm:ss');
console.log(isoDate); // Moment<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Moment<2026-02-21T09:00:00-05:00>
En versions anteriors, Moment seria una millor endevinació per analitzar qualsevol cadena de data amb format arbitrari. Això podria donar lloc a resultats impredictibles. Per exemple, el 02-03-2026 és el 2 de febrer o el 3 de març? Per aquest motiu, les versions més noves de Moment mostren un avís de desús destacat si es crida sense una cadena de data amb format ISO (tret que també es doni el segon argument amb el format desitjat). Temporal només analitzarà una cadena de data amb format específic. La cadena ha de complir el format ISO 8601 o la seva extensió, RFC 9557. Si es passa una cadena de data no compatible a un mètode from, Temporal generarà un RangeError.
// Utilitzant una cadena 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
// S'utilitza una cadena de data desconeguda const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Error temporal: caràcter no vàlid durant l'anàlisi del valor de l'any.
Els requisits exactes de la cadena de data depenen del tipus d'objecte temporal que esteu creant. A l'exemple anterior, Temporal.Instant requereix una ISO completaCadena de data 8601 o RFC 9557 que especifica la data i l'hora amb un desplaçament de zona horària, però també podeu crear objectes PlainDate o PlainTime utilitzant només un subconjunt del format 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
Tingueu en compte que aquestes cadenes encara han de complir amb el format esperat, o es generarà un error.
// Utilitzant cadenes de temps no compatibles. Tot això llançarà un RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Consell professional: manejar cadenes no ISO Com que Temporal prioritza la fiabilitat, no intentarà endevinar el format d'una cadena com el 02-01-2026. Si la vostra font de dades utilitza aquestes cadenes, haureu de fer alguna manipulació de cadenes per reordenar els valors en una cadena ISO com 2026-02-01 abans d'intentar utilitzar-la amb Temporal.
Formatatge Un cop tingueu un objecte Moment o Temporal, probablement voldreu convertir-lo en una cadena formatada en algun moment. Aquest és un cas en què Moment és una mica més concis. Truqueu al mètode de format de l'objecte amb una cadena de fitxes que descriuen el format de data desitjat. const data = moment();
console.log(date.format('MM/DD/AAAA')); // 22/02/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 22 de febrer de 2026, 20.18.30 h
D'altra banda, Temporal requereix que siguis una mica més detallat. Els objectes temporals, com ara Instant, tenen un mètode toLocaleString que accepta diverses opcions de format especificades com a propietats d'un objecte.
data constant = Temporal.Now.instant();
// sense arguments, obtindrem el format predeterminat per a la configuració regional actual console.log(date.toLocaleString()); // 2/2/2026, 20:23:36 (suposant una configuració regional de en-US)
// passa opcions de format per generar una cadena de format personalitzada console.log(date.toLocaleString('en-US', { mes: 'llarg', dia: 'numèric', any: 'numèric', hora: "2 dígits", minut: "2 dígits" })); // 22 de febrer de 2026 a les 20:23
// només passa els camps que vulguis a la cadena de format console.log(date.toLocaleString('en-US', { mes: 'curt', dia: 'numèric' })); // 22 de febrer
El format de data temporal utilitza realment l'API Intl.DateTimeFormat (que ja està disponible als navegadors moderns) sota el capó. Això vol dir que podeu crear un objecte DateTimeFormat reutilitzable amb les vostres opcions de format personalitzades i després passar objectes temporals al seu mètode de format. Per això, no admet formats de dates personalitzats com ho fa Moment. Si necessiteu alguna cosa com ara "Q1 2026" o un altre format especialitzat, és possible que necessiteu algun codi de format de data personalitzat o trobareu una biblioteca de tercers. const formatter = new Intl.DateTimeFormat('en-US', { mes: "2 dígits", dia: "2 dígits", any: 'numèric' });
data constant = Temporal.Now.instant(); console.log(formatter.format(data)); // 22/02/2026
Els testimonis de format de Moment són més senzills d'escriure, però no són compatibles amb la configuració regional. El format encadena "codi dur" coses com ara l'ordre del mes/dia. L'avantatge d'utilitzar un objecte de configuració, com ho fa Temporal, és que s'adaptarà automàticament a qualsevol configuració regional i utilitzarà el format correcte. data constant = Temporal.Now.instant();
const formatOptions = { mes: 'numèric', dia: 'numèric', any: 'numèric' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22/2/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Càlculs de dates En moltes aplicacions, haureu d'acabar fent alguns càlculs en una data. És possible que vulgueu sumar o restar unitats de temps (dies, hores, segons, etc.). Per exemple, si teniu la data actual, és possible que vulgueu mostrar la data a l'usuari d'aquí a una setmana. Els objectes de moment tenen mètodes com sumar i restar que realitzen aquestes operacions. Aquestes funcions prenen un valor i una unitat, per exemple: add(7, 'dies'). Una diferència molt important entre Moment i Temporal, però, és que quan es realitzen aquests càlculs de data, l'objecte subjacent es modifica i es perd el seu valor original. const ara = moment();
console.log(ara); // Moment<2026-02-24T20:08:36-05:00>
const nextWeek = ara.add(7, 'dies'); console.log(la setmana vinent); // Moment<2026-03-03T20:08:36-05:00>
// Gotcha - l'objecte original va ser mutat console.log(ara); // Moment<2026-03-03T20:08:36-05:00>
Per evitar perdre la data original, podeu trucar a clonar a l'objecte Moment per crear-ne una còpia. const ara= moment(); const nextWeek = ara.clone().add(7, 'dies');
console.log(ara); // Moment<2026-02-24T20:12:55-05:00>
console.log(la setmana vinent); // Moment<2026-03-03T20:12:55-05:00>
D'altra banda, els objectes temporals són immutables. Un cop hàgiu creat un objecte com un Instant, PlainDate, etc., el valor d'aquest objecte no canviarà mai. Els objectes temporals també tenen mètodes de suma i resta. El temporal és una mica exigent sobre quines unitats de temps es poden afegir a quins tipus d'objectes. Per exemple, no podeu afegir dies a un instant:
const ara = Temporal.Now.instant(); const nextWeek = ara.add({ dies: 7 }); // RangeError: Error temporal: la unitat més gran no pot ser una unitat de data
Això es deu al fet que els objectes instantanis representen un moment específic en el temps UTC i són independents del calendari. Com que la durada d'un dia pot canviar en funció de les regles de la zona horària, com ara l'horari d'estiu, aquest càlcul no està disponible en un instant. Tanmateix, podeu realitzar aquesta operació en altres tipus d'objectes, com ara PlainDateTime: const ara = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
const nextWeek = ara.add({ dies: 7 });
// Tingueu en compte que el PlainDateTime original es manté sense canvis console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
També podeu calcular quant de temps hi ha entre dos objectes Moment o Temporal. Amb la funció de diferència de Moment, heu de proporcionar una unitat per a la granularitat, en cas contrari, tornarà la diferència en mil·lisegons. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(data2.diff(data1)); // 91800000
console.log(data2.diff(data1, 'dies')); // 1
Per fer-ho amb un objecte Temporal, podeu passar un altre objecte Temporal als seus mètodes fins o des. Això retorna un objecte Temporal.Duration que conté informació sobre la diferència horària. L'objecte Duració té propietats per a cada component de la diferència i també pot generar una cadena de durada ISO 8601 que representi la diferència horària.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// majorUnit especifica la unitat de temps més gran a representar // en el càlcul de durada const diff = data2.des de (data1, {Unitat més gran: 'dia'});
console.log(dif.dies); // 1
console.log(diff.hours); // 1
console.log(diff.minuts); // 30
console.log(diff.toString()); // P1DT1H30M // (cadena de durada ISO 8601: 1 dia, 1 hora, 30 minuts)
Comparació de dates i hores Moment i Temporal us permeten comparar dates i hores per determinar quina és abans que l'altra, però adopteu enfocaments diferents amb l'API. Moment proporciona mètodes com ara isBefore, isAfter i isSame per comparar dos objectes Moment. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(data1.isBefore(data2)); // cert
Temporal utilitza un mètode de comparació estàtica per realitzar una comparació entre dos objectes del mateix tipus. Retorna -1 si la primera data ve abans de la segona, 0 si són iguals o 1 si la primera data ve després de la segona. L'exemple següent mostra com comparar dos objectes PlainDate. Els dos arguments de Temporal.PlainDate.compare han de ser objectes PlainDate.
const date1 = Temporal.PlainDate.from ({ any: 2026, mes: 2, dia: 24 }); const date2 = Temporal.PlainDate.from({ any: 2026, mes: 3, dia: 24});
// data1 arriba abans de data2, per tant -1 console.log(Temporal.PlainDate.compare(data1, data2));
// Error si intentem comparar dos objectes de diferents tipus console.log(Temporal.PlainDate.compare(data1, Temporal.Now.instant())); // TypeError: Error temporal: S'han proporcionat camps PlainDate no vàlids.
En particular, això fa que sigui fàcil ordenar una matriu d'objectes temporals cronològicament. // Una matriu d'objectes Temporal.PlainDate dates const = [ ... ];
// utilitza Temporal.PlainDate.compare com a funció de comparació dates.sort(Temporal.PlainDate.compare);
Conversions de zona horària La biblioteca principal de Moment no admet conversions de zones horàries. Si necessiteu aquesta funcionalitat, també heu d'instal·lar el paquet moment-timezone. Aquest paquet no es pot moure en arbre i, per tant, pot augmentar significativament la mida del paquet. Un cop hàgiu instal·lat moment-timezone, podeu convertir objectes Moment a diferents zones horàries amb el mètode tz. Com amb altres operacions Moment, això muta el subjacentobjecte. // Assumint l'hora oriental dels EUA const ara = moment(); console.log(ara); // Moment<2026-02-28T20:08:20-05:00>
// Converteix a hora del Pacífic. // Es perd l'època oriental original. now.tz('America/Los_Angeles'); console.log(ara); // Moment<2026-02-28T17:08:20-08:00>
La funcionalitat de zona horària està integrada a l'API Temporal quan s'utilitza un objecte Temporal.ZonedDateTime. Aquests objectes inclouen un mètode withTimeZone que retorna un nou ZonedDateTime que representa el mateix moment en el temps, però a la zona horària especificada. // De nou, assumint l'hora oriental dels EUA const ara = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28/02/2026, 20:12:02 EST
// Converteix a hora del Pacífic const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28/02/2026, 17:12:02 PST
// L'objecte original es manté sense canvis console.log(now.toLocaleString()); // 28/02/2026, 20:12:02 EST
Nota: els valors amb format que retorna toLocaleString depenen de la configuració regional, com el seu nom indica. El codi d'exemple s'ha desenvolupat a la configuració regional en-US, de manera que el format és el següent: 2/28/2026, 5:12:02 PM PST. En un altre lloc, això pot ser diferent. Per exemple, a la configuració regional en-GB, obtindreu alguna cosa com 28/2/2026, 17:12:02 GMT-8. Una refactorització del món real Suposem que estem creant una aplicació per programar esdeveniments en diferents zones horàries. Part d'aquesta aplicació és una funció, getEventTimes, que pren una cadena ISO 8601 que representa l'hora i la data de l'esdeveniment, una zona horària local i una zona horària objectiu. La funció crea cadenes de data i hora amb format per a l'esdeveniment en ambdues zones horàries. Si la funció rep una cadena d'entrada que no és una cadena de data/hora vàlida, generarà un error. Aquí teniu la implementació original, utilitzant Moment (també requereix l'ús del paquet moment-zona horària).
importar moment de "moment-zona horària";
funció getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Crea el moment inicial a la zona horària de l'usuari const eventTime = moment.tz( inputString, moment.ISO_8601, // Espereu una cadena ISO 8601 cert, // Anàlisi estricte userTimeZone );
// Llença un error si la cadena d'entrada no representa una data vàlida si (!eventTime.isValid()) { throw new Error('Entrada de data/hora no vàlida'); }
// 2. Calcula el temps objectiu // CRÍTIC: Hem de clonar, o "eventTime" canvia per sempre! const targetTime = eventTime.clone().tz(targetTimeZone);
tornar { local: eventTime.format(timeFormat), target: targetTime.format(timeFormat), }; }
const schedule = getEventTimes( '2026-03-05T15:00-05:00', "Amèrica/Nova_York", "Europa/Londres", );
console.log(schedule.local); // 5 de març de 2026, 15:00:00 EST
console.log(schedule.target); // 5 de març de 2026, 20:00:00 GMT
En aquest exemple, estem utilitzant un format de data esperat ISO 8601, que està integrat de manera útil a Moment. També estem utilitzant una anàlisi estricta, la qual cosa significa que Moment no intentarà endevinar amb una cadena de data que no coincideixi amb el format. Si es passa una cadena de data que no sigui ISO, donarà lloc a un objecte de data no vàlid i llançarem un error. La implementació temporal sembla similar, però té algunes diferències clau.
funció getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Analitzeu l'entrada directament en un Instant i, a continuació, creeu // un ZonedDateTime a la zona de l'usuari. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Converteix a la zona objectiu // Això retorna automàticament un objecte NOU; 'eventTime' és segur. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formateu amb Intl (incorporat) const options = { any: 'numèric', mes: 'curt', dia: 'numèric', hora: 'numèrica', minut: "2 dígits", segon: "2 dígits", timeZoneName: "curt" };
tornar { local: eventTime.toLocaleString(navigator.language, opcions), target: targetTime.toLocaleString(navigator.language, opcions) }; }
const schedule = getEventTimes( '2026-03-05T15:00-05:00', "Amèrica/Nova_York", "Europa/Londres", );
console.log(schedule.local); // 5 de març de 2026, 15:00:00 EST
console.log(schedule.target); // 5 de març de 2026, 20:00:00 GMT
Amb Moment, hem d'especificar explícitament una cadena de format per a les cadenes de data resultants. Independentment de la ubicació o la configuració regional de l'usuari, les hores de l'esdeveniment sempre tindran el format 5 de març de 2026, 3:00:00pm EST. A més, no hem de llançar una excepció explícitament. Si es passa una cadena no vàlida a Temporal.Instant.from, Temporal ens llançarà l'excepció. Una cosa a tenir en compte és que, fins i tot amb una anàlisi estricta, la versió de Moment és encara més indulgent. Temporal requereix el desplaçament de la zona horària al final de la cadena. També heu de tenir en compte que, com que estem utilitzant navigator.language, aquest codi només s'executarà en un entorn de navegador, ja que el navegador no està definit en un entorn Node.js. La implementació temporal utilitza la configuració regional actual del navegador (navigator.language), de manera que l'usuari obtindrà automàticament el format de l'hora d'esdeveniment en el seu format d'hora local. A la configuració regional dels EUA, això és el 5 de març de 2026 a les 15:00, EST. Tanmateix, si l'usuari es troba a Londres, per exemple, les hores de l'esdeveniment tindran el format 5 de març de 2026, 15:00:00 GMT-5. Resum
Acció Moment.js Temporal Hora actual moment () Temporal.Now.zonedDateTimeISO() Anàlisi ISO moment (str) Temporal.Instant.from(str) Afegeix temps .add(7, 'dies') (muta) .add({ dies: 7 }) (objecte nou) Diferència .diff(altres, 'hores') .des de(altres).hores Zona horària .tz('Zona/Nom') .withTimeZone('Zona/Nom')
A primera vista, la diferència pot ser lleugerament diferent (i en el cas de Temporal, de vegades més detallada i més estricta), la sintaxi, però hi ha diversos avantatges clau per utilitzar Temporal sobre Moment.js:
Ser més explícit significa menys sorpreses i errors no desitjats. El moment pot semblar més indulgent, però implica "conjectures", que de vegades pot donar lloc a dates incorrectes. Si doneu a Temporal alguna cosa no vàlida, genera un error. Si el codi s'executa, saps que tens una data vàlida. Moment pot afegir una mida important al paquet de l'aplicació, sobretot si utilitzeu el paquet moment-zona horària. Temporal no afegeix res (un cop s'envia als vostres navegadors de destinació). La immutabilitat us proporciona la confiança que mai perdreu ni sobreescriureu dades quan feu operacions i conversions de dates. Diferents representacions del temps (Instant, PlainDateTime, ZonedDateTime) segons els vostres requisits, on Moment sempre és un embolcall al voltant d'una marca de temps UTC. Temporal utilitza les API Intl per al format de la data, la qual cosa significa que podeu tenir un format conscient de la configuració regional sense haver d'especificar explícitament testimonis.
Notes sobre el Polyfill Com s'ha esmentat anteriorment, hi ha disponible un polyfill temporal, distribuït com a paquet npm anomenat @js-temporal/polyfill. Si voleu utilitzar Temporal avui, necessitareu aquest polyfill per admetre navegadors com Safari que encara no han enviat l'API. La mala notícia amb això és que augmentarà la mida del paquet. La bona notícia és que encara afegeix molt menys que el moment o la zona horària del moment. Aquí hi ha una comparació de les mides dels paquets tal com informa Bundlephobia.com, un lloc web que presenta informació sobre les mides dels paquets npm (feu clic al nom de cada paquet per veure l'anàlisi de Bundlephobia):
paquet Minificat Reduït i comprimit @js-temporal/polyfill 154,1 kB 44,1 kB moment 294,4 kB 75,4 kB moment-zona horària 1 MB 114,2 kB
El polyfill també ha tingut històricament alguns problemes de rendiment sobre l'ús de la memòria i, en el moment d'escriure, es considera que es troba en un estat alfa. Per això, és possible que no vulgueu utilitzar-lo en producció fins que arribi a un estat més madur. L'altra bona notícia és que esperem que el polyfill no sigui necessari per molt més temps (tret que hàgiu de suportar navegadors més antics, és clar). En el moment d'escriure, Temporal s'ha enviat a Chrome, Edge i Firefox. Encara no està del tot preparat a Safari, tot i que sembla que està disponible amb un indicador de temps d'execució a la darrera vista prèvia de tecnologia.
