Preskaŭ ajna speco de aplikaĵo skribita en JavaScript funkcias kun tempoj aŭ datoj en iu kapablo. En la komenco, ĉi tio estis limigita al la enkonstruita Date API. Ĉi tiu API inkluzivas bazajn funkciojn, sed estas sufiĉe limigita en tio, kion ĝi povas fari. Triaj bibliotekoj kiel Moment.js, kaj poste enkonstruitaj APIoj kiel la Intl-APIoj kaj la nova Temporal API, aldonas multe pli grandan flekseblecon por labori kun tempoj kaj datoj. La Pliiĝo Kaj Falo De Momento.js Moment.js estas JavaScript-biblioteko kun potencaj iloj por labori kun tempoj kaj datoj. Ĝi inkluzivas mankantajn funkciojn de la baza Date API, kiel horzona manipulado, kaj simpligas multajn oftajn operaciojn. Moment ankaŭ inkluzivas funkciojn por formatado de datoj kaj horoj. Ĝi iĝis vaste uzita biblioteko en multaj malsamaj aplikoj. Tamen, Moment ankaŭ havis sian parton de temoj. Ĝi estas granda biblioteko, kaj povas signife aldoni al la pakgrandeco de aplikaĵo. Ĉar la biblioteko ne subtenas arbo-skuadon (trajto de modernaj pakaĵoj, kiuj povas forigi neuzatajn partojn de bibliotekoj), la tuta Moment-biblioteko estas inkluzivita eĉ se vi uzas nur unu aŭ du el ĝiaj funkcioj. Alia problemo kun Momento estas la fakto ke la objektoj kiujn ĝi kreas estas ŝanĝeblaj. Voki certajn funkciojn sur Momenta objekto havas kromefikojn kaj mutacias la valoron de tiu objekto. Ĉi tio povas konduki al neatendita konduto aŭ cimoj. En 2020, la prizorgantoj de Moment decidis meti la bibliotekon en funkciservan reĝimon. Neniu nova funkcio disvolviĝas, kaj la prizorgantoj rekomendas kontraŭ uzi ĝin por novaj projektoj. Estas aliaj JavaScript datbibliotekoj, kiel date-fns, sed estas nova ludanto en la urbo, API enkonstruita rekte en JavaScript: Temporal. Ĝi estas nova normo, kiu plenigas la truojn de la originala Date API kaj ankaŭ solvas kelkajn el la limigoj trovitaj en Moment kaj aliaj bibliotekoj. Kio Estas Tempora? Temporalo estas nova tempo kaj dato API aldonita al la ECMAScript-normo, kiu difinas modernan JavaScript. En marto 20266, ĝi atingis Etapon 4 de la TC39-procezo (la komisiono kiu kontrolas proponojn kaj aldonojn al la JavaScript-lingvo), kaj estos inkludita en la venonta versio de la ECMAScript-specifo. Ĝi jam estis efektivigita en pluraj retumiloj: Chrome 144+ kaj Fajrovulpo 139+, kaj Safaro atendas baldaŭ sekvi. Polyfill ankaŭ haveblas por nesubtenataj retumiloj kaj Node.js. La Temporal API kreas objektojn kiuj, ĝenerale, reprezentas momentojn en tempo. Tiuj povas esti plentempaj kaj datmarkoj en antaŭfiksita horzono, aŭ ili povas esti senmarka kazo de "mura horloĝo" tempo sen ajna horzono aŭ datinformo. Kelkaj el la ĉefaj trajtoj de Temporal inkluzivas:
Tempoj kun aŭ sen datoj. Tempora objekto povas reprezenti specifan tempon en specifa dato, aŭ tempon sen ajna dato informo. Specifa dato, sen tempo, ankaŭ povas esti reprezentita. Subteno de horzonoj.Temporaj objektoj estas plene konsciaj pri horzono kaj povas esti konvertitaj tra malsamaj horzonoj. Moment subtenas horzonojn ankaŭ, sed ĝi postulas la kroman moment-horzonan bibliotekon. Neŝanĝebleco.Iam Tempora objekto estas kreita, ĝi ne povas esti ŝanĝita. Tempo-aritmetiko aŭ horzonkonvertoj ne modifas la suban objekton. Anstataŭe, ili generas novan Temporan objekton. 1-bazita indeksado. Ofta fonto de cimoj kun la Date API (same kiel kun Moment) estas, ke monatoj estas nul-indeksitaj. Ĉi tio signifas, ke januaro estas monato 0, anstataŭ monato 1, kiel ni ĉiuj komprenas en la reala vivo. Temporalo riparas ĉi tion uzante 1-bazitan indeksadon - januaro estas monato 1. Ĝi estas konstruita en la retumilon. Ĉar Temporal estas API en la retumilo mem, ĝi aldonas nenion al la pakgrandeco de via aplikaĵo.
Ankaŭ gravas noti, ke la Date API ne foriras. Dum Temporal anstataŭas ĉi tiun API, ĝi ne estas forigita aŭ malrekomendita. Multaj aplikoj rompiĝus se retumiloj subite forigus la Date API. Tamen, ankaŭ memoru, ke Moment nun estas konsiderata hereda projekto en bontena reĝimo. En la resto de la artikolo, ni rigardos kelkajn "receptojn" por migrado de Moment-bazita kodo al la nova Temporal API. Ni komencu refaktorigon! Kreante Datajn kaj Tempajn Objektojn Antaŭ ol ni povas manipuli datojn kaj horojn, ni devas krei objektojn reprezentantajn ilin. Por krei Momentan objekton reprezentantan la aktualan daton kaj horon, uzu la momentfunkcion. const nun = momento(); console.log(nun); // Momento<2026-02-18T21:26:29-05:00>
Ĉi tiu objekto nun povas esti formatita aŭ manipulita laŭbezone.
// konverti al UTC //averto: Ĉi tio mutacias la Momentan objekton kaj metas ĝin en UTC-reĝimon! console.log(nun.utc()); // Momento<2026-02-19T02:26:29Z>
// presi formatitan ĉenon - notu, ke ĝi nun uzas la UTC-tempon console.log(nun.format('MM/DD/YYYY hh:mm:ss a')); // 19/02/2026 02:27:07 a.m
La ŝlosila afero por memori pri Momento estas, ke Momenta objekto ĉiam inkluzivas informojn pri la tempo kaj la dato. Se vi nur bezonas labori kun tempinformoj, ĉi tio kutime estas bona, sed ĝi povas kaŭzi neatenditan konduton en situacioj kiel Somera Tempo aŭ superjaroj, kie la dato povas efiki sur tempokalkuloj. Temporalo estas pli fleksebla. Vi povas krei objekton reprezentantan la aktualan daton kaj horon kreante Temporal.Instant objekton. Ĉi tio reprezentas tempopunkton difinitan de la tempo ekde "la epoko" (noktomezo UTC la 1-an de januaro 1970). Temporalo povas referenci ĉi tiun momenton en tempo kun nanosekun-nivela precizeco. const nun = Temporalo.Nun.instant ();
// vidu krudajn nanosekundojn ekde la epoko console.log(nun.epochNanoseconds); // 1771466342612000000n
// formato por UTC console.log(nun.toString()); // 2026-02-19T01:55:27.844Z
// formato por aparta horzono console.log(nun.toString({ timeZone: 'Ameriko/Nov_Jorko' })); // 2026-02-18T20:56:57.905-05:00
Temporaj.Tuj objektoj ankaŭ povas esti kreitaj por specifa tempo kaj dato uzante la de statika metodo.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formatu la momenton en la loka horzono. Notu, ke ĉi tio nur kontrolas // la formatado - ĝi ne mutacias la objekton kiel faras moment.utc. console.log (myInstant.toString ({ horzono: 'Ameriko/Nov_Jorko' })); // 2026-02-18T21:10:00-05:00
Vi ankaŭ povas krei aliajn specojn de Temporaj objektoj, inkluzive de:
Temporal.PlainDate: dato sen tempo-informo. Temporal.PlainTime: Tempo sen datinformoj. Temporal.ZonedDateTime: dato kaj horo en specifa horzono.
Ĉiu el ĉi tiuj havas metodon de kiu povas esti vokita kun objekto specifanta la daton kaj/aŭ horon, aŭ datĉenon por analizi. // Nur dato const hodiaŭ = Temporal.PlainDate.from({ jaro: 2026, monato: 2, // rimarku, ke ni uzas 2 por februaro tago: 18 }); console.log(hodiaŭ.toString()); // 2026-02-18
// Nur tempon const lunchTime = Temporal.PlainTime.from({ horo: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Dato kaj horo en la usona orienta horzono const dueAt = Temporal.ZonedDateTime.from({ TimeZone: 'Ameriko/Nov-Jorko', jaro: 2026, monato: 3, tago: 1, horo: 12, minuto: 0, dua: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Ameriko/Nov-Jorko]
Analizado Ni kovris programan kreadon de dataj kaj horo-informoj. Nun ni rigardu analizadon. Analizado estas unu areo kie Moment estas pli fleksebla ol la enkonstruita Temporal API. Vi povas analizi datĉenon pasante ĝin al la momentfunkcio. Kun ununura argumento, Moment atendas ISO-datan ĉenon, sed vi povas uzi alternativajn formatojn se vi provizas duan argumenton specifantan la datformaton uzatan.
const isoDato = momento('2026-02-21T09:00:00'); const formatedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDato); // Momento<2026-02-21T09:00:00-05:00>
console.log(formatitaDato); // Momento<2026-02-21T09:00:00-05:00>
En pli malnovaj versioj, Moment farus plej bonan divenon por analizi ajnan arbitre formatitan datĉenon. Ĉi tio povus konduki al neantaŭvideblaj rezultoj. Ekzemple, ĉu 02-03-2026 estas la 2-a de februaro aŭ la 3-a de marto? Tial, pli novaj versioj de Moment montras elstaran averton pri malrekomendiĝo se ĝi estas vokita sen ISO formatita datŝnuro (krom se la dua argumento kun la dezirata formato ankaŭ estas donita). Temporalo nur analizos specife formatitan datĉenon. La ĉeno devas esti konforma al la formato ISO 8601 aŭ ĝia etendaĵo, RFC 9557. Se nekonforma datĉeno estas pasita al metodo de, Temporal ĵetos RangeError.
// Uzanta RFC 9557-datoĉeno const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[Ameriko/Nov_Jorko]'); console.log (miaDato.toString ({ horzono: 'Ameriko/Nov_Jorko' })); // 2026-02-21T09:00:00-05:00
// Uzanta nekonatan datĉenon const otherDato = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Temporara eraro: Nevalida signo dum analizado de jarvaloro.
La precizaj postuloj de la datoŝnuro dependas de kia Tempora objekto vi kreas. En la supra ekzemplo, Temporal.Instant postulas plenan ISO8601 aŭ RFC 9557 datŝnuro specifanta la daton kaj horon kun horzona ofseto, sed vi ankaŭ povas krei PlainDate aŭ PlainTime objektojn uzante nur subaron de la datformato. const myDate = Temporal.PlainDate.from ('2026-02-21'); console.log(miaDato.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(miaTempo.toString()); // 09:00:00
Notu, ke ĉi tiuj ŝnuroj ankoraŭ devas konformi al la atendata formato, aŭ eraro estos ĵetita.
// Uzante nekonformajn tempoĉenojn. Ĉi tiuj ĉiuj ĵetos RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Profesia konsilo: Pritraktado de ne-ISO-ŝnuroj Ĉar Temporalo prioritatas fidindecon, ĝi ne provos diveni la formaton de ŝnuro kiel 02-01-2026. Se via datumfonto uzas tiajn ŝnurojn, vi devos fari iom da ŝnuromanipulado por rearanĝi la valorojn en ISO-ĉenon kiel 2026-02-01 antaŭ ol provi uzi ĝin kun Temporal.
Formatado Post kiam vi havas Momentan aŭ Temporan objekton, vi verŝajne volos konverti ĝin al formatita ĉeno iam. Ĉi tio estas kazo kie Momento estas iom pli konciza. Vi nomas la formatan metodon de la objekto per ŝnuro da ĵetonoj, kiuj priskribas la deziratan datformaton. konst dato = momento ();
console.log(date.format('MM/DD/YYYY')); // 22/02/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // La 22-an de februaro 2026, 20:18:30
Aliflanke, Temporal postulas, ke vi estu iom pli vorta. Temporaj objektoj, kiel Instant, havas metodon toLocaleString, kiu akceptas diversajn formatajn opciojn specifitajn kiel trajtojn de objekto.
konst dato = Temporal.Now.instant ();
// sen argumentoj, ni ricevos la defaŭltan formaton por la nuna loko console.log(date.toLocaleString()); // 2/22/2026, 20:23:36 (supozante lokon de en-US)
// transdonas formatajn opciojn por generi propran formatan ĉenon console.log(date.toLocaleString('en-US', { monato: 'longa', tago: 'numera', jaro: 'numera', horo: '2-cifera', minuto: '2-cifera' })); // La 22-an de februaro 2026 je la 20:23
// nur preterpasu la kampojn, kiujn vi volas en la formata ĉeno console.log(date.toLocaleString('en-US', { monato: 'mallonga', tago: 'numera' })); // la 22-an de februaro
Tempa datformatado efektive uzas la Intl.DateTimeFormat API (kiu jam estas facile havebla en modernaj retumiloj) sub la kapuĉo. Tio signifas, ke vi povas krei recikleblan DateTimeFormat-objekton kun viaj kutimaj formataj opcioj, poste pasi Tempajn objektojn al ĝia formata metodo. Pro tio, ĝi ne subtenas kutimajn datajn formatojn kiel Moment faras. Se vi bezonas ion kiel 'Q1 2026' aŭ alian specialigitan formatadon, vi eble bezonos iun kutiman datformatan kodon aŭ atingi trian bibliotekon. const formatilo = nova Intl.DateTimeFormat('en-US', { monato: '2-cifera', tago: '2-cifera', jaro: 'numera' });
konst dato = Temporal.Now.instant (); console.log(formatilo.formato(dato)); // 22/02/2026
La formataj ĵetonoj de Moment estas pli simplaj por skribi, sed ili ne estas loke-amikaj. La formato ĉenoj "malmola kodo" aferoj kiel monato/taga ordo. La avantaĝo uzi agordan objekton, kiel Temporal faras, estas ke ĝi aŭtomate adaptiĝos al iu ajn loko kaj uzos la ĝustan formaton. konst dato = Temporal.Now.instant ();
const formatOptions = { monato: 'numera', tago: 'numera', jaro: 'numera' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22/2/2026
console.log(date.toLocaleString('eo-GB', formatOptions)); // 22/02/2026
Dataj kalkuloj En multaj aplikoj, vi devos fini fari kelkajn kalkulojn en dato. Vi eble volas aldoni aŭ subtrahi unuojn de tempo (tagoj, horoj, sekundoj, ktp.). Ekzemple, se vi havas la aktualan daton, vi eble volas montri al la uzanto la daton post 1 semajno. Momentaj objektoj havas metodojn kiel aldoni kaj subtrahi, kiuj plenumas ĉi tiujn operaciojn. Ĉi tiuj funkcioj prenas valoron kaj unuon, ekzemple: add(7, 'tagoj'). Unu tre grava diferenco inter Momento kaj Temporalo, tamen, estas, ke kiam oni faras ĉi tiujn datajn kalkulojn, la suba objekto estas modifita kaj ĝia origina valoro estas perdita. const nun = momento();
console.log(nun); // Momento<2026-02-24T20:08:36-05:00>
const nextWeek = nun.add(7, 'tagoj'); console.log (venonta Semajno); // Momento<2026-03-03T20:08:36-05:00>
// Gotcha - la origina objekto estis mutaciita console.log(nun); // Momento<2026-03-03T20:08:36-05:00>
Por eviti perdi la originan daton, vi povas voki klonon sur la Momenta objekto por krei kopion. const nun= momento(); const nextWeek = nun.clone().add(7, 'tagoj');
console.log(nun); // Momento<2026-02-24T20:12:55-05:00>
console.log (venonta Semajno); // Momento<2026-03-03T20:12:55-05:00>
Aliflanke, Tempaj objektoj estas neŝanĝeblaj. Post kiam vi kreis objekton kiel Instant, PlainDate, kaj tiel plu, la valoro de tiu objekto neniam ŝanĝiĝos. Tempaj objektoj ankaŭ havas aldonajn kaj subtrahi metodojn. Temporalo estas iom elektema pri kiuj tempounuoj povas esti aldonitaj al kiuj objektotipoj. Ekzemple, vi ne povas aldoni tagojn al Tuj:
const nun = Temporalo.Nun.instant (); const venontaSemajno = nun.add({ tagoj: 7 }); // RangeError: Temporaro: Plej granda unuo ne povas esti datunuo
Ĉi tio estas ĉar Tuj objektoj reprezentas specifan momenton en UTC kaj estas kalendar-agnostikaj. Ĉar la longeco de tago povas ŝanĝiĝi surbaze de horzonaj reguloj kiel la Somera Tempo, ĉi tiu kalkulo ne estas disponebla en Tuj. Vi povas tamen fari ĉi tiun operacion sur aliaj specoj de objektoj, kiel PlainDateTime: const nun = Temporalo.Now.plainDateTimeISO (); console.log(nun.toLocaleString()); // 2026/02/24, 20:23:59
const venontaSemajno = nun.add({ tagoj: 7 });
// Notu, ke la originala PlainDateTime restas senŝanĝa console.log(nun.toLocaleString()); // 2026/02/24, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Vi ankaŭ povas kalkuli kiom da tempo estas inter du Momentaj aŭ Temporaj objektoj. Kun la diffunkcio de Moment, vi devas provizi unuon por granulareco, alie ĝi redonos la diferencon en milisekundoj. konst dato1 = momento('2026-02-21T09:00:00'); konst dato2 = momento('2026-02-22T10:30:00');
console.log(dato2.diff(dato1)); // 91800000
console.log (dato2.diff (dato1, 'tagoj')); // 1
Por fari tion kun Tempora objekto, vi povas pasi alian Temporalon al ĝiaj metodoj ĝis aŭ ekde. Ĉi tio resendas objekton Temporal.Duration enhavantan informojn pri la tempodiferenco. La Duration-objekto havas ecojn por ĉiu komponento de la diferenco, kaj ankaŭ povas generi ISO 8601-daŭroĉenon reprezentantan la tempodiferencon.
konst dato1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// plej granda unuo precizigas la plej grandan tempounuon por reprezenti // en la daŭrokalkulo konst dif = dato2.ekde (dato1, { plej granda Unuo: 'tago' });
console.log(malsamaj.tagoj); // 1
console.log (malsamaj horoj); // 1
console.log (malsamaj minutoj); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 daŭroŝnuro: 1 tago, 1 horo, 30 minutoj)
Komparante Datojn Kaj Tempojn Momenta kaj Temporalo ambaŭ permesas kompari datojn kaj horojn por determini kiu venas antaŭ la alia, sed alprenu malsamajn alirojn kun la API. Moment provizas metodojn kiel isBefore, isAfter kaj isSame por kompari du Moment-objektojn. konst dato1 = momento('2026-02-21T09:00:00'); konst dato2 = momento('2026-02-22T10:30:00');
console.log(date1.isBefore(dato2)); // vera
Temporalo uzas senmovan komparmetodon por fari komparon inter du objektoj de la sama tipo. Ĝi liveras -1 se la unua dato venas antaŭ la dua, 0 se ili estas egalaj, aŭ 1 se la unua dato venas post la dua. La sekva ekzemplo montras kiel kompari du PlainDate-objektojn. Ambaŭ argumentoj al Temporal.PlainDate.compare devas esti PlainDate-objektoj.
konst dato1 = Temporal.PlainDate.from({ jaro: 2026, monato: 2, tago: 24}); konst dato2 = Temporal.PlainDate.from({ jaro: 2026, monato: 3, tago: 24});
// dato1 venas antaŭ dato2, do -1 console.log(Temporal.PlainDate.compare (dato1, dato2));
// Eraro se ni provas kompari du objektojn de malsamaj tipoj console.log(Temporal.PlainDate.compare(dato1, Temporal.Now.instant())); // TypeError: Temporara eraro: Nevalidaj PlainDate-kampoj provizitaj.
Aparte, tio faciligas ordigi aron de Temporaj objektoj kronologie. // Tabelo de Temporal.PlainDate objektoj konst datoj = [ ... ];
// uzu Temporal.PlainDate.compare kiel komparilan funkcion datoj.sort(Temporal.PlainDate.compare);
Horzonaj Konvertiĝoj La kerna Moment-biblioteko ne subtenas horzonajn konvertiĝojn. Se vi bezonas ĉi tiun funkcion, vi ankaŭ devas instali la moment-horzonan pakaĵon. Ĉi tiu pakaĵo ne estas arbo-skuebla, kaj tial povas signife aldoni al via pakgrando. Post kiam vi instalis moment-horzonon, vi povas konverti Momentajn objektojn al malsamaj horzonoj per la tz-metodo. Kiel kun aliaj Moment-operacioj, ĉi tio mutacias la subestanobjekto. // Supozante usonan orientan tempon const nun = momento(); console.log(nun); // Momento<2026-02-28T20:08:20-05:00>
// Konverti al Pacifika tempo. // La origina orienta tempo estas perdita. nun.tz('Ameriko/Los_Angeles'); console.log(nun); // Momento<2026-02-28T17:08:20-08:00>
Horzonfunkcio estas konstruita en la Temporal API kiam vi uzas Temporal.ZonedDateTime objekto. Ĉi tiuj objektoj inkluzivas kunTimeZone-metodon, kiu resendas novan ZonedDateTime reprezentantan la saman momenton, sed en la specifita horzono. // Denove, supozante usonan orientan tempon const nun = Temporalo.Now.zonedDateTimeISO (); console.log(nun.toLocaleString()); // 2026/02/28, 20:12:02 EST
// Konverti al Pacifika tempo const nowPacific = nun.withTimeZone('America/Los_Angeles'); console.log(nunPacific.toLocaleString()); // 2/28/2026, 17:12:02 PST
// Originala objekto restas senŝanĝa console.log(nun.toLocaleString()); // 2026/02/28, 20:12:02 EST
Noto: La formatitaj valoroj resenditaj de toLocaleString estas, kiel la nomo implicas, dependaj de loka. La ekzempla kodo estis evoluigita en la en-usona loko, do la formato estas tia: 2/28/2026, 5:12:02 PM PST. En alia loko, tio povas esti malsama. Ekzemple, en la en-GB-loko, vi ricevus ion kiel 28/2/2026, 17:12:02 GMT-8. Real-monda Refaktorado Supozu, ke ni konstruas apon por plani eventojn trans horzonoj. Parto de ĉi tiu programo estas funkcio, getEventTimes, kiu prenas ISO 8601-ĉenon reprezentante la horon kaj daton de la evento, lokan horzonon kaj celan horzonon. La funkcio kreas formatitajn tempo- kaj datajn ĉenojn por la evento en ambaŭ horzonoj. Se la funkcio ricevas enigan ĉenon, kiu ne estas valida tempo/dato, ĝi ĵetos eraron. Jen la originala efektivigo, uzante Momenton (ankaŭ postulante uzon de la moment-horzona pakaĵo).
importi momenton el 'momento-horzono';
funkcio getEventTimes(inputString, userTimeZone, celTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Kreu la komencan momenton en la horzono de la uzanto const eventTime = momento.tz( enigoString, momento.ISO_8601, // Atendu ISO 8601-ĉenon vera, // Strikta analizo userTimeZone );
// Ĵeti eraron se la inputString ne reprezentis validan daton se (!eventTime.isValid()) { throw new Eraro ('Nevalida dato/hora enigo'); }
// 2. Kalkulu la celtempon // KRITIKA: Ni devas kloni, aŭ 'eventTime' ŝanĝiĝas por ĉiam! const celtempo = eventTime.clone().tz(celTimeZone);
reveni { loka: eventTime.format(timeFormat), celo: targetTime.format(timeFormat), }; }
const horaro = getEventTimes ( '2026-03-05T15:00-05:00', 'Ameriko/Nov-Jorko', "Eŭropo/Londono", );
console.log(horaro.loka); // Mar 5, 2026, 3:00:00 pm EST
console.log(horaro.celo); // Mar 5, 2026, 20:00:00 GMT
En ĉi tiu ekzemplo, ni uzas atenditan datformaton de ISO 8601, kiu estas helpeme konstruita en Moment. Ni ankaŭ uzas striktan analizadon, kio signifas, ke Momento ne provos diveni kun dato-ĉeno, kiu ne kongruas kun la formato. Se ne-ISO-datoŝnuro estas preterpasita, ĝi rezultigos nevalidan datan objekton, kaj ni ĵetas eraron. La Temporal-efektivigo aspektas simila, sed havas kelkajn ŝlosilajn diferencojn.
funkcio getEventTimes(inputString, userTimeZone, celTimeZone) { // 1. Analizu la enigon rekte en Tujaĵon, poste kreu // ZonedDateTime en la zono de la uzanto. const instant = Temporal.Instant.from (inputString); const eventTime = instant.toZonedDateTimeISO (uzantoTimeZone);
// 2. Konverti al la celzono // Ĉi tio aŭtomate resendas NOVAN objekton; 'eventTime' estas sekura. const targetTime = eventTime.withTimeZone (celTimeZone);
// 3. Formatu uzante Intl (enkonstruitan) konst opcioj = { jaro: 'numera', monato: 'mallonga', tago: 'numera', horo: 'numera', minuto: '2-cifera', dua: '2-cifera', timeZoneName: 'mallonga' };
reveni { loka: eventTime.toLocaleString(navigator.language, opcioj), celo: targetTime.toLocaleString(navigator.language, opcioj) }; }
const horaro = getEventTimes ( '2026-03-05T15:00-05:00', 'Ameriko/Nov-Jorko', "Eŭropo/Londono", );
console.log(horaro.loka); // Mar 5, 2026, 3:00:00 PM EST
console.log(horaro.celo); // Mar 5, 2026, 20:00:00 GMT
Kun Momento, ni devas eksplicite specifi formatan ĉenon por la rezultantaj datoŝnuroj. Sendepende de la loko aŭ loko de la uzanto, la okazaĵaj tempoj ĉiam estos formatitaj kiel Mar 5, 2026, 3:00:00pm EST. Ankaŭ, ni ne devas eksplicite ĵeti escepton. Se nevalida ĉeno estas transdonita al Temporal.Instant.from, Temporal ĵetos la escepton por ni. Unu afero rimarkinda estas, ke eĉ kun strikta analizado, la Moment-versio ankoraŭ estas pli milda. Temporalo postulas la horzonan ofseton ĉe la fino de la ĉeno. Vi ankaŭ notu, ke ĉar ni uzas navigator.language, ĉi tiu kodo ruliĝos nur en retumila medio, ĉar navigilo ne estas difinita en Node.js-medio. La Temporal-efektivigo uzas la nunan lokaĵon de la retumilo (navigator.language), do la uzanto aŭtomate ricevos eventotempojn formatitajn en sia loka tempoformato. En la en-usona loko, tio estas la 5-a de marto 2026, 15:00:00 EST. Tamen, se la uzanto estas en Londono, ekzemple, la okazaĵaj tempoj estos formatitaj kiel 5 Mar 2026, 15:00:00 GMT-5. Resumo
Ago Momento.js Temporalo Nuna horo momento () Temporal.Now.zonedDateTimeISO() Analizante ISO momento (str) Temporalo.Tuja.de(str) Aldonu tempon .add(7, 'tagoj') (ŝanĝas) .add({ tagoj: 7 }) (nova objekto) Diferenco .diff(aliaj, 'horoj') .de(aliaj).horoj Horzono .tz('Zono/Nomo') .withTimeZone('Zono/Nomo')
Unuavide, la diferenco povas esti iomete malsama (kaj en la kazo de Temporal, foje pli multvorta kaj pli strikta) sintakso, sed ekzistas pluraj ĉefaj avantaĝoj uzi Temporal super Moment.js:
Esti pli eksplicita signifas malpli da surprizoj kaj neintencitaj cimoj. Momento povas ŝajni esti pli milda, sed ĝi implikas "konjekton", kiu foje povas rezultigi malĝustajn datojn. Se vi donas Temporalon ion nevalidan, ĝi ĵetas eraron. Se la kodo funkcias, vi scias, ke vi havas validan daton. Momento povas aldoni signifan grandecon al la pakaĵo de la aplikaĵo, precipe se vi uzas la moment-horzonan pakaĵon. Tempoal aldonas nenion (post kiam ĝi estas sendita en viaj celaj retumiloj). Neŝanĝebleco donas al vi la fidon, ke vi neniam perdos aŭ anstataŭigos datumojn kiam vi faras datajn konvertiĝojn kaj operaciojn. Malsamaj reprezentoj de tempo (Tuja, PlainDateTime, ZonedDateTime) depende de viaj postuloj, kie Momento ĉiam estas envolvaĵo ĉirkaŭ UTC-tempostampo. Temporal uzas la Intl-APIojn por datformatado, kio signifas, ke vi povas havi lok-konscian formatadon sen devi eksplicite specifi ĵetonojn.
Notoj Pri La Polyfill Kiel menciite pli frue, ekzistas Temporal polyfill disponebla, distribuita kiel npm-pakaĵo nomita @js-temporal/polyfill. Se vi volas uzi Temporal hodiaŭ, vi bezonos ĉi tiun polyfill por subteni retumiloj kiel Safari, kiuj ankoraŭ ne sendis la API. La malbona novaĵo kun ĉi tio estas, ke ĝi aldonos al via pakgrandeco. La bona novaĵo estas, ke ĝi ankoraŭ aldonas signife malpli ol momento aŭ momento-horzono. Jen komparo de la pakaĵgrandoj kiel raportite fare de Bundlephobia.com, retejo kiu prezentas informojn pri npm pakgrandecoj (alklaku sur ĉiu paknomo por vidi la Bundlephobia analizon):
Pako Minigita Minimigita & gzipped @js-temporal/polyfill 154,1 kB 44,1 kB momento 294,4 kB 75,4 kB moment-horzono 1 MB 114,2 kB
La poliplenigo ankaŭ historie havis kelkajn rendimentajn problemojn ĉirkaŭ memoruzo, kaj dum la skribado, ĝi estas konsiderata kiel alfa-stato. Pro tio, vi eble ne volas uzi ĝin en produktado ĝis ĝi atingos pli maturan staton. La alia bona novaĵo estas, ke espereble la polyfill ne estos bezonata multe pli longe (krom se vi bezonas subteni pli malnovajn retumiloj, kompreneble). Dum la skribado, Temporal estis sendita en Chrome, Edge kaj Firefox. Ĝi ankoraŭ ne estas tute preta en Safaro, kvankam ĝi ŝajnas esti disponebla kun rultempa flago en la plej nova Teknologia Antaŭrigardo.
