Szinte minden JavaScript-ben írt alkalmazás működik bizonyos minőségben időpontokkal vagy dátumokkal. Kezdetben ez a beépített Date API-ra korlátozódott. Ez az API magában foglalja az alapvető funkciókat, de meglehetősen korlátozott, mire képes. A harmadik féltől származó könyvtárak, mint például a Moment.js, és a későbbi beépített API-k, mint például az Intl API-k és az új Temporal API, sokkal rugalmasabbá teszik az idők és dátumok kezelését. The Rise and Fall Of Moment.js A Moment.js egy JavaScript-könyvtár, amely hatékony segédprogramokkal rendelkezik az idők és dátumok kezeléséhez. Tartalmazza az alapvető dátum API-ból hiányzó funkciókat, például az időzóna-manipulációt, és sok gyakori műveletet egyszerűbbé tesz. A Moment dátumok és időpontok formázására szolgáló funkciókat is tartalmaz. Széles körben használt könyvtár lett számos különféle alkalmazásban. Azonban a pillanatnak is megvolt a maga része a problémákban. Ez egy nagy könyvtár, és jelentősen növelheti az alkalmazás csomagméretét. Mivel a könyvtár nem támogatja a fa rázást (a modern kötegelők egyik jellemzője, amely képes eltávolítani a könyvtárak nem használt részeit), a teljes Moment könyvtár akkor is benne van, ha csak egy vagy kettő funkcióját használja. A Moment másik problémája az a tény, hogy az általa létrehozott objektumok változtathatók. Egy Moment objektum bizonyos függvényeinek meghívása mellékhatásokkal jár, és megváltoztatja az objektum értékét. Ez váratlan viselkedéshez vagy hibákhoz vezethet. 2020-ban a Moment fenntartói úgy döntöttek, hogy karbantartási üzemmódba kapcsolják a könyvtárat. Új funkciók fejlesztése nem történik, és a karbantartók azt javasolják, hogy ne használják új projektekhez. Vannak más JavaScript-dátumkönyvtárak, például a date-fns, de van egy új játékos a városban, egy közvetlenül a JavaScriptbe épített API: a Temporal. Ez egy új szabvány, amely kitölti az eredeti Date API lyukait, valamint megoldja a Momentben és más könyvtárakban található korlátozásokat. Mi az Időbeli? A Temporal egy új idő és dátum API, amelyet hozzáadunk az ECMAScript szabványhoz, amely meghatározza a modern JavaScriptet. 2026. márciusában6 elérte a TC39 folyamat 4. szakaszát (a JavaScript nyelv javaslatait és kiegészítését felügyelő bizottság), és az ECMAScript specifikáció következő verziójába fog belekerülni. Már több böngészőben is implementálták: Chrome 144+ és Firefox 139+, a Safari pedig várhatóan hamarosan következik. A nem támogatott böngészőkhöz és a Node.js-hez is elérhető a többkitöltés. A Temporal API objektumokat hoz létre, amelyek általában az idő pillanatait reprezentálják. Ezek lehetnek teljes idejű és dátumbélyegek egy adott időzónában, vagy lehetnek a „falióra” idő általános példányai időzóna- vagy dátuminformáció nélkül. A Temporal néhány fő funkciója:
Idők dátummal vagy anélkül. Az Időbeli objektumok egy adott időpontot jeleníthetnek meg egy adott dátumon, vagy dátuminformáció nélkül. Egy adott dátum, idő nélkül is ábrázolható. Az időzóna támogatása. Az időbeli objektumok teljes mértékben ismerik az időzónát, és különböző időzónák között konvertálhatók. A Moment támogatja az időzónákat is, de ehhez további pillanat-időzóna könyvtárra van szükség. Változatlanság. Az ideiglenes objektum létrehozása után nem módosítható. Az időaritmetikai vagy időzóna-konverziók nem módosítják a mögöttes objektumot. Ehelyett új Temporal objektumot generálnak. 1-alapú indexelés. A Date API (és a Moment) hibák gyakori forrása az, hogy a hónapok nulla indexeltek. Ez azt jelenti, hogy a január a 0. hónap, nem pedig az 1. hónap, ahogyan azt a való életben mindannyian értjük. A Temporal ezt az 1-alapú indexeléssel javítja – január az 1. hónap. Be van építve a böngészőbe. Mivel a Temporal egy API magában a böngészőben, semmit sem ad hozzá az alkalmazás csomagméretéhez.
Azt is fontos megjegyezni, hogy a Date API nem tűnik el. Bár a Temporal felülírja ezt az API-t, nem távolítják el vagy elavulják. Sok alkalmazás leállna, ha a böngészők hirtelen eltávolítanák a Date API-t. Ne feledje azonban, hogy a Moment karbantartási módban már örökölt projektnek számít. A cikk további részében megnézünk néhány „receptet” a Moment-alapú kódnak az új Temporal API-ba való áttelepítéséhez. Kezdjük az átalakítást! Dátum és idő objektumok létrehozása Mielőtt manipulálhatnánk a dátumokat és időpontokat, létre kell hoznunk az azokat reprezentáló objektumokat. Az aktuális dátumot és időt reprezentáló Moment objektum létrehozásához használja a pillanat függvényt. const most = pillanat(); console.log(now); // Pillanat<2026-02-18T21:26:29-05:00>
Ez az objektum most szükség szerint formázható vagy módosítható.
// konvertálni UTC-re //figyelmeztetés: Ez mutálja a Moment objektumot és UTC módba helyezi! console.log(now.utc()); // Pillanat<2026-02-19T02:26:29Z>
// formázott karakterlánc nyomtatása – vegye figyelembe, hogy ez most az UTC időt használja console.log(now.format('HH/NN/ÉÉÉÉ óó:pp:ss a')); // 02/19/2026 02:27:07 am
A legfontosabb dolog, amit meg kell jegyezni a Moment kapcsán, hogy a Moment objektum mindig tartalmaz információkat az időről és a dátumról. Ha csak az időinformációkkal kell dolgoznia, ez általában rendben van, de váratlan viselkedést okozhat olyan helyzetekben, mint a nyári időszámítás vagy a szökőév, ahol a dátum hatással lehet az időszámításra. Az időbeli rugalmasabb. Az aktuális dátumot és időt reprezentáló objektumot létrehozhat egy Temporal.Instant objektum létrehozásával. Ez a „korszak” óta eltelt idő (1970. január 1. éjfél, UTC) által meghatározott időpontot jelent. A Temporal nanoszekundumos pontossággal tudja időben hivatkozni erre a pillanatra. const now = Temporal.Now.instant();
// lásd a nyers nanoszekundumot a korszak óta console.log(now.epochNanosecunds); // 1771466342612000000n
// UTC formátum console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// formátum egy adott időzónához console.log(now.toString({ időzóna: 'Amerika/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant objektumok egy adott időpontra és dátumra is létrehozhatók a statikus metódussal.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// A pillanat formázása a helyi időzónában. Vegye figyelembe, hogy ez csak vezérli // a formázás - nem mutálja az objektumot, mint a moment.utc. console.log(myInstant.toString({ időzóna: 'Amerika/New_York' })); // 2026-02-18T21:10:00-05:00
Más típusú időbeli objektumokat is létrehozhat, például:
Temporal.PlainDate: Időinformáció nélküli dátum. Temporal.PlainTime: Dátuminformáció nélküli időpont. Temporal.ZonedDateTime: Dátum és idő egy adott időzónában.
Mindegyik rendelkezik egy from metódussal, amely meghívható egy dátumot és/vagy időt meghatározó objektummal, vagy egy elemzendő dátum karakterlánccal. // Csak egy randevú const today = Temporal.PlainDate.from({ év: 2026, hónap: 2, // vegye figyelembe, hogy februárban 2-t használunk nap: 18 }); console.log(ma.toString()); // 2026-02-18
// Csak egy idő const lunchTime = Temporal.PlainTime.from({ óra: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Dátum és idő az Egyesült Államok keleti időzónájában const dueAt = Temporal.ZonedDateTime.from({ időzóna: „Amerika/New_York”, év: 2026, hónap: 3, nap: 1, óra: 12, perc: 0, második: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amerika/New_York]
Elemzés Kitértünk a dátum- és időadatok programozott létrehozására. Most nézzük az elemzést. Az elemzés olyan terület, ahol a Moment rugalmasabb, mint a beépített Temporal API. Egy dátum karakterláncot úgy elemezhet, hogy átadja a pillanat függvénynek. Egyetlen argumentum esetén a Moment ISO-dátum karakterláncot vár, de alternatív formátumokat is használhat, ha megad egy második argumentumot, amely megadja a használt dátumformátumot.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = pillanat('2/21/26 9:00:00', 'H/N/YY h:mm:ss');
console.log(isoDate); // Pillanat<2026-02-21T09:00:00-05:00>
console.log(formázottDátum); // Pillanat<2026-02-21T09:00:00-05:00>
A régebbi verziókban a Moment a legjobb tippet adja az önkényesen formázott dátumkarakterlánc elemzéséhez. Ez megjósolhatatlan eredményekhez vezethet. Például 2026-03-02 február 2 vagy március 3? Emiatt a Moment újabb verziói jól látható elavulási figyelmeztetést jelenítenek meg, ha ISO formátumú dátumkarakterlánc nélkül hívják meg (hacsak nincs megadva a második argumentum is a kívánt formátummal). A Temporal csak egy speciálisan formázott dátumkarakterláncot elemez. A karakterláncnak meg kell felelnie az ISO 8601 formátumnak vagy annak kiterjesztésének, az RFC 9557-nek. Ha egy nem megfelelő dátum karakterláncot ad át egy from metódusnak, a Temporal RangeError üzenetet ad.
// RFC 9557 dátumkarakterlánc használata const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[Amerika/New_York]'); console.log(myDate.toString({ időzóna: 'Amerika/New_York' })); // 2026-02-21T09:00:00-05:00
// Ismeretlen dátum karakterlánc használata const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Időbeli hiba: Érvénytelen karakter az évérték elemzésekor.
A dátumkarakterlánc pontos követelményei attól függenek, hogy milyen típusú Temporal objektumot hoz létre. A fenti példában a Temporal.Instant teljes ISO-t igényel8601 vagy RFC 9557 dátumkarakterlánc, amely megadja a dátumot és az időt időzóna eltolással, de létrehozhat PlainDate vagy PlainTime objektumokat a dátumformátum egy részhalmazával is. 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
Ne feledje, hogy ezeknek a karakterláncoknak továbbra is meg kell felelniük az elvárt formátumnak, különben hibaüzenet jelenik meg.
// Nem megfelelő idő karakterláncok használata. Ezek mind RangeError-t fognak dobni. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Profi tipp: Nem ISO-karakterláncok kezeléseMivel a Temporal a megbízhatóságot részesíti előnyben, nem próbálja meg kitalálni egy karakterlánc formátumát, például 2026. 02. 01.. Ha az adatforrás ilyen karakterláncokat használ, néhány karakterlánc-manipulációt kell végrehajtania, hogy átrendezze az értékeket egy ISO-karakterláncba, például 2026-02-01, mielőtt megpróbálná használni a Temporal-lal.
Formázás Ha már rendelkezik egy pillanatnyi vagy időbeli objektummal, valószínűleg valamikor formázott karakterláncra szeretné konvertálni. Ez egy olyan eset, amikor a pillanat egy kicsit tömörebb. Az objektum formázási metódusát a kívánt dátumformátumot leíró tokenekkel hívhatja meg. const date = pillanat();
console.log(date.format('MM/DD/YYYY')); // 2026.02.22
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 2026. február 22., 20:18:30
Másrészt a Temporal megköveteli, hogy egy kicsit bőbeszédűbb legyél. Az ideiglenes objektumok, például az Instant, rendelkeznek egy toLocaleString metódussal, amely elfogadja az objektum tulajdonságaiként megadott különféle formázási beállításokat.
const date = Temporal.Now.instant();
// argumentumok nélkül az aktuális területi beállítás alapértelmezett formátumát kapjuk meg console.log(date.toLocaleString()); // 2026.02.22., 20:23:36 (az en-US nyelvterületet feltételezve)
// átadja a formázási beállításokat egyéni formátumú karakterlánc létrehozásához console.log(date.toLocaleString('en-US', { hónap: 'hosszú', nap: 'numeric', év: "numeric", óra: "2 számjegyű", perc: "2 számjegyű" })); // 2026. február 22., 20:23
// csak a kívánt mezőket adja át a formátum karakterláncban console.log(date.toLocaleString('en-US', { hónap: 'rövid', nap: 'numerikus' })); // Február 22
Az időbeli dátumformázás valójában az Intl.DateTimeFormat API-t használja (amely már könnyen elérhető a modern böngészőkben) a motorháztető alatt. Ez azt jelenti, hogy létrehozhat egy újrafelhasználható DateTimeFormat objektumot az egyéni formázási beállításokkal, majd átadhatja az Temporal objektumokat a formázási metódusának. Emiatt nem támogatja az egyéni dátumformátumokat, mint például a Moment. Ha olyasmire van szüksége, mint a „2026. I. negyedév” vagy más speciális formázás, szükség lehet egy egyéni dátumformázási kódra vagy egy harmadik féltől származó könyvtárra. const formatter = new Intl.DateTimeFormat('en-US', { hónap: "2 számjegyű", nap: "2 számjegyű", év: "numerikus" });
const date = Temporal.Now.instant(); console.log(formázó.formátum(dátum)); // 2026.02.22
A Moment formázási tokenek írása egyszerűbb, de nem helybarát. A formátum olyan „kemény kódot” ír le, mint például a hónap/nap sorrend. A konfigurációs objektumok használatának előnye, ahogyan a Temporal is teszi, hogy automatikusan alkalmazkodik bármely adott területi beállításhoz, és a megfelelő formátumot használja. const date = Temporal.Now.instant();
const formatOptions = { hónap: 'numeric', nap: 'numeric', év: "numerikus" };
console.log(date.toLocaleString('en-US', formatOptions)); // 2026.02.22
console.log(date.toLocaleString('en-GB', formatOptions)); // 2026.02.22
Dátum számítások Sok alkalmazásban bizonyos számításokat kell végeznie egy dátumon. Érdemes lehet időegységeket (napok, órák, másodpercek stb.) összeadni vagy kivonni. Például, ha megvan az aktuális dátum, akkor érdemes lehet a felhasználónak a dátumot 1 hét múlva mutatni. A pillanatnyi objektumoknak vannak olyan metódusai, mint az összeadás és a kivonás, amelyek végrehajtják ezeket a műveleteket. Ezek a függvények értéket és mértékegységet vesznek fel, például: add(7, 'days'). Egy nagyon fontos különbség azonban a Moment és a Temporal között, hogy ezeknek a dátumszámításoknak a végrehajtásakor a mögöttes objektum módosul, és az eredeti értéke elveszik. const most = pillanat();
console.log(now); // Pillanat<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'napok'); console.log(nextWeek); // Pillanat<2026-03-03T20:08:36-05:00>
// Gotcha - az eredeti objektum mutációra került console.log(now); // Pillanat<2026-03-03T20:08:36-05:00>
Az eredeti dátum elvesztésének elkerülése érdekében a Moment objektum klónozásával másolatot készíthet. const most= pillanat(); const nextWeek = now.clone().add(7, 'napok');
console.log(now); // Pillanat<2026-02-24T20:12:55-05:00>
console.log(nextWeek); // Pillanat<2026-03-03T20:12:55-05:00>
Másrészt az időbeli objektumok megváltoztathatatlanok. Miután létrehozott egy objektumot, például egy Instant, PlainDate és így tovább, az objektum értéke soha nem fog megváltozni. Az időbeli objektumoknak is vannak összeadási és kivonási módszerei. A Temporal kissé válogatós abban, hogy mely objektumtípusokhoz milyen időegységeket lehet hozzáadni. Például nem adhat hozzá napokat egy Instanthoz:
const now = Temporal.Now.instant(); const nextWeek = now.add({ nap: 7 }); // RangeError: Időbeli hiba: A legnagyobb egység nem lehet dátumegység
Ennek az az oka, hogy az azonnali objektumok egy adott időpontot képviselnek az UTC-ben, és naptár-agnosztikusak. Mivel a nap hossza az időzóna-szabályok, például a nyári időszámítás függvényében változhat, ez a számítás nem érhető el Instant esetén. Ezt a műveletet azonban más típusú objektumokon is végrehajthatja, például a PlainDateTime-on: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2026.02.24., 20:23:59
const nextWeek = now.add({ nap: 7 });
// Vegye figyelembe, hogy az eredeti PlainDateTime változatlan marad console.log(now.toLocaleString()); // 2026.02.24., 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Azt is kiszámíthatja, hogy mennyi idő van két pillanatnyi vagy időbeli objektum között. A Moment diff függvényében meg kell adni egy mértékegységet a részletességhez, ellenkező esetben ezredmásodpercben adja vissza a különbséget. const date1 = moment('2026-02-21T09:00:00'); const date2 = pillanat('2026-02-22T10:30:00');
console.log(date2.diff(dátum1)); // 91800000
console.log(date2.diff(dátum1, 'napok')); 1
Egy Temporal objektumhoz ehhez átadhat egy másik Időbeli objektumot a amíg vagy a óta metódusainak. Ez egy Temporal.Duration objektumot ad vissza, amely információkat tartalmaz az időeltérésről. Az Időtartam objektum a különbség minden összetevőjéhez rendelkezik tulajdonságokkal, és létrehozhat egy ISO 8601 szerinti időtartamú karakterláncot, amely az időkülönbséget reprezentálja.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// A legnagyobb egység a reprezentálandó legnagyobb időegységet adja meg // az időtartam számításánál const diff = date2.ince(dátum1, { legnagyobb egység: 'nap' });
console.log(diff.days); 1
console.log(diff.hours); 1
console.log(diff.minutes); 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 időtartama: 1 nap, 1 óra, 30 perc)
Dátumok és idők összehasonlítása A Moment és a Temporal egyaránt lehetővé teszi a dátumok és időpontok összehasonlítását annak meghatározásához, hogy melyik áll a másik előtt, de eltérő megközelítést alkalmaz az API-val. A Moment olyan módszereket biztosít, mint például az isBefore, isAfter és isSame két Moment objektum összehasonlításához. const date1 = moment('2026-02-21T09:00:00'); const date2 = pillanat('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // igaz
A Temporal statikus összehasonlítási módszert használ két azonos típusú objektum összehasonlítására. -1-et ad vissza, ha az első dátum megelőzi a másodikat, 0-t, ha egyenlők, vagy 1-et, ha az első dátum a második után jön. A következő példa bemutatja, hogyan lehet összehasonlítani két PlainDate objektumot. A Temporal.PlainDate.compare mindkét argumentumának PlainDate objektumnak kell lennie.
const date1 = Temporal.PlainDate.from({ év: 2026, hónap: 2, nap: 24 }); const date2 = Temporal.PlainDate.from({ év: 2026, hónap: 3, nap: 24 });
// a dátum1 a dátum2 előtt van, tehát -1 console.log(Temporal.PlainDate.compare(dátum1, dátum2));
// Hiba, ha két különböző típusú objektumot próbálunk összehasonlítani console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // Típushiba: Időbeli hiba: Érvénytelen PlainDate mezők lettek megadva.
Ez különösen megkönnyíti az időbeli objektumok tömbjének kronológiai sorrendbe rendezését. // Temporal.PlainDate objektumok tömbje const date = [ ... ];
// használja a Temporal.PlainDate.compare összehasonlító függvényt dates.sort(Temporal.PlainDate.compare);
Időzóna-konverziók A Moment alapvető könyvtára nem támogatja az időzóna-konverziókat. Ha szüksége van erre a funkcióra, telepítenie kell a moment-timezone csomagot is. Ez a csomag nem rázható meg, ezért jelentősen növelheti a csomag méretét. A pillanat-időzóna telepítése után a Moment objektumokat különböző időzónákra konvertálhatja a tz módszerrel. A többi Moment-művelethez hasonlóan ez is megváltoztatja az alapjátobjektum. // Amerikai keleti idő szerint const most = pillanat(); console.log(now); // Pillanat<2026-02-28T20:08:20-05:00>
// Átváltás csendes-óceáni időre. // Az eredeti keleti idő elveszett. now.tz('Amerika/Los_Angeles'); console.log(now); // Pillanat<2026-02-28T17:08:20-08:00>
A Temporal.ZonedDateTime objektum használatakor az időzóna funkció be van építve a Temporal API-ba. Ezek az objektumok tartalmaznak egy withTimeZone metódust, amely egy új ZonedDateTime értéket ad vissza, amely ugyanazt az időpontot képviseli, de a megadott időzónában. // Ismét, az Egyesült Államok keleti idejét feltételezve const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2/28/2026, 20:12:02 EST
// Átváltás csendes-óceáni időre const nowPacific = now.withTimeZone('Amerika/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 2026.02.28., 17:12:02 PST
// Az eredeti objektum változatlan marad console.log(now.toLocaleString()); // 2/28/2026, 20:12:02 EST
Megjegyzés: A toLocaleString által visszaadott formázott értékek, ahogy a neve is sugallja, területfüggő. A mintakódot az en-US nyelvterületen fejlesztették ki, így a formátum a következő: 2/28/2026, 17:12:02 PST. Egy másik területen ez eltérhet. Például az en-GB nyelvterületen valami olyasmit kap, mint 28/2/2026, 17:12:02 GMT-8. Valós újrafaktorálás Tegyük fel, hogy egy alkalmazást építünk az események időzónák közötti ütemezésére. Az alkalmazás része egy függvény, a getEventTimes, amely egy ISO 8601-es karakterláncot vesz fel, amely az esemény időpontját és dátumát, egy helyi időzónát és egy célidőzónát jelöli. A függvény formázott idő- és dátumkarakterláncokat hoz létre az eseményhez mindkét időzónában. Ha a függvény olyan bemeneti karakterláncot kap, amely nem érvényes idő/dátum karakterlánc, akkor hibát fog kiadni. Íme az eredeti megvalósítás, a Moment használatával (amely szintén a pillanat-időzóna csomag használatát igényli).
pillanat importálása a 'moment-timezone'-ból;
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'HH D, ÉÉÉÉ, h:pp:ss a z';
// 1. Hozza létre a kezdeti pillanatot a felhasználó időzónájában const eventTime = moment.tz( inputString, moment.ISO_8601, // ISO 8601 karakterláncra számítson igaz, // Szigorú elemzés userTimeZone );
// Hibát dob, ha az inputString nem érvényes dátumot jelent if (!eventTime.isValid()) { throw new Error('Érvénytelen dátum/idő bevitel'); }
// 2. Számítsa ki a célidőt // KRITIKUS: Klónoznunk kell, különben az 'eventTime' örökre megváltozik! const targetTime = eventTime.clone().tz(targetTimeZone);
return { local: eventTime.format(timeFormat), cél: targetTime.format(timeFormat), }; }
const ütemterv = getEventTimes( "2026-03-05T15:00-05:00", „Amerika/New_York”, „Európa/London”, );
console.log(schedule.local); // 2026. március 5., 15:00:00 EST
console.log(schedule.target); // 2026. március 5., 20:00:00 GMT
Ebben a példában az ISO 8601 várható dátumformátumot használjuk, amely hasznosan be van építve a Momentbe. Szigorú elemzést is használunk, ami azt jelenti, hogy a Moment nem próbál kitalálni olyan dátum karakterlánccal, amely nem egyezik a formátummal. Ha nem ISO dátumkarakterláncot adunk át, az érvénytelen dátumobjektumot eredményez, és hibát dobunk ki. Az ideiglenes megvalósítás hasonlónak tűnik, de van néhány lényeges különbség.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Elemezze a bemenetet közvetlenül egy Instantba, majd hozzon létre // egy ZonedDateTime a felhasználói zónában. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Konvertálás a célzónára // Ez automatikusan egy ÚJ objektumot ad vissza; Az 'eventTime' biztonságos. const célIdő = eventTime.withTimeZone(targetTimeZone);
// 3. Formázás Intl használatával (beépített) const options = { év: "numeric", hónap: 'rövid', nap: 'numeric', óra: 'numeric', perc: '2-jegyű', második: „2-jegyű”, timeZoneName: 'short' };
return { local: eventTime.toLocaleString(navigator.language, options), cél: targetTime.toLocaleString(navigator.language, options) }; }
const ütemterv = getEventTimes( "2026-03-05T15:00-05:00", „Amerika/New_York”, „Európa/London”, );
console.log(schedule.local); // 2026. március 5., 15:00:00 EST
console.log(schedule.target); // 2026. március 5., 20:00:00 GMT
A Momentnél kifejezetten meg kell adnunk egy formátum karakterláncot az eredményül kapott dátum karakterláncokhoz. A felhasználó tartózkodási helyétől vagy területétől függetlenül az események időpontja mindig 2026. március 5., 3:00:00 lesz.délután EST. Ezenkívül nem kell kifejezetten kivételt dobnunk. Ha érvénytelen karakterláncot adunk át a Temporal.Instant.from fájlnak, a Temporal kivételt dob számunkra. Meg kell jegyezni, hogy a Moment verzió még szigorú elemzés mellett is engedékenyebb. Az Időbeli beállítás megköveteli az időzóna eltolását a karakterlánc végén. Azt is meg kell jegyezni, hogy mivel a navigator.language nyelvet használjuk, ez a kód csak böngésző környezetben fog futni, mivel a navigátor Node.js környezetben nincs megadva. Az ideiglenes megvalósítás a böngésző aktuális területi beállítását (navigator.language) használja, így a felhasználó automatikusan megkapja a helyi időformátumban formázott eseményidőket. Az Egyesült Államokban ez 2026. március 5., 15:00:00 EST. Ha azonban a felhasználó például Londonban tartózkodik, az események időpontja 2026. március 5., 15:00:00 GMT-5 lesz. Összegzés
Akció Moment.js Időbeli Jelenlegi idő pillanat () Temporal.Now.zonedDateTimeISO() ISO elemzése pillanat (str) Temporal.Instant.from(str) Add hozzá az időt .add(7, 'napok') (mutál) .add({ nap: 7 }) (új objektum) Különbség .diff(egyéb, 'óra') .mióta(egyéb).óra Időzóna .tz('Zóna/Név') .withTimeZone('Zóna/Név')
Első pillantásra a különbség kissé eltérhet (és a Temporal esetében néha bőbeszédűbb és szigorúbb) szintaxis, de a Temporal használatának számos fő előnye van a Moment.js-hez képest:
Az explicitebb kifejezés kevesebb meglepetést és nem szándékos hibát jelent. A pillanat engedékenyebbnek tűnhet, de „találgatásokkal” jár, ami néha helytelen dátumokat eredményezhet. Ha érvénytelen valamit adsz meg a Temporal-nak, az hibát jelez. Ha a kód lefut, tudja, hogy érvényes dátummal rendelkezik. A pillanat jelentős mértékben növelheti az alkalmazáscsomagot, különösen, ha a pillanatnyi időzóna csomagot használja. A Temporal nem ad hozzá semmit (miután a célböngészőkben elküldték). A változatlanság azt a magabiztosságot adja, hogy soha nem veszíti el vagy írja felül az adatokat a dátumkonverziók és -műveletek végrehajtásakor. Az idő különböző ábrázolásai (Instant, PlainDateTime, ZonedDateTime) az Ön igényeitől függően, ahol a Moment mindig egy UTC időbélyeg körüli burkolóanyag. A Temporal az Intl API-kat használja a dátum formázásához, ami azt jelenti, hogy a területi beállításokat figyelembe vevő formázást anélkül, hogy kifejezetten meg kellene adnia tokeneket.
Megjegyzések a Polyfillről Mint korábban említettük, elérhető egy Temporal polyfill, amelyet @js-temporal/polyfill nevű npm-csomagként terjesztenek. Ha ma szeretné használni a Temporalt, akkor szüksége lesz erre a többkitöltésre olyan böngészők támogatásához, mint a Safari, amelyek még nem szállították az API-t. A rossz hír az, hogy növeli a csomag méretét. A jó hír az, hogy még mindig lényegesen kevesebbet ad hozzá, mint a pillanat vagy a pillanatnyi időzóna. Íme a csomagméretek összehasonlítása a Bundlephobia.com webhelyen, amely az npm csomagméretekkel kapcsolatos információkat közöl (kattintson az egyes csomagok nevére a Bundlephobia elemzés megtekintéséhez):
csomag Minimalizált Minimalizált és gzip-fájl @js-temporal/polyfill 154,1 kB 44,1 kB pillanat 294,4 kB 75,4 kB pillanat-időzóna 1 MB 114,2 kB
A polifillnek történelmileg is voltak teljesítménybeli problémái a memóriahasználattal kapcsolatban, és az írás idején alfa állapotúnak tekinthető. Emiatt előfordulhat, hogy nem kívánja termelésben használni, amíg el nem éri egy érettebb állapotot. A másik jó hír az, hogy remélhetőleg a polyfillre már nem lesz sokáig szükség (kivéve persze, ha régebbi böngészőket kell támogatnia). A cikk írásakor a Temporal Chrome-ban, Edge-ben és Firefoxban volt szállítva. Még nincs teljesen készen a Safariban, bár úgy tűnik, hogy elérhető lesz futásidejű jelzővel a legújabb technológiai előnézeten.
