Skoraj vsaka vrsta aplikacije, napisane v JavaScriptu, do neke mere deluje s časi ali datumi. Na začetku je bilo to omejeno na vgrajeni API za datume. Ta API vključuje osnovno funkcionalnost, vendar je precej omejen v svojih zmožnostih. Knjižnice tretjih oseb, kot je Moment.js, in pozneje vgrajeni API-ji, kot sta Intl API-ji in novi Temporal API, dodajajo veliko večjo prilagodljivost pri delu s časi in datumi. Vzpon in padec Moment.js Moment.js je knjižnica JavaScript z zmogljivimi pripomočki za delo s časi in datumi. Vključuje manjkajoče funkcije iz osnovnega API-ja za datume, kot je manipulacija s časovnim pasom, in poenostavi številne običajne operacije. Moment vključuje tudi funkcije za oblikovanje datumov in ur. Postala je široko uporabljena knjižnica v številnih različnih aplikacijah. Vendar je imel tudi Moment svoj delež težav. To je velika knjižnica in lahko znatno poveča velikost paketa aplikacije. Ker knjižnica ne podpira drevesnega stresanja (funkcija sodobnih povezovalnikov, ki lahko odstranijo neuporabljene dele knjižnic), je celotna knjižnica Moment vključena, tudi če uporabljate samo eno ali dve njeni funkciji. Druga težava pri Momentu je dejstvo, da so predmeti, ki jih ustvari, spremenljivi. Klicanje določenih funkcij na objektu Moment ima stranske učinke in spremeni vrednost tega predmeta. To lahko povzroči nepričakovano vedenje ali napake. Leta 2020 so se vzdrževalci Momenta odločili knjižnico preklopiti v vzdrževalni način. Ne razvija se nobena nova funkcija in vzdrževalci priporočajo, da se ne uporablja za nove projekte. Obstajajo še druge knjižnice datumov JavaScript, kot je date-fns, vendar je v mestu nov igralec, API, vgrajen neposredno v JavaScript: Temporal. To je nov standard, ki zapolnjuje luknje prvotnega API-ja za datume in rešuje nekatere omejitve, ki jih najdemo v Momentu in drugih knjižnicah. Kaj je temporalno? Temporal je nov API za čas in datum, ki je dodan standardu ECMAScript, ki definira sodobni JavaScript. Od marca 20266 je dosegel 4. stopnjo procesa TC39 (odbor, ki nadzira predloge in dodatke k jeziku JavaScript) in bo vključen v naslednjo različico specifikacije ECMAScript. Implementiran je bil že v več brskalnikih: Chrome 144+ in Firefox 139+, kmalu pa naj bi mu sledil tudi Safari. Polifill je na voljo tudi za nepodprte brskalnike in Node.js. Temporal API ustvari objekte, ki na splošno predstavljajo trenutke v času. To so lahko polni delovni čas in datumski žigi v danem časovnem pasu ali pa so lahko generični primerek časa »stenske ure« brez informacij o časovnem pasu ali datumu. Nekatere glavne značilnosti Temporal vključujejo:
Časi z ali brez datumov. Časovni objekt lahko predstavlja določen čas na določen datum ali čas brez datumskih informacij. Predstavljen je lahko tudi določen datum brez časa. Podpora za časovni pas. Začasni objekti v celoti poznajo časovni pas in jih je mogoče pretvoriti v različne časovne pasove. Moment podpira tudi časovne pasove, vendar zahteva dodatno knjižnico moment-timezone. Nespremenljivost. Ko je začasni objekt ustvarjen, ga ni mogoče spremeniti. Pretvorbe časovne aritmetike ali časovnih pasov ne spremenijo osnovnega predmeta. Namesto tega ustvarijo nov časovni objekt. Indeksiranje na podlagi 1. Pogost vir napak z API-jem za datum (kot tudi z Momentom) je, da so meseci indeksirani z nič. To pomeni, da je januar mesec 0 in ne mesec 1, kot vsi razumemo v resničnem življenju. Temporal to popravi z uporabo indeksiranja na podlagi 1 – januar je 1. mesec. Vgrajen je v brskalnik. Ker je Temporal API v samem brskalniku, ne doda ničesar k velikosti paketa vaše aplikacije.
Pomembno je tudi omeniti, da API za datume ne bo izginil. Čeprav Temporal nadomešča ta API, ga ne bomo odstranili ali zastareli. Številne aplikacije bi se zlomile, če bi brskalniki nenadoma odstranili datumski API. Vendar ne pozabite tudi, da se Moment zdaj šteje za podedovan projekt v načinu vzdrževanja. V nadaljevanju članka si bomo ogledali nekaj "receptov" za selitev kode, ki temelji na Momentu, v novi Temporal API. Začnimo s preoblikovanjem! Ustvarjanje predmetov datuma in časa Preden lahko manipuliramo z datumi in časi, moramo ustvariti predmete, ki jih predstavljajo. Če želite ustvariti predmet Trenutek, ki predstavlja trenutni datum in uro, uporabite funkcijo trenutka. const zdaj = moment(); console.log(zdaj); // Trenutek<2026-02-18T21:26:29-05:00>
Ta predmet je zdaj mogoče formatirati ali manipulirati po potrebi.
// pretvori v UTC //opozorilo: To mutira objekt Moment in ga postavi v način UTC! console.log(now.utc()); // Trenutek<2026-02-19T02:26:29Z>
// natisni oblikovani niz - upoštevajte, da zdaj uporablja čas UTC console.log(now.format('MM/DD/LLLL hh:mm:ss a')); // 19. 2. 2026 02:27:07 zjutraj
Ključna stvar, ki si jo morate zapomniti pri Momentu, je, da objekt Moment vedno vključuje informacije o času in datumu. Če morate delati samo s podatki o času, je to običajno v redu, vendar lahko povzroči nepričakovano vedenje v situacijah, kot je poletni čas ali prestopna leta, kjer lahko datum vpliva na izračune časa. Časovnica je bolj prožna. Ustvarite lahko objekt, ki predstavlja trenutni datum in čas, tako da ustvarite objekt Temporal.Instant. To predstavlja časovno točko, opredeljeno s časom od »epohe« (opolnoči UTC 1. januarja 1970). Temporal se lahko sklicuje na ta trenutek v času z nanosekundno natančnostjo. const zdaj = Temporal.Now.instant();
// ogled neobdelanih nanosekund od epohe console.log(now.epochNanoseconds); // 1771466342612000000n
// format za UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// format za določen časovni pas console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Objekte Temporal.Instant je mogoče ustvariti tudi za določen čas in datum z uporabo metode from static.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Oblikujte trenutek v lokalnem časovnem pasu. Upoštevajte, da to samo nadzoruje // oblikovanje - ne spreminja predmeta, kot to počne moment.utc. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Ustvarite lahko tudi druge vrste začasnih predmetov, vključno z:
Temporal.PlainDate: datum brez informacij o času. Temporal.PlainTime: čas brez podatkov o datumu. Temporal.ZonedDateTime: datum in čas v določenem časovnem pasu.
Vsak od teh ima metodo from, ki jo je mogoče poklicati z objektom, ki določa datum in/ali čas, ali datumski niz za razčlenitev. // Samo zmenek const danes = Temporal.PlainDate.from({ leto: 2026, mesec: 2, // upoštevajte, da uporabljamo 2 za februar dan: 18 }); console.log(today.toString()); // 2026-02-18
// Samo čas const lunchTime = Temporal.PlainTime.from({ ura: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Datum in čas v vzhodnem časovnem pasu ZDA const dueAt = Temporal.ZonedDateTime.from({ časovni pas: 'America/New_York', leto: 2026, mesec: 3, dan: 1, ura: 12, minuta: 0, drugič: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amerika/New_York]
Razčlenjevanje Zajeli smo programsko ustvarjanje informacij o datumu in času. Zdaj pa poglejmo razčlenjevanje. Razčlenjevanje je eno področje, kjer je Moment bolj prilagodljiv kot vgrajen Temporal API. Datumski niz lahko razčlenite tako, da ga posredujete trenutni funkciji. Z enim samim argumentom Moment pričakuje datumski niz ISO, vendar lahko uporabite druge oblike zapisa, če podate drugi argument, ki določa uporabljeno obliko datuma.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('21.2.26 9:00:00', 'M/D/LL h:mm:ss');
console.log(isoDate); // Trenutek<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Trenutek<2026-02-21T09:00:00-05:00>
V starejših različicah bi Moment najbolje ugibal, da bi razčlenil kateri koli poljubno oblikovan datumski niz. To lahko vodi do nepredvidljivih rezultatov. Ali je na primer 02-03-2026 2. februar ali 3. marec? Iz tega razloga novejše različice Momenta prikažejo vidno opozorilo o zastarelosti, če se kliče brez datumskega niza, oblikovanega v ISO (razen če je podan tudi drugi argument z želeno obliko). Temporal bo razčlenil samo posebej oblikovan datumski niz. Niz mora biti združljiv s formatom ISO 8601 ali njegovo razširitvijo, RFC 9557. Če je neskladen datumski niz posredovan metodi from, bo Temporal vrgel RangeError.
// Uporaba datumskega niza 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' })); // 2026-02-21T09:00:00-05:00
// Uporaba neznanega datumskega niza const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Časovna napaka: Neveljaven znak med razčlenjevanjem vrednosti leta.
Natančne zahteve za datumski niz so odvisne od vrste časovnega objekta, ki ga ustvarjate. V zgornjem primeru Temporal.Instant zahteva polni ISODatumski niz 8601 ali RFC 9557, ki določa datum in čas z odmikom časovnega pasu, lahko pa ustvarite tudi objekte PlainDate ali PlainTime z uporabo samo podnabora oblike zapisa datuma. const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
Upoštevajte, da morajo biti ti nizi še vedno skladni s pričakovano obliko, sicer bo prikazana napaka.
// Uporaba neskladnih časovnih nizov. Vse to bo povzročilo RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Profesionalni nasvet: ravnanje z nizi, ki niso ISO. Ker Temporal daje prednost zanesljivosti, ne bo poskušal uganiti formata niza, kot je 02-01-2026. Če vaš podatkovni vir uporablja takšne nize, boste morali narediti nekaj manipulacij z nizi, da preuredite vrednosti v niz ISO, kot je 2026-02-01, preden ga poskusite uporabiti s Temporal.
Oblikovanje Ko imate predmet Moment ali Temporal, ga boste verjetno kdaj želeli pretvoriti v oblikovani niz. To je primer, ko je Moment nekoliko bolj jedrnat. Metodo oblike predmeta pokličete z nizom žetonov, ki opisujejo želeno obliko datuma. const datum = moment();
console.log(date.format('MM/DD/LLLL')); // 22. 2. 2026
console.log(date.format('MMMM Do LLLL, h:mm:ss a')); // 22. februar 2026, 20:18:30
Po drugi strani pa Temporal zahteva, da ste nekoliko bolj natančni. Začasni objekti, kot je Instant, imajo metodo toLocaleString, ki sprejema različne možnosti oblikovanja, določene kot lastnosti predmeta.
const datum = Temporal.Now.instant();
// brez argumentov bomo dobili privzeto obliko za trenutno področno nastavitev console.log(date.toLocaleString()); // 22. 2. 2026, 20:23:36 (ob predpostavki, da je jezik en-US)
// posredovanje možnosti oblikovanja za ustvarjanje niza oblikovanja po meri console.log(date.toLocaleString('en-US', { mesec: 'dolg', dan: 'numeric', leto: 'numeric', ura: '2-mestno', minuta: '2-mestno' })); // 22. februar 2026 ob 20.23
// posredujte samo polja, ki jih želite v formatnem nizu console.log(date.toLocaleString('en-US', { mesec: 'kratek', dan: 'numeric' })); // 22. februar
Začasno oblikovanje datuma dejansko uporablja API Intl.DateTimeFormat (ki je že na voljo v sodobnih brskalnikih) pod pokrovom. To pomeni, da lahko ustvarite objekt DateTimeFormat za večkratno uporabo s svojimi možnostmi oblikovanja po meri, nato pa začasne predmete posredujete njegovi metodi oblikovanja. Zaradi tega ne podpira formatov datumov po meri, kot jih ima Moment. Če potrebujete nekaj takega, kot je 'Q1 2026' ali drugo specializirano oblikovanje, boste morda potrebovali kodo za oblikovanje datuma po meri ali posegli po knjižnici drugega proizvajalca. const formatter = new Intl.DateTimeFormat('en-US', { mesec: '2-mestno', dan: '2-mestno', leto: 'numeric' });
const datum = Temporal.Now.instant(); console.log(formatter.format(datum)); // 22. 2. 2026
Momentove žetone za oblikovanje je enostavneje napisati, vendar niso prijazni do krajev. Oblika niza "trdo kodo", kot je vrstni red mesec/dan. Prednost uporabe konfiguracijskega objekta, kot to počne Temporal, je, da se bo samodejno prilagodil kateri koli dani lokalni nastavitvi in uporabil pravilno obliko. const datum = Temporal.Now.instant();
const formatOptions = { mesec: 'numeric', dan: 'numeric', leto: 'numeric' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22. 2. 2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22. 2. 2026
Datumski izračuni V mnogih aplikacijah boste morali na koncu opraviti nekaj izračunov na datum. Morda boste želeli dodati ali odšteti enote časa (dneve, ure, sekunde itd.). Na primer, če imate trenutni datum, boste morda želeli uporabniku prikazati datum čez 1 teden. Objekti Moment imajo metode, kot sta seštevanje in odštevanje, ki izvajajo te operacije. Te funkcije sprejmejo vrednost in enoto, na primer: add(7, 'days'). Ena zelo pomembna razlika med Moment in Temporal pa je, da se pri izvajanju teh datumskih izračunov osnovni objekt spremeni in njegova prvotna vrednost se izgubi. const zdaj = moment();
console.log(zdaj); // Trenutek<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dni'); console.log(naslednjiTeden); // Trenutek<2026-03-03T20:08:36-05:00>
// Razumem - izvirni objekt je bil mutiran console.log(zdaj); // Trenutek<2026-03-03T20:08:36-05:00>
Če želite preprečiti izgubo izvirnega datuma, lahko pokličete klon na objektu Trenutek, da ustvarite kopijo. konst zdaj= moment(); const nextWeek = now.clone().add(7, 'dni');
console.log(zdaj); // Trenutek<2026-02-24T20:12:55-05:00>
console.log(naslednjiTeden); // Trenutek<2026-03-03T20:12:55-05:00>
Po drugi strani pa so začasni objekti nespremenljivi. Ko ustvarite predmet, kot je Instant, PlainDate in tako naprej, se vrednost tega predmeta ne bo nikoli spremenila. Začasni predmeti imajo tudi metode seštevanja in odštevanja. Temporal je nekoliko izbirčen glede tega, katere časovne enote je mogoče dodati posameznim vrstam predmetov. Na primer, ne morete dodati dni v instant:
const zdaj = Temporal.Now.instant(); const nextWeek = now.add({dni: 7}); // RangeError: Časovna napaka: Največja enota ne more biti datumska enota
To je zato, ker Instant objekti predstavljajo določeno časovno točko v UTC in so neodvisni od koledarja. Ker se lahko dolžina dneva spremeni glede na pravila časovnega pasu, kot je poletni čas, ta izračun ni na voljo v instantnem načinu. Vendar pa lahko to operacijo izvedete na drugih vrstah predmetov, kot je PlainDateTime: const zdaj = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24. 2. 2026, 20:23:59
const nextWeek = now.add({dni: 7});
// Upoštevajte, da izvirni PlainDateTime ostane nespremenjen console.log(now.toLocaleString()); // 24. 2. 2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3.3.2026, 20:23:59
Izračunate lahko tudi, koliko časa je med dvema trenutnima ali časovnima objektoma. Pri Momentovi funkciji diff morate zagotoviti enoto za razdrobljenost, sicer bo vrnila razliko v milisekundah. const datum1 = trenutek ('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(datum2.diff(datum1)); // 91800000
console.log(datum2.diff(datum1, 'dnevi')); // 1
Če želite to narediti s temporalnim objektom, lahko drug časovni objekt posredujete njegovim metodam do ali od. To vrne objekt Temporal.Duration, ki vsebuje informacije o časovni razliki. Objekt Trajanje ima lastnosti za vsako komponento razlike in lahko ustvari tudi niz trajanja ISO 8601, ki predstavlja časovno razliko.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// largeUnit podaja največjo enoto časa za predstavitev // pri izračunu trajanja const diff = date2.since(date1, { largeUnit: 'dan' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (niz trajanja ISO 8601: 1 dan, 1 ura, 30 minut)
Primerjava datumov in ur Tako Moment kot Temporal vam omogočata primerjavo datumov in ur, da ugotovite, kateri je pred drugim, vendar uporabite različne pristope z API-jem. Moment ponuja metode, kot so isBefore, isAfter in isSame za primerjavo dveh objektov Moment. const datum1 = trenutek ('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(datum1.isBefore(datum2)); // res
Temporal uporablja metodo statične primerjave za izvedbo primerjave med dvema predmetoma iste vrste. Vrne -1, če je prvi datum pred drugim, 0, če sta enaka, ali 1, če je prvi datum za drugim. Naslednji primer prikazuje, kako primerjati dva predmeta PlainDate. Oba argumenta za Temporal.PlainDate.compare morata biti objekta PlainDate.
const date1 = Temporal.PlainDate.from({ leto: 2026, mesec: 2, dan: 24 }); const date2 = Temporal.PlainDate.from({ leto: 2026, mesec: 3, dan: 24 });
// datum1 je pred datumom2, torej -1 console.log(Temporal.PlainDate.compare(datum1, date2));
// Napaka, če poskušamo primerjati dva predmeta različnih vrst console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Časovna napaka: Na voljo so neveljavna polja PlainDate.
Zlasti to olajša kronološko razvrščanje niza časovnih objektov. // Matrika objektov Temporal.PlainDate const datumi = [ ... ];
// uporabi Temporal.PlainDate.compare kot primerjalno funkcijo dates.sort(Temporal.PlainDate.compare);
Pretvorbe časovnih pasov Osnovna knjižnica Moment ne podpira pretvorb časovnih pasov. Če potrebujete to funkcionalnost, morate namestiti tudi paket moment-timezone. Ta paket ni pretresljiv, zato lahko znatno poveča vašo velikost paketa. Ko namestite moment-timezone, lahko objekte Moment pretvorite v različne časovne pasove z metodo tz. Kot pri drugih operacijah Moment tudi to mutira osnovnopredmet. // Ob predpostavki vzhodnega ameriškega časa const zdaj = moment(); console.log(zdaj); // Trenutek<2026-02-28T20:08:20-05:00>
// Pretvori v pacifiški čas. // Prvotni vzhodni čas je izgubljen. now.tz('Amerika/Los_Angeles'); console.log(zdaj); // Trenutek<2026-02-28T17:08:20-08:00>
Funkcionalnost časovnega pasu je vgrajena v Temporal API pri uporabi objekta Temporal.ZonedDateTime. Ti objekti vključujejo metodo withTimeZone, ki vrne nov ZonedDateTime, ki predstavlja isti trenutek v času, vendar v podanem časovnem pasu. // Spet ob predpostavki vzhodnega časa ZDA const zdaj = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28. 2. 2026, 20:12:02 EST
// Pretvori v pacifiški čas const nowPacific = now.withTimeZone('Amerika/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28. 2. 2026, 17:12:02 PST
// Prvotni objekt ostane nespremenjen console.log(now.toLocaleString()); // 28. 2. 2026, 20:12:02 EST
Opomba: Oblikovane vrednosti, ki jih vrne toLocaleString, so, kot pove ime, odvisne od področne nastavitve. Vzorčna koda je bila razvita v en-US jeziku, zato je oblika takšna: 2/28/2026, 17:12:02 PST. V drugem lokalu je to lahko drugače. Na primer, v lokalni nastavitvi en-GB bi dobili nekaj takega kot 28/2/2026, 17:12:02 GMT-8. Preoblikovanje v resničnem svetu Recimo, da gradimo aplikacijo za razporejanje dogodkov po časovnih pasovih. Del te aplikacije je funkcija getEventTimes, ki sprejme niz ISO 8601, ki predstavlja čas in datum dogodka, lokalni časovni pas in ciljni časovni pas. Funkcija ustvari oblikovane časovne in datumske nize za dogodek v obeh časovnih pasovih. Če funkcija prejme vhodni niz, ki ni veljaven časovni/datumski niz, bo sprožila napako. Tukaj je prvotna izvedba z uporabo Momenta (zahteva tudi uporabo paketa moment-timezone).
uvozi trenutek iz 'moment-timezone';
funkcija getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, LLLL, h:mm:ss a z';
// 1. Ustvarite začetni trenutek v časovnem pasu uporabnika const eventTime = moment.tz( inputString, moment.ISO_8601, // Pričakujte niz ISO 8601 res, // Strogo razčlenjevanje userTimeZone );
// Vrne napako, če inputString ne predstavlja veljavnega datuma if (!eventTime.isValid()) { vrzi novo napako ('Neveljaven vnos datuma/časa'); }
// 2. Izračunajte ciljni čas // KRITIČNO: Moramo klonirati, sicer se 'eventTime' za vedno spremeni! const targetTime = eventTime.clone().tz(targetTimeZone);
return { lokalno: eventTime.format(timeFormat), cilj: targetTime.format(timeFormat), }; }
const urnik = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Evropa/London', );
console.log(schedule.local); // 5. marec 2026, 15:00:00 EST
console.log(schedule.target); // 5. marec 2026, 20:00:00 GMT
V tem primeru uporabljamo pričakovano obliko datuma ISO 8601, ki je koristno vgrajena v Moment. Uporabljamo tudi strogo razčlenjevanje, kar pomeni, da Moment ne bo poskušal ugibati z datumskim nizom, ki se ne ujema z obliko. Če je posredovan datumski niz, ki ni ISO, bo to povzročilo neveljaven datumski objekt in sprožili bomo napako. Časovna izvedba je videti podobna, vendar ima nekaj ključnih razlik.
funkcija getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Razčlenite vnos neposredno v instant in nato ustvarite // ZonedDateTime v uporabnikovem območju. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Pretvori v ciljno območje // To samodejno vrne NOV predmet; 'eventTime' je varen. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Oblikujte z uporabo Intl (vgrajeno) možnosti const = { leto: 'numeric', mesec: 'kratek', dan: 'numeric', ura: 'numeric', minuta: '2-mestno', drugo: '2-mestno', timeZoneName: 'kratek' };
return { lokalno: eventTime.toLocaleString(navigator.language, možnosti), cilj: targetTime.toLocaleString(navigator.language, možnosti) }; }
const urnik = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Evropa/London', );
console.log(schedule.local); // 5. marec 2026, 15:00:00 EST
console.log(schedule.target); // 5. marec 2026, 20:00:00 GMT
Pri Momentu moramo eksplicitno podati formatni niz za nastale datumske nize. Ne glede na lokacijo ali jezik uporabnika bodo časi dogodkov vedno oblikovani kot 5. marec 2026, 3:00:00popoldan EST. Prav tako nam ni treba izrecno vrniti izjeme. Če je v Temporal.Instant.from posredovan neveljaven niz, bo Temporal namesto nas vrgel izjemo. Upoštevati je treba, da je tudi s strogim razčlenjevanjem različica Moment še vedno bolj prizanesljiva. Temporal zahteva odmik časovnega pasu na koncu niza. Upoštevati morate tudi, da ker uporabljamo navigator.language, se bo ta koda izvajala samo v okolju brskalnika, saj navigator ni definiran v okolju Node.js. Začasna izvedba uporablja trenutne področne nastavitve brskalnika (navigator.language), tako da bo uporabnik samodejno dobil čas dogodkov, oblikovan v svojem lokalnem časovnem formatu. V lokalni nastavitvi en-US je to 5. marec 2026, 15:00:00 EST. Če pa je uporabnik na primer v Londonu, bodo časi dogodkov oblikovani kot 5. marec 2026, 15:00:00 GMT-5. Povzetek
Akcija Moment.js Časovno Trenutni čas trenutek() Temporal.Now.zonedDateTimeISO() Razčlenjevanje ISO trenutek (str) Temporal.Instant.from(str) Dodajte čas .add(7, 'dni') (mutira) .add({ dni: 7 }) (nov predmet) Razlika .diff(other, 'ure') .od(drugo).ure Časovni pas .tz('Območje/Ime') .withTimeZone('Območje/Ime')
Na prvi pogled je razlika morda nekoliko drugačna (in v primeru Temporal včasih bolj besedna in strožja) sintaksa, vendar obstaja več ključnih prednosti uporabe Temporal pred Moment.js:
Biti bolj nazoren pomeni manj presenečenj in nenamernih napak. Moment se morda zdi bolj prizanesljiv, vendar vključuje "ugibanje", ki lahko včasih povzroči napačne datume. Če Temporal daste nekaj neveljavnega, vrže napako. Če se koda izvaja, veste, da imate veljaven datum. Moment lahko znatno poveča paket aplikacij, zlasti če uporabljate paket moment-timezone. Temporal ne doda ničesar (ko je poslano v vaše ciljne brskalnike). Nespremenljivost vam daje zaupanje, da ne boste nikoli izgubili ali prepisali podatkov pri izvajanju pretvorb datumov in operacij. Različne predstavitve časa (Instant, PlainDateTime, ZonedDateTime), odvisno od vaših zahtev, pri čemer je Moment vedno ovoj okrog časovnega žiga UTC. Temporal uporablja API-je Intl za oblikovanje datuma, kar pomeni, da imate lahko oblikovanje, ki upošteva področne nastavitve, ne da bi morali izrecno določiti žetone.
Opombe o Polyfillu Kot smo že omenili, je na voljo Temporal polyfill, ki se distribuira kot paket npm z imenom @js-temporal/polyfill. Če želite danes uporabljati Temporal, boste potrebovali ta polifill za podporo brskalnikov, kot je Safari, ki še niso poslali API-ja. Slaba novica pri tem je, da bo povečala vašo velikost svežnja. Dobra novica je, da še vedno doda bistveno manj kot trenutek ali časovni pas trenutka. Tukaj je primerjava velikosti paketov, ki jih poroča Bundlephobia.com, spletno mesto, ki predstavlja informacije o velikostih paketov npm (kliknite ime vsakega paketa, da si ogledate analizo Bundlephobia):
Paket Pomanjšano Pomanjšano in gzipano @js-temporal/polyfill 154,1 kB 44,1 kB trenutek 294,4 kB 75,4 kB trenutek-časovni pas 1 MB 114,2 kB
Polyfill je imel v preteklosti tudi nekaj težav z zmogljivostjo v zvezi z uporabo pomnilnika in v času pisanja tega članka velja, da je v alfa stanju. Zaradi tega ga morda ne boste želeli uporabljati v proizvodnji, dokler ne doseže bolj zrelega stanja. Druga dobra novica je, da upamo, da polyfill ne bo potreben še dolgo (seveda, razen če potrebujete podporo za starejše brskalnike). V času pisanja je bil Temporal na voljo v brskalnikih Chrome, Edge in Firefox. V brskalniku Safari še ni povsem pripravljen, čeprav se zdi, da je na voljo z zastavico za čas izvajanja v najnovejšem predogledu tehnologije.
