Peaaegu kõik JavaScriptis kirjutatud rakendused töötavad teatud määral kellaaegade või kuupäevadega. Alguses piirdus see sisseehitatud kuupäeva API-ga. See API sisaldab põhifunktsioone, kuid selle võimekus on üsna piiratud. Kolmandate osapoolte teegid, nagu Moment.js, ja hilisemad sisseehitatud API-d, nagu Intl API-d ja uus Temporal API, lisavad kellaaegade ja kuupäevadega töötamisele palju suuremat paindlikkust. Momenti tõus ja langus.js Moment.js on JavaScripti teek, millel on võimsad utiliidid kellaaegade ja kuupäevadega töötamiseks. See sisaldab Date API-st puuduvad funktsioonid, nagu ajavööndi manipuleerimine, ja muudab paljud tavalised toimingud lihtsamaks. Moment sisaldab ka kuupäevade ja kellaaegade vormindamise funktsioone. Sellest sai laialdaselt kasutatav raamatukogu paljudes erinevates rakendustes. Siiski oli ka Momendil omajagu probleeme. See on suur raamatukogu ja võib oluliselt suurendada rakenduse kogumi suurust. Kuna teek ei toeta puude raputamist (kaasaegsete komplekteerijate funktsioon, mis võib eemaldada teekide kasutamata osad), on kaasatud kogu Momenti teek, isegi kui kasutate ainult ühte või kahte selle funktsiooni. Teine Momenti probleem on asjaolu, et selle loodud objektid on muudetavad. Moment-objekti teatud funktsioonide kutsumisel on kõrvalmõjud ja see muudab selle objekti väärtust. See võib põhjustada ootamatut käitumist või vigu. 2020. aastal otsustasid Momendi hooldajad panna raamatukogu hooldusrežiimile. Uusi funktsioone ei arendata ja hooldajad soovitavad seda uute projektide jaoks mitte kasutada. On ka teisi JavaScripti kuupäevateeke, näiteks date-fns, kuid linnas on uus mängija, otse JavaScripti sisseehitatud API: Temporal. See on uus standard, mis täidab algse Date API augud ning lahendab mõned piirangud, mis Momentis ja teistes teekides leiduvad. Mis on ajaline? Temporal on uus kellaaja ja kuupäeva API, mis lisatakse ECMAScripti standardile, mis määratleb kaasaegse JavaScripti. 2026. aasta märtsi seisuga6 on see jõudnud TC39 protsessi 4. etappi (komitee, mis jälgib JavaScripti keele ettepanekuid ja täiendusi) ning lisatakse ECMAScripti spetsifikatsiooni järgmisse versiooni. Seda on juba rakendatud mitmetes brauserites: Chrome 144+ ja Firefox 139+, millele peaks peagi järgnema ka Safari. Polütäitmine on saadaval ka toetamata brauserite ja Node.js jaoks. Temporal API loob objekte, mis üldiselt esindavad ajahetki. Need võivad olla täisaja- ja kuupäevatemplid antud ajavööndis või olla "seinakella" aja üldine näide ilma ajavööndi või kuupäeva teabeta. Mõned Temporali põhifunktsioonid on järgmised:
Ajad kuupäevadega või ilma. Ajaline objekt võib kujutada kindlat kellaaega kindlal kuupäeval või kellaaega ilma kuupäevateabeta. Esitada saab ka konkreetse kuupäeva ilma kellaajata. Ajavööndi tugi. Ajalised objektid on täielikult ajavööndist teadlikud ja neid saab teisendada erinevatesse ajavöönditesse. Moment toetab ka ajavööndeid, kuid see nõuab täiendavat hetke-ajavööndi teeki. Muutumatus. Kui ajaline objekt on loodud, ei saa seda muuta. Ajaaritmeetika või ajavööndi teisendused ei muuda aluseks olevat objekti. Selle asemel genereerivad nad uue ajalise objekti. 1-põhine indekseerimine. Date API (nagu ka Moment) puhul on levinud vigade allikas see, et kuud on nullindekseeritud. See tähendab, et jaanuar on kuu 0, mitte kuu 1, nagu me kõik päriselus mõistame. Temporal parandab selle, kasutades 1-põhist indekseerimist – jaanuar on 1. kuu. See on brauserisse sisse ehitatud. Kuna Temporal on brauseris endas API, ei lisa see teie rakenduse kogumi suurusele midagi.
Samuti on oluline märkida, et kuupäeva API ei kao kuhugi. Kuigi Temporal asendab selle API, seda ei eemaldata ega aegunud. Paljud rakendused puruneksid, kui brauserid eemaldaksid ootamatult kuupäeva API. Siiski pidage meeles, et Momenti peetakse nüüd hooldusrežiimis pärandprojektiks. Ülejäänud artiklis vaatleme mõningaid "retsepte" hetkepõhise koodi viimiseks uude ajutisse API-sse. Alustame ümbertöötamist! Kuupäeva ja kellaaja objektide loomine Enne kui saame kuupäevade ja kellaaegadega manipuleerida, peame looma neid esindavad objektid. Praegust kuupäeva ja kellaaega esindava hetkeobjekti loomiseks kasutage hetkefunktsiooni. const now = moment(); console.log(now); // Hetk<2026-02-18T21:26:29-05:00>
Seda objekti saab nüüd vastavalt vajadusele vormindada või sellega manipuleerida.
// teisendada UTC-ks //hoiatus: See muudab objekti Moment ja paneb selle UTC-režiimi! console.log(now.utc()); // Hetk<2026-02-19T02:26:29Z>
// vormindatud stringi printimine – pange tähele, et see kasutab praegu UTC aega console.log(now.format('KK/PP/AAAA hh:mm:ss a')); // 19.02.2026 02:27:07 am
Peamine asi, mida Momenti puhul meeles pidada, on see, et hetkeobjekt sisaldab alati teavet kellaaja ja kuupäeva kohta. Kui teil on vaja töötada ainult ajateabega, on see tavaliselt hea, kuid see võib põhjustada ootamatut käitumist sellistes olukordades nagu suveaeg või liigaastad, kus kuupäev võib aja arvutamist mõjutada. Ajaline on paindlikum. Praegust kuupäeva ja kellaaega esindava objekti saate luua, luues objekti Temporal.Instant. See tähistab ajahetke, mis on määratletud aja järgi alates "ajastust" (1. jaanuari 1970 kesköö UTC). Temporal suudab seda hetke nanosekundilise täpsusega ajas viidata. const now = Temporal.Now.instant();
// vt töötlemata nanosekundeid ajastust alates console.log(now.epochNanoconds); // 1771466342612000000n
// vorming UTC jaoks console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// vorming konkreetse ajavööndi jaoks console.log(now.toString({ ajavöönd: 'Ameerika/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant-objekte saab luua ka kindla kellaaja ja kuupäeva jaoks, kasutades staatilisest meetodist.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Instanti vormindamine kohaliku ajavööndi järgi. Pange tähele, et see juhib ainult // vorming – see ei muteeri objekti nagu moment.utc teeb. console.log(myInstant.toString({ ajavöönd: 'Ameerika/New_York' })); // 2026-02-18T21:10:00-05:00
Saate luua ka muud tüüpi ajalisi objekte, sealhulgas:
Temporal.PlainDate: kuupäev ilma kellaaja teabeta. Temporal.PlainTime: kellaaeg ilma kuupäevateabeta. Temporal.ZonedDateTime: kuupäev ja kellaaeg kindlas ajavööndis.
Kõigil neist on meetod from, mida saab kutsuda kuupäeva ja/või kellaaega täpsustava objektiga või sõelutava kuupäevastringiga. // Lihtsalt kohting const today = Temporal.PlainDate.from({ aasta: 2026, kuu: 2, // pange tähele, et me kasutame veebruariks 2 päev: 18 }); console.log(today.toString()); // 2026-02-18
// Lihtsalt üks aeg const lunchTime = Temporal.PlainTime.from({ tund: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Kuupäev ja kellaaeg USA idapoolses ajavööndis const dueAt = Temporal.ZonedDateTime.from({ ajavöönd: "Ameerika/New_York", aasta: 2026, kuu: 3, päev: 1, tund: 12, minut: 0, teine: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Ameerika/New_York]
Parsimine Oleme käsitlenud kuupäeva ja kellaaja teabe programmilist loomist. Vaatame nüüd sõelumist. Parsimine on üks valdkond, kus Moment on paindlikum kui sisseehitatud Temporal API. Kuupäeva stringi saate sõeluda, edastades selle hetkefunktsioonile. Ühe argumendi korral ootab Moment ISO-kuupäeva stringi, kuid võite kasutada ka alternatiivseid vorminguid, kui esitate teise argumendi, mis määrab kasutatava kuupäevavormingu.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = hetk('21/26 9:00:00', 'K/D/AA h:mm:ss');
console.log(isoDate); // Hetk<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Hetk<2026-02-21T09:00:00-05:00>
Vanemates versioonides tegi Moment parima oletuse, et sõeluda suvaliselt vormindatud kuupäevastringi. See võib viia ettearvamatute tulemusteni. Kas näiteks 02-03-2026 on 2. veebruar või 3. märts? Sel põhjusel kuvavad Momenti uuemad versioonid silmapaistva kulumishoiatuse, kui seda kutsutakse ilma ISO-vormingus kuupäevastringita (kui pole antud ka teist argumenti soovitud vorminguga). Temporal sõelub ainult spetsiaalselt vormindatud kuupäevastringi. String peab ühilduma ISO 8601 vorminguga või selle laiendiga RFC 9557. Kui mitteühilduv kuupäevastring edastatakse meetodile from, kuvab Temporal teate RangeError.
// RFC 9557 kuupäevastringi kasutamine const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[Ameerika/New_York]'); console.log(myDate.toString({ ajavöönd: 'Ameerika/New_York' })); // 2026-02-21T09:00:00-05:00
// Tundmatu kuupäevastringi kasutamine const otherDate = Temporal.Instant.from('21/26 9:00:00'); // RangeError: ajaline viga: aasta väärtuse sõelumisel on kehtetu märk.
Kuupäeva stringi täpsed nõuded sõltuvad sellest, millist tüüpi ajalist objekti loote. Ülaltoodud näites nõuab Temporal.Instant täielikku ISO-d8601 või RFC 9557 kuupäevastring, mis määrab kuupäeva ja kellaaja ajavööndi nihkega, kuid saate luua ka PlainDate või PlainTime objekte, kasutades ainult kuupäevavormingu alamhulka. 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
Pange tähele, et need stringid peavad siiski vastama oodatud vormingule, vastasel juhul kuvatakse tõrge.
// Mitteühilduvate ajastringide kasutamine. Need kõik tekitavad RangeErrori. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Professionaalsete näpunäide. Mitte-ISO-stringide käsitlemine Kuna Temporal seab esikohale töökindluse, ei püüa see ära arvata stringi vormingut, nagu 02-01-2026. Kui teie andmeallikas kasutab selliseid stringe, peate enne selle kasutamist koos Temporaliga väärtuste ümberkorraldamiseks ISO-stringiks, näiteks 2026-02-01, tegema stringidega manipuleerimist.
Vormindamine Kui teil on hetk või ajaline objekt, soovite selle tõenäoliselt mingil hetkel teisendada vormindatud stringiks. See on näide, kus hetk on pisut napisõnalisem. Kutsute objekti vormingumeetodit märkide jadaga, mis kirjeldavad soovitud kuupäevavormingut. const date = hetk();
console.log(date.format('KK/PP/AAAA')); // 22.02.2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 22. veebruar 2026, 20:18:30
Teisest küljest nõuab Temporal, et oleksite pisut sõnasõnalisem. Ajalistel objektidel, näiteks Instantil, on meetod toLocaleString, mis aktsepteerib mitmesuguseid objekti omadustena määratud vormindamisvalikuid.
const date = Temporal.Now.instant();
// ilma argumentideta saame praeguse lokaadi vaikevormingu console.log(date.toLocaleString()); // 22.02.2026, 20:23:36 (eeldades, et lokaat on en-US)
// edastage vormingusuvandid kohandatud vormingustringi genereerimiseks console.log(date.toLocaleString('en-US', { kuu: "pikk", päev: 'numbriline', aasta: 'numbriline', tund: '2-kohaline', minut: '2-kohaline' })); // 22. veebruar 2026, kell 20:23
// edastab vormingustringis ainult soovitud väljad console.log(date.toLocaleString('en-US', { kuu: 'lühike', päev: 'numbriline' })); // 22. veebr
Ajaline kuupäevavormindus kasutab tegelikult Intl.DateTimeFormat API-d (mis on tänapäevastes brauserites juba hõlpsasti saadaval) kapoti all. See tähendab, et saate oma kohandatud vormindamisvalikutega luua korduvkasutatava DateTimeFormat objekti ja seejärel edastada ajalised objektid selle vormindamismeetodile. Seetõttu ei toeta see kohandatud kuupäevavorminguid nagu Moment. Kui vajate midagi nagu „2026. aasta 1. kvartal” või muud spetsiaalset vormingut, võite vajada kohandatud kuupäevavormingu koodi või jõuda kolmanda osapoole teeki. const vormindaja = new Intl.DateTimeFormat('en-US', { kuu: '2-kohaline', päev: '2-kohaline', aasta: 'numbriline' });
const date = Temporal.Now.instant(); console.log(formater.format(date)); // 22.02.2026
Momenti vormindamismärke on lihtsam kirjutada, kuid need pole lokaadisõbralikud. Vorming stringid "kõvakoodi" asjad, nagu kuu/päeva järjestus. Konfiguratsiooniobjekti kasutamise eeliseks, nagu seda teeb Temporal, on see, et see kohandub automaatselt mis tahes lokaadiga ja kasutab õiget vormingut. const date = Temporal.Now.instant();
const formatOptions = { kuu: 'numbriline', päev: 'numbriline', aasta: 'numbriline' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22.02.2026
console.log(date.toLocaleString('en-GB', formOptions)); // 22/02/2026
Kuupäevade arvutused Paljude rakenduste puhul peate mõnel kuupäeval arvutusi tegema. Võib-olla soovite lisada või lahutada ajaühikuid (päevad, tunnid, sekundid jne). Näiteks kui teil on praegune kuupäev, võiksite kasutajale näidata kuupäeva, mis on 1 nädala pärast. Hetkeobjektidel on sellised toimingud nagu liitmine ja lahutamine. Need funktsioonid võtavad väärtuse ja ühiku, näiteks: add(7, 'days'). Üks väga oluline erinevus Momenti ja Temporal vahel on aga see, et nende kuupäevaarvutuste tegemisel muudetakse alusobjekti ja selle algne väärtus kaob. const now = moment();
console.log(now); // Hetk<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log(nextWeek); // Hetk<2026-03-03T20:08:36-05:00>
// Gotcha - algne objekt oli muteerunud console.log(now); // Hetk<2026-03-03T20:08:36-05:00>
Algse kuupäeva kaotamise vältimiseks võite koopia loomiseks kutsuda objektil Moment klooni. konst nüüd= moment(); const nextWeek = now.clone().add(7, 'päevad');
console.log(now); // Hetk<2026-02-24T20:12:55-05:00>
console.log(nextWeek); // Hetk<2026-03-03T20:12:55-05:00>
Teisest küljest on ajalised objektid muutumatud. Kui olete loonud objekti, nagu Instant, PlainDate jne, ei muutu selle objekti väärtus kunagi. Ajalistel objektidel on ka liitmise ja lahutamise meetodid. Temporal on veidi valiv selle osas, milliseid ajaühikuid saab millistele objektitüüpidele lisada. Näiteks ei saa te Instantile päevi lisada.
const now = Temporal.Now.instant(); const nextWeek = now.add({ päeva: 7 }); // RangeError: ajaline viga: suurim ühik ei saa olla kuupäevaühik
Selle põhjuseks on asjaolu, et Instant-objektid esindavad UTC-s kindlat ajahetke ja on kalendriagnostilised. Kuna päeva pikkus võib ajavööndi reeglite (nt suveaja) alusel muutuda, pole see arvutus Instanti puhul saadaval. Seda toimingut saate siiski teha muud tüüpi objektidega, näiteks PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
const nextWeek = now.add({ päeva: 7 });
// Pange tähele, et algne PlainDateTime jääb muutumatuks console.log(now.toLocaleString()); // 24.02.2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Samuti saate arvutada, kui palju aega on kahe hetke- või ajaobjekti vahel. Funktsiooni Moment diff puhul peate määrama detailsuse ühiku, vastasel juhul tagastab see erinevuse millisekundites. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date2.diff(kuupäev1)); // 91800000
console.log(date2.diff(kuupäev1, 'päevad')); // 1
Ajutise objektiga selleks saate edastada teise ajutise objekti selle meetoditele kuni või kuna. See tagastab objekti Temporal.Duration, mis sisaldab teavet ajavahe kohta. Objektil Kestus on atribuudid erinevuse iga komponendi jaoks ja see võib genereerida ka ISO 8601 kestuse stringi, mis tähistab ajavahet.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// largeUnit määrab suurima esitatava ajaühiku // kestuse arvutamisel const diff = date2.since(kuupäev1, { suurim Ühik: 'päev' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 kestuse string: 1 päev, 1 tund, 30 minutit)
Kuupäevade ja kellaaegade võrdlemine Mõlemad Moment ja Temporal võimaldavad teil võrrelda kuupäevi ja kellaaegu, et teha kindlaks, kumb on enne teist, kuid kasutada API-ga erinevaid lähenemisviise. Moment pakub selliseid meetodeid nagu isBefore, isAfter ja isSame, et võrrelda kahte hetkeobjekti. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // tõsi
Temporal kasutab kahe sama tüüpi objekti võrdlemiseks staatilist võrdlusmeetodit. Tagastab -1, kui esimene kuupäev tuleb enne teist, 0, kui need on võrdsed, või 1, kui esimene kuupäev tuleb pärast teist. Järgmine näide näitab, kuidas võrrelda kahte PlainDate objekti. Mõlemad argumendid Temporal.PlainDate.compare peavad olema PlainDate objektid.
const date1 = Temporal.PlainDate.from({aasta: 2026, kuu: 2, päev: 24 }); const date2 = Temporal.PlainDate.from({aasta: 2026, kuu: 3, päev: 24 });
// kuupäev1 tuleb enne kuupäeva2, seega -1 console.log(Temporal.PlainDate.compare(kuupäev1, kuupäev2));
// Viga, kui proovime võrrelda kahte erinevat tüüpi objekti console.log(Temporal.PlainDate.compare(kuupäev1, Temporal.Now.instant())); // Tüübiviga: ajaline viga: antud väljad PlainDate on valed.
Eelkõige muudab see ajaliste objektide massiivi kronoloogiliseks sortimise lihtsaks. // Temporal.PlainDate objektide massiiv const dates = [ ... ];
// kasutage võrdlusfunktsioonina Temporal.PlainDate.compare kuupäevad.sort (Temporal.PlainDate.compare);
Ajavööndi teisendused Momenti põhiteek ei toeta ajavööndi teisendamist. Kui vajate seda funktsiooni, peate installima ka hetke-ajavööndi paketi. See pakett ei ole puude raputatav ja seetõttu võib see teie kimbu suurust oluliselt suurendada. Kui olete hetke-ajavööndi installinud, saate tz-meetodiga teisendada hetkeobjektid erinevatesse ajavöönditesse. Nagu ka teiste Momenti operatsioonide puhul, muudab see alustobjektiks. // USA idaaja järgi const now = moment(); console.log(now); // Hetk<2026-02-28T20:08:20-05:00>
// Teisenda Vaikse ookeani aeg. // Algne idaaeg on kadunud. now.tz('Ameerika/Los_Angeles'); console.log(now); // Hetk<2026-02-28T17:08:20-08:00>
Objekti Temporal.ZonedDateTime kasutamisel on ajavööndi funktsionaalsus sisse ehitatud Temporal API-sse. Need objektid sisaldavad meetodit withTimeZone, mis tagastab uue ZonedDateTime, mis tähistab sama ajahetke, kuid määratud ajavööndis. // Jällegi USA idaaja järgi const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28.02.2026, 20:12:02 EST
// Teisenda Vaikse ookeani aeg const nowPacific = now.withTimeZone('Ameerika/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28.02.2026, 17:12:02 PST
// Algne objekt jääb muutumatuks console.log(now.toLocaleString()); // 28.02.2026, 20:12:02 EST
Märkus. ToLocaleStringi tagastatud vormindatud väärtused sõltuvad, nagu nimigi ütleb, lokaadist. Näidiskood töötati välja USA lokaadis, seega on vorming järgmine: 28.02.2026, 17:12:02 PST. Mõnes teises lokaadis võib see olla erinev. Näiteks en-GB lokaadis saate midagi sellist nagu 28/2/2026, 17:12:02 GMT-8. Reaalmaailma ümberfaktorimine Oletame, et loome rakendust sündmuste ajastamiseks ajavööndites. Osa sellest rakendusest on funktsioon getEventTimes, mis võtab ISO 8601 stringi, mis tähistab sündmuse kellaaega ja kuupäeva, kohalikku ajavööndit ja sihtajavööndit. Funktsioon loob mõlemas ajavööndis sündmuse jaoks vormindatud kellaaja ja kuupäeva stringid. Kui funktsioonile antakse sisendstring, mis ei ole kehtiv kellaaja/kuupäeva string, annab see veateate. Siin on algne teostus, mis kasutab Momenti (mis nõuab ka hetke-ajavööndi paketi kasutamist).
import hetk alates 'moment-timezone';
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'KKM D, YYYY, h:mm:ss a z';
// 1. Loo algushetk kasutaja ajavööndis const eventTime = moment.tz( inputString, moment.ISO_8601, // Oodake ISO 8601 stringi tõsi, // Range sõelumine userTimeZone );
// Kui inputString ei kujutanud kehtivat kuupäeva, esitab vea if (!eventTime.isValid()) { throw new Error('Vigane kuupäeva/kellaaja sisestus'); }
// 2. Arvutage sihtaeg // KRIITILINE: peame kloonima, muidu muutub sündmuse aeg igaveseks! const sihtaeg = sündmuseaeg.kloon().tz(sihtajavöönd);
return { kohalik: eventTime.format(timeFormat), sihtmärk: targetTime.format(timeFormat), }; }
const ajakava = getEventTimes( "2026-03-05T15:00-05:00", "Ameerika/New_York", "Euroopa/London", );
console.log(schedule.local); // 5. märts 2026, 15:00:00 EST
console.log(ajakava.sihtmärk); // 5. märts 2026, 20:00:00 GMT
Selles näites kasutame eeldatavat kuupäevavormingut ISO 8601, mis on Momenti kasulikult sisse ehitatud. Kasutame ka ranget sõelumist, mis tähendab, et Moment ei püüa arvata kuupäevastringiga, mis ei vasta vormingule. Kui edastatakse mitte-ISO-kuupäeva string, annab see kehtetu kuupäevaobjekti ja kuvame vea. Ajutine rakendamine näeb välja sarnane, kuid sellel on mõned olulised erinevused.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Parsige sisend otse Instanti ja looge seejärel // ZonedDateTime kasutaja tsoonis. const instant = Temporal.Instant.from(inputString); const sündmuseaeg = instant.toZonedDateTimeISO(kasutajaajavöönd);
// 2. Teisenda sihttsooniks // See tagastab automaatselt UUE objekti; "EventTime" on ohutu. const sihtaeg = sündmuseaeg.ajavööndiga(sihtajavöönd);
// 3. Vormindamine Intl-iga (sisseehitatud) const suvandid = { aasta: 'numbriline', kuu: 'lühike', päev: 'numbriline', tund: 'numbriline', minut: '2-kohaline', teine: '2-kohaline', timeZoneName: 'short' };
return { local: eventTime.toLocaleString(navigator.language, options), sihtmärk: targetTime.toLocaleString(navigator.language, options) }; }
const ajakava = getEventTimes( "2026-03-05T15:00-05:00", "Ameerika/New_York", "Euroopa/London", );
console.log(graafik.local); // 5. märts 2026, 15:00:00 EST
console.log(ajakava.sihtmärk); // 5. märts 2026, 20:00:00 GMT
Momenti puhul peame selgesõnaliselt määrama saadud kuupäevastringide vormingustringi. Sõltumata kasutaja asukohast või lokaadist on sündmuste ajad alati vormindatud 5. märts 2026, 3:00:00pm EST. Samuti ei pea me selgesõnaliselt erandit tegema. Kui failile Temporal.Instant.from edastatakse kehtetu string, teeb Temporal meie jaoks erandi. Üks asi, mida tuleb märkida, on see, et isegi range sõelumisega on Momenti versioon siiski leebem. Ajaline nõuab ajavööndi nihet stringi lõpus. Samuti peaksite arvestama, et kuna me kasutame keelt navigator.language, töötab see kood ainult brauseri keskkonnas, kuna Node.js keskkonnas pole navigaatorit määratletud. Ajutine juurutus kasutab brauseri praegust lokaadi (navigator.language), nii et kasutaja saab sündmuste ajad automaatselt vormindatud kohaliku aja vormingus. USA-s on see 5. märts 2026, 15:00:00 EST. Kui aga kasutaja on näiteks Londonis, vormistatakse sündmuste ajad järgmiselt: 5. märts 2026, 15:00:00 GMT-5. Kokkuvõte
Tegevus Moment.js Ajaline Praegune aeg hetk () Temporal.Now.zonedDateTimeISO() ISO parsimine hetk (str) Temporal.Instant.from(str) Lisa aeg .add(7, 'days') (muteerib) .add({ päeva: 7 }) (uus objekt) Erinevus .diff(muu, 'tunnid') .alates(muud).tunnid Ajavöönd .tz('Tsoon/nimi') .withTimeZone('Tsoon/nimi')
Esmapilgul võib erinevus olla veidi erinev (ja Temporali puhul mõnikord paljusõnalisem ja rangem) süntaks, kuid Temporali kasutamisel on Moment.js-i ees mitmeid olulisi eeliseid:
Selgesõnalisem olemine tähendab vähem üllatusi ja soovimatuid vigu. Hetk võib tunduda leebem, kuid see hõlmab "arvamist", mis võib mõnikord põhjustada valesid kuupäevi. Kui annate Temporalile midagi kehtetut, annab see veateate. Kui kood töötab, teate, et teil on kehtiv kuupäev. Moment võib rakenduse kogumit oluliselt suurendada, eriti kui kasutate hetke-ajavööndi paketti. Temporal ei lisa midagi (kui see on teie sihtbrauserites tarnitud). Muutumatus annab teile kindlustunde, et kuupäevade teisendamise ja toimingute tegemisel te ei kaota ega kirjuta kunagi andmeid üle. Erinevad aja esitused (Instant, PlainDateTime, ZonedDateTime) olenevalt teie vajadustest, kus hetk on alati UTC ajatempli ümber. Temporal kasutab kuupäeva vormindamiseks Intl API-sid, mis tähendab, et saate kasutada lokaaditeadlikku vormingut, ilma et peaksite lubasid selgesõnaliselt määrama.
Märkused Polyfilli kohta Nagu varem mainitud, on saadaval Temporal polyfill, mida levitatakse npm-paketina nimega @js-temporal/polyfill. Kui soovite kasutada Temporali täna, vajate seda polütäitet, et toetada brausereid, nagu Safari, mis pole veel API-d tarninud. Halb uudis on see, et see suurendab teie kimbu suurust. Hea uudis on see, et see lisab siiski oluliselt vähem kui hetk või hetk-ajavöönd. Siin on kimpude suuruste võrdlus, nagu teatas veebisait Bundlephobia.com, mis pakub teavet npm pakendi suuruste kohta (Bundlephobia analüüsi vaatamiseks klõpsake iga paketi nimel):
pakett Vähendatud Minimeeritud ja gzipitud @js-temporal/polyfill 154,1 kB 44,1 kB hetk 294,4 kB 75,4 kB hetk-ajavöönd 1 MB 114,2 kB
Samuti on polüfillil ajalooliselt olnud mälukasutusega seotud jõudlusprobleeme ja selle kirjutamise ajal peetakse seda alfa-olekus. Seetõttu ei pruugi te soovida seda tootmises kasutada enne, kui see jõuab küpsemasse olekusse. Teine hea uudis on see, et loodetavasti pole polütäitmist enam kaua vaja (muidugi, kui teil pole vaja vanemaid brausereid toetada). Kirjutamise ajal tarniti Temporal Chrome'is, Edge'is ja Firefoxis. See pole Safaris veel päris valmis, kuigi tundub, et see on saadaval koos käitusaja lipuga uusimas tehnoloogia eelvaates.
