Byna enige soort toepassing wat in JavaScript geskryf is, werk in een of ander hoedanigheid met tye of datums. In die begin was dit beperk tot die ingeboude Datum API. Hierdie API bevat basiese funksionaliteit, maar is redelik beperk in wat dit kan doen. Derdeparty-biblioteke soos Moment.js, en later ingeboude API's soos die Intl API's en die nuwe Temporal API, voeg baie groter buigsaamheid by om met tye en datums te werk. Die Opkoms En Ondergang Van Moment.js Moment.js is 'n JavaScript-biblioteek met kragtige nutsprogramme om met tye en datums te werk. Dit bevat ontbrekende kenmerke van die basiese Datum API, soos tydsone manipulasie, en maak baie algemene bewerkings eenvoudiger. Moment bevat ook funksies vir die formatering van datums en tye. Dit het 'n wyd gebruikte biblioteek in baie verskillende toepassings geword. Moment het egter ook sy deel van kwessies gehad. Dit is 'n groot biblioteek en kan aansienlik bydra tot 'n toepassing se bondelgrootte. Omdat die biblioteek nie boomskud ondersteun nie ('n kenmerk van moderne bundels wat ongebruikte dele van biblioteke kan verwyder), is die hele Moment-biblioteek ingesluit, selfs al gebruik jy net een of twee van sy funksies. Nog 'n probleem met Moment is die feit dat die voorwerpe wat dit skep veranderbaar is. Om sekere funksies op 'n Moment-voorwerp te roep, het newe-effekte en muteer die waarde van daardie voorwerp. Dit kan lei tot onverwagte gedrag of foute. In 2020 het die instandhouers van Moment besluit om die biblioteek in onderhoudsmodus te plaas. Geen nuwe kenmerkontwikkeling word gedoen nie, en die instandhouers beveel aan om dit vir nuwe projekte te gebruik. Daar is ander JavaScript-datumbiblioteke, soos date-fns, maar daar is 'n nuwe speler in die stad, 'n API wat direk in JavaScript ingebou is: Temporal. Dit is 'n nuwe standaard wat die gate van die oorspronklike Date API invul, asook sommige van die beperkings wat in Moment en ander biblioteke gevind word, oplos. Wat is tydelik? Temporal is 'n nuwe tyd- en datum-API wat by die ECMAScript-standaard gevoeg word, wat moderne JavaScript definieer. Vanaf Maart 20266 het dit stadium 4 van die TC39-proses bereik (die komitee wat toesig hou oor voorstelle en toevoegings tot die JavaScript-taal), en sal ingesluit word in die volgende weergawe van die ECMAScript-spesifikasie. Dit is reeds in verskeie blaaiers geïmplementeer: Chrome 144+ en Firefox 139+, met Safari wat na verwagting binnekort sal volg. 'n Polyfill is ook beskikbaar vir nie-ondersteunde blaaiers en Node.js. Die Temporal API skep voorwerpe wat oor die algemeen oomblikke in tyd verteenwoordig. Dit kan voltydse en datumstempels in 'n gegewe tydsone wees, of dit kan 'n generiese voorbeeld van "muurhorlosie"-tyd wees sonder enige tydsone of datuminligting. Sommige van die hoofkenmerke van Temporal sluit in:
Tye met of sonder datums. 'n Tydelike voorwerp kan 'n spesifieke tyd op 'n spesifieke datum voorstel, of 'n tyd sonder enige datuminligting. 'n Spesifieke datum, sonder 'n tyd, kan ook voorgestel word. Tydsone-ondersteuning. Tydelike voorwerpe is ten volle tydsone-bewus en kan oor verskillende tydsones omgeskakel word. Moment ondersteun ook tydsones, maar dit vereis die bykomende oomblik-tydsone-biblioteek. Onveranderlikheid. Sodra 'n tydelike voorwerp geskep is, kan dit nie verander word nie. Tydrekenkundige of tydsone-omskakelings wysig nie die onderliggende voorwerp nie. In plaas daarvan genereer hulle 'n nuwe Temporele voorwerp. 1-gebaseerde indeksering. 'n Algemene bron van foute met die Datum API (sowel as met Moment) is dat maande nul-geïndexeer is. Dit beteken dat Januarie maand 0 is, eerder as maand 1 soos ons almal in die werklike lewe verstaan. Temporele maak dit reg deur 1-gebaseerde indeksering te gebruik - Januarie is maand 1. Dit is in die blaaier ingebou. Aangesien Temporal 'n API in die blaaier self is, voeg dit niks by jou toepassing se bondelgrootte nie.
Dit is ook belangrik om daarop te let dat die Datum API nie verdwyn nie. Terwyl Temporal hierdie API vervang, word dit nie verwyder of afgekeur nie. Baie toepassings sal breek as blaaiers die Date API skielik verwyder. Hou egter ook in gedagte dat Moment nou as 'n erfenisprojek in onderhoudsmodus beskou word. In die res van die artikel sal ons kyk na 'n paar "resepte" vir die migreer van Moment-gebaseerde kode na die nuwe Temporal API. Kom ons begin herfaktoreer! Die skep van datum- en tydvoorwerpe Voordat ons datums en tye kan manipuleer, moet ons voorwerpe skep wat hulle verteenwoordig. Om 'n Moment-voorwerp te skep wat die huidige datum en tyd verteenwoordig, gebruik die oomblik-funksie. const nou = moment(); console.log(nou); // Oomblik<2026-02-18T21:26:29-05:00>
Hierdie voorwerp kan nou geformateer of gemanipuleer word soos nodig.
// skakel om na UTC //waarskuwing: Dit muteer die Moment-voorwerp en plaas dit in UTC-modus! console.log(nou.utc()); // Oomblik<2026-02-19T02:26:29Z>
// druk 'n geformateerde string - let op dat dit nou die UTC-tyd gebruik console.log(now.format('MM/DD/JJJJ uu:mm:ss a')); // 02/19/2026 02:27:07 vm
Die belangrikste ding om van Moment te onthou, is dat 'n Moment-voorwerp altyd inligting oor die tyd en datum insluit. As jy net met tydinligting hoef te werk, is dit gewoonlik goed, maar dit kan onverwagte gedrag veroorsaak in situasies soos Somertyd of skrikkeljare, waar die datum 'n uitwerking op tydberekeninge kan hê. Temporeel is meer buigsaam. Jy kan 'n voorwerp skep wat die huidige datum en tyd verteenwoordig deur 'n Temporal.Instant voorwerp te skep. Dit verteenwoordig 'n tydstip wat gedefinieer word deur die tyd sedert "die epog" (middernag UTC op 1 Januarie 1970). Temporal kan hierdie oomblik betyds met nanosekondevlak-presisie verwys. const now = Temporal.Now.instant();
// sien rou nanosekondes sedert die epog console.log(nou.epochNanosekondes); // 1771466342612000000n
// formaat vir UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// formaat vir 'n spesifieke tydsone console.log(now.toString({ tydsone: 'America/New_York'})); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant-objekte kan ook vir 'n spesifieke tyd en datum geskep word deur die van statiese metode te gebruik.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formateer die oomblik in die plaaslike tydsone. Let daarop dat dit slegs beheer // die formatering - dit muteer nie die voorwerp soos moment.utc doen nie. console.log(myInstant.toString({ timeZone: 'America/New_York'})); // 2026-02-18T21:10:00-05:00
Jy kan ook ander tipes tydelike voorwerpe skep, insluitend:
Temporal.PlainDate: 'n Datum sonder tydinligting. Temporal.PlainTime: 'n Tyd sonder datuminligting. Temporal.ZonedDateTime: 'n Datum en tyd in 'n spesifieke tydsone.
Elkeen van hierdie het 'n van-metode wat genoem kan word met 'n objek wat die datum en/of tyd spesifiseer, of 'n datumstring om te ontleed. // Net 'n afspraak const today = Temporal.PlainDate.from({ jaar: 2026, maand: 2, // let op ons gebruik 2 vir Februarie dag: 18 }); console.log(today.toString()); // 2026-02-18
// Net 'n tyd const lunchTime = Temporal.PlainTime.from({ uur: 12 }); console.log(lunchTime.toString()); // 12:00:00
// 'n Datum en tyd in die Amerikaanse oostelike tydsone const dueAt = Temporal.ZonedDateTime.from({ tydsone: 'Amerika/New_York', jaar: 2026, maand: 3, dag: 1, uur: 12, minuut: 0, sekonde: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amerika/New_York]
Ontleding Ons het programmatiese skepping van datum- en tydinligting gedek. Kom ons kyk nou na ontleding. Ontleding is een gebied waar Moment meer buigsaam is as die ingeboude Temporal API. Jy kan 'n datumstring ontleed deur dit na die momentfunksie deur te gee. Met 'n enkele argument verwag Moment 'n ISO-datumstring, maar jy kan alternatiewe formate gebruik as jy 'n tweede argument verskaf wat die datumformaat spesifiseer wat gebruik word.
const isoDatum = oomblik('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDatum); // Oomblik<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Oomblik<2026-02-21T09:00:00-05:00>
In ouer weergawes sou Moment 'n beste raaiskoot maak om enige arbitrêr geformateerde datumstring te ontleed. Dit kan tot onvoorspelbare resultate lei. Is 02-03-2026 byvoorbeeld 2 Februarie of 3 Maart? Om hierdie rede vertoon nuwer weergawes van Moment 'n prominente afskaffingswaarskuwing as dit sonder 'n ISO-geformateerde datumstring geroep word (tensy die tweede argument met die verlangde formaat ook gegee word). Temporal sal slegs 'n spesifiek geformateerde datumstring ontleed. Die string moet voldoen aan die ISO 8601-formaat of sy uitbreiding, RFC 9557. As 'n nie-voldoenende datumstring na 'n van-metode oorgedra word, sal Temporal 'n RangeError gooi.
// Gebruik 'n RFC 9557 datumstring const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ tydsone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// Gebruik 'n onbekende datumstring const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Tydelike fout: Ongeldige karakter tydens die ontleding van jaarwaarde.
Die presiese vereistes van die datumstring hang af van watter soort Temporele voorwerp jy skep. In die voorbeeld hierbo vereis Temporal.Instant 'n volledige ISO8601 of RFC 9557 datumstring wat die datum en tyd met 'n tydsone-verskuiwing spesifiseer, maar jy kan ook PlainDate- of PlainTime-objekte skep deur slegs 'n subset van die datumformaat te gebruik. 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
Let daarop dat hierdie stringe steeds aan die verwagte formaat moet voldoen, anders sal 'n fout gegooi word.
// Gebruik 'n nie-voldoenende tydstringe. Dit sal almal 'n RangeError gooi. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Pro-wenk: Hantering van nie-ISO-stringe Omdat Temporal betroubaarheid prioritiseer, sal dit nie probeer om die formaat van 'n string soos 02-01-2026 te raai nie. As jou databron sulke stringe gebruik, sal jy stringmanipulasie moet doen om die waardes in 'n ISO-string soos 2026-02-01 te herrangskik voordat jy probeer om dit met Temporal te gebruik.
Formatering Sodra jy 'n oomblik of tydelike voorwerp het, sal jy dit waarskynlik een of ander tyd na 'n geformateerde string wil omskakel. Dit is 'n geval waar Moment 'n bietjie meer bondig is. Jy noem die voorwerp se formaatmetode met 'n string tekens wat die verlangde datumformaat beskryf. const datum = oomblik();
console.log(date.format('MM/DD/JJJJ')); // 22/02/2026
console.log(date.format('MMMM Doen JJJJ, h:mm:ss a')); // 22 Februarie 2026, 20:18:30
Aan die ander kant vereis Temporal dat jy 'n bietjie meer breedvoerig moet wees. Tydelike voorwerpe, soos Instant, het 'n toLocaleString-metode wat verskeie formateringopsies aanvaar wat as eienskappe van 'n voorwerp gespesifiseer is.
const datum = Temporal.Now.instant();
// met geen argumente, sal ons die verstek formaat vir die huidige locale kry console.log(date.toLocaleString()); // 22/2/2026, 20:23:36 (met 'n land van en-VSA)
// gee formatering opsies om 'n pasgemaakte formaat string te genereer console.log(date.toLocaleString('en-US', { maand: 'lank', dag: 'numeries', jaar: 'numeries', uur: '2-syfer', minuut: '2-syfer' })); // 22 Februarie 2026 om 20:23
// gee slegs die velde wat jy in die formaatstring wil hê, deur console.log(date.toLocaleString('en-US', { maand: 'kort', dag: 'numeries' })); // 22 Feb
Temporele datumformatering gebruik eintlik die Intl.DateTimeFormat API (wat reeds geredelik beskikbaar is in moderne blaaiers) onder die kap. Dit beteken dat jy 'n herbruikbare DateTimeFormat-objek met jou pasgemaakte formatering-opsies kan skep, en dan Temporal-objekte na sy formaatmetode kan deurgee. As gevolg hiervan ondersteun dit nie pasgemaakte datumformate soos Moment nie. As jy iets soos 'Q1 2026' of ander gespesialiseerde formatering nodig het, sal jy dalk 'n pasgemaakte datumformateringkode nodig hê of 'n derdeparty-biblioteek bereik. const formatter = new Intl.DateTimeFormat('en-US', { maand: '2-syfer', dag: '2-syfer', jaar: 'numeries' });
const datum = Temporal.Now.instant(); console.log(formatter.format(datum)); // 22/02/2026
Moment se formateringtokens is makliker om te skryf, maar dit is nie plekvriendelik nie. Die formaat stringe "harde kode" dinge soos maand/dag volgorde. Die voordeel van die gebruik van 'n konfigurasie-objek, soos Temporal doen, is dat dit outomaties sal aanpas by enige gegewe plek en die korrekte formaat gebruik. const datum = Temporal.Now.instant();
const formatOptions = { maand: 'numeries', dag: 'numeries', jaar: 'numeries' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22/2/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Datum berekeninge In baie toepassings sal jy uiteindelik sekere berekeninge op 'n datum moet uitvoer. Jy sal dalk tydeenhede wil byvoeg of aftrek (dae, ure, sekondes, ens.). Byvoorbeeld, as jy die huidige datum het, wil jy dalk die gebruiker die datum 1 week van nou af wys. Momentvoorwerpe het metodes soos optel en aftrek wat hierdie bewerkings uitvoer. Hierdie funksies neem 'n waarde en 'n eenheid, byvoorbeeld: add(7, 'days'). Een baie belangrike verskil tussen Moment en Temporal is egter dat wanneer hierdie datumberekeninge uitgevoer word, die onderliggende voorwerp gewysig word en die oorspronklike waarde daarvan verlore gaan. const nou = moment();
console.log(nou); // Oomblik<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'dae'); console.log(volgendeweek); // Oomblik<2026-03-03T20:08:36-05:00>
// Gotcha - die oorspronklike voorwerp is gemuteer console.log(nou); // Oomblik<2026-03-03T20:08:36-05:00>
Om te verhoed dat u die oorspronklike datum verloor, kan u kloon op die Moment-voorwerp roep om 'n kopie te skep. konst nou= oomblik(); const nextWeek = now.clone().add(7, 'dae');
console.log(nou); // Oomblik<2026-02-24T20:12:55-05:00>
console.log(volgendeweek); // Oomblik<2026-03-03T20:12:55-05:00>
Aan die ander kant is tydelike voorwerpe onveranderlik. Sodra jy 'n voorwerp soos 'n Instant, PlainDate, ensovoorts geskep het, sal die waarde van daardie voorwerp nooit verander nie. Temporele voorwerpe het ook optel- en aftrekmetodes. Temporal is 'n bietjie kieskeurig oor watter tydeenhede by watter voorwerptipes gevoeg kan word. Jy kan byvoorbeeld nie dae by 'n kits voeg nie:
const now = Temporal.Now.instant(); const nextWeek = now.add({dae: 7}); // RangeError: Tydelike fout: Grootste eenheid kan nie 'n datumeenheid wees nie
Dit is omdat Kitsvoorwerpe 'n spesifieke tydstip in UTC verteenwoordig en kalender-agnosties is. Omdat die lengte van 'n dag kan verander op grond van tydsonereëls soos somertyd, is hierdie berekening nie op 'n kits beskikbaar nie. Jy kan egter hierdie bewerking op ander soorte voorwerpe uitvoer, soos 'n PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
const nextWeek = now.add({dae: 7});
// Let daarop dat die oorspronklike PlainDateTime onveranderd bly console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Jy kan ook bereken hoeveel tyd daar tussen twee Moment- of Tydelike voorwerpe is. Met Moment se diff-funksie moet jy 'n eenheid vir korreligheid verskaf, anders sal dit die verskil in millisekondes teruggee. konst datum1 = oomblik('2026-02-21T09:00:00'); konst datum2 = oomblik('2026-02-22T10:30:00');
console.log(datum2.verskil(datum1)); // 91800000
console.log(date2.diff(datum1, 'dae')); // 1
Om dit met 'n tydelike voorwerp te doen, kan jy 'n ander tydelike voorwerp na sy tot of sedert metodes deurgee. Dit gee 'n Temporal.Duration-objek terug wat inligting oor die tydsverskil bevat. Die Duration-objek het eienskappe vir elke komponent van die verskil, en kan ook 'n ISO 8601-duurstring genereer wat die tydsverskil verteenwoordig.
const datum1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const datum2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// LargestUnit spesifiseer die grootste eenheid van tyd om voor te stel // in die tydsduur berekening const diff = datum2.since(datum1, {grootste Eenheid: 'dag'});
console.log(verskil.dae); // 1
console.log(verskil.ure); // 1
console.log(verskil.minute); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 duur string: 1 dag, 1 uur, 30 minute)
Vergelyk datums en tye Moment en Temporal laat jou albei datums en tye vergelyk om te bepaal watter voor die ander kom, maar neem verskillende benaderings met die API. Moment verskaf metodes soos isBefore, isAfter en isSame om twee Moment-objekte te vergelyk. konst datum1 = oomblik('2026-02-21T09:00:00'); konst datum2 = oomblik('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // waar
Temporal gebruik 'n statiese vergelykingsmetode om 'n vergelyking tussen twee voorwerpe van dieselfde tipe uit te voer. Dit gee -1 as die eerste datum voor die tweede kom, 0 as hulle gelyk is, of 1 as die eerste datum na die tweede kom. Die volgende voorbeeld wys hoe om twee PlainDate-objekte te vergelyk. Beide argumente vir Temporal.PlainDate.compare moet PlainDate-objekte wees.
const datum1 = Temporal.PlainDate.from({ jaar: 2026, maand: 2, dag: 24 }); const datum2 = Temporal.PlainDate.from({ jaar: 2026, maand: 3, dag: 24 });
// datum1 kom voor datum2, dus -1 console.log(Temporal.PlainDate.compare(date1, date2));
// Fout as ons probeer om twee voorwerpe van verskillende tipes te vergelyk console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Tydelike fout: Ongeldige PlainDate-velde verskaf.
Dit maak dit veral maklik om 'n reeks tydelike voorwerpe chronologies te sorteer. // 'n Skikking van Temporal.PlainDate-objekte const datums = [ ... ];
// gebruik Temporal.PlainDate.compare as die vergelykerfunksie dates.sort(Temporal.PlainDate.compare);
Tydsone-omskakelings Die kern Moment-biblioteek ondersteun nie tydsone-omskakelings nie. As jy hierdie funksionaliteit nodig het, moet jy ook die oomblik-tydsone-pakket installeer. Hierdie pakket is nie boom-skudbaar nie, en kan dus aansienlik byvoeg tot jou bondelgrootte. Sodra jy oomblik-tydsone geïnstalleer het, kan jy Moment-voorwerpe na verskillende tydsones omskakel met die tz-metode. Soos met ander Moment-operasies, muteer dit die onderliggendevoorwerp. // Aanvaar Amerikaanse oostelike tyd const nou = moment(); console.log(nou); // Oomblik<2026-02-28T20:08:20-05:00>
// Skakel oor na Stille Oseaan-tyd. // Die oorspronklike Oosterse tyd is verlore. now.tz('America/Los_Angeles'); console.log(nou); // Oomblik<2026-02-28T17:08:20-08:00>
Tydsone-funksionaliteit word in die Temporal API ingebou wanneer 'n Temporal.ZonedDateTime-objek gebruik word. Hierdie voorwerpe sluit 'n withTimeZone-metode in wat 'n nuwe ZonedDateTime terugstuur wat dieselfde tydstip verteenwoordig, maar in die gespesifiseerde tydsone. // Weereens, in die veronderstelling van Amerikaanse Oosterse tyd const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28/02/2026, 20:12:02 EST
// Skakel oor na Stille Oseaan-tyd const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28/02/2026, 17:12:02 PST
// Oorspronklike voorwerp bly onveranderd console.log(now.toLocaleString()); // 28/02/2026, 20:12:02 EST
Let wel: Die geformateerde waardes wat deur toLocaleString teruggestuur word, is, soos die naam aandui, locale-afhanklik. Die voorbeeldkode is ontwikkel in die en-US-lokaal, so die formaat is soos volg: 2/28/2026, 5:12:02 PM PST. In 'n ander plek kan dit anders wees. Byvoorbeeld, in die en-GB-lokaal sal jy iets soos 28/2/2026, 17:12:02 GMT-8 kry. 'n Werklike Refaktorering Gestel ons bou 'n toepassing om geleenthede oor tydsones te skeduleer. Deel van hierdie toepassing is 'n funksie, getEventTimes, wat 'n ISO 8601-string neem wat die tyd en datum van die gebeurtenis, 'n plaaslike tydsone en 'n teikentydsone verteenwoordig. Die funksie skep geformateerde tyd- en datumstringe vir die gebeurtenis in beide tydsones. As die funksie 'n invoerstring kry wat nie 'n geldige tyd-/datumstring is nie, sal dit 'n fout skep. Hier is die oorspronklike implementering, met behulp van Moment (wat ook die gebruik van die oomblik-tydsone-pakket vereis).
invoer oomblik van 'oomblik-tydsone';
funksie getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, JJJJ, h:mm:ss a z';
// 1. Skep die aanvanklike oomblik in die gebruiker se tydsone const eventTime = moment.tz( invoerstring, moment.ISO_8601, // Verwag 'n ISO 8601-string waar, // Streng ontleding gebruiker Tydsone );
// Gooi 'n fout as die invoerString nie 'n geldige datum verteenwoordig het nie if (!eventTime.isValid()) { gooi nuwe Fout ('Ongeldige datum/tyd-invoer'); }
// 2. Bereken die teikentyd // KRITIES: Ons moet kloon, of 'gebeurtenisTyd' verander vir altyd! const targetTime = eventTime.clone().tz(targetTimeZone);
terugkeer { local: eventTime.format(timeFormat), teiken: targetTime.format(timeFormat), }; }
const skedule = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/Londen', );
console.log(skedule.plaaslik); // 5 Maart 2026, 15:00:00 EST
console.log(skedule.teiken); // 5 Maart 2026, 20:00:00 GMT
In hierdie voorbeeld gebruik ons 'n verwagte datumformaat van ISO 8601, wat nuttig in Moment ingebou is. Ons gebruik ook streng ontleding, wat beteken Moment sal nie probeer raai met 'n datumstring wat nie by die formaat pas nie. As 'n nie-ISO datumstring geslaag word, sal dit 'n ongeldige datumvoorwerp tot gevolg hê, en ons gooi 'n fout. Die tydelike implementering lyk soortgelyk, maar het 'n paar belangrike verskille.
funksie getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Ontleed die invoer direk in 'n kits, en skep dan // 'n ZonedDateTime in die gebruiker se sone. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Skakel oor na die teikensone // Dit gee outomaties 'n NUWE voorwerp terug; 'eventTime' is veilig. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formateer met behulp van Intl (ingebou) const opsies = { jaar: 'numeries', maand: 'kort', dag: 'numeries', uur: 'numeries', minuut: '2-syfer', tweede: '2-syfer', tydsonenaam: 'kort' };
terugkeer { local: eventTime.toLocaleString(navigator.language, opsies), teiken: targetTime.toLocaleString(navigator.language, opsies) }; }
const skedule = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/Londen', );
console.log(skedule.plaaslik); // 5 Maart 2026, 15:00:00 EST
console.log(skedule.teiken); // 5 Maart 2026, 20:00:00 GMT
Met Moment moet ons 'n formaatstring vir die resulterende datumstringe uitdruklik spesifiseer. Ongeag die gebruiker se ligging of plek, die geleentheidstye sal altyd geformateer word as 5 Maart 2026, 3:00:00nm EST. Ons hoef ook nie uitdruklik 'n uitsondering te gooi nie. As 'n ongeldige string na Temporal.Instant.from deurgegee word, sal Temporal die uitsondering vir ons gooi. Een ding om op te let is dat selfs met streng ontleding, die Moment-weergawe steeds meer toegeeflik is. Temporeel vereis die tydsone-verskuiwing aan die einde van die string. Jy moet ook daarop let dat aangesien ons navigator.language gebruik, hierdie kode slegs in 'n blaaieromgewing sal loop, aangesien navigator nie in 'n Node.js-omgewing gedefinieer word nie. Die tydelike implementering gebruik die blaaier se huidige plek (navigator.language), sodat die gebruiker outomaties gebeurtenistye in hul plaaslike tydformaat geformateer sal kry. In die en-VSA-lokaal is dit 5 Maart 2026, 15:00:00 EST. As die gebruiker egter byvoorbeeld in Londen is, sal die geleentheidstye geformateer word as 5 Maart 2026, 15:00:00 GMT-5. Opsomming
Aksie Moment.js Tydelike Huidige tyd oomblik () Temporal.Now.zonedDateTimeISO() Ontleding van ISO oomblik (str) Temporal.Instant.from(str) Voeg tyd by .add(7, 'dae') (muteer) .add({ dae: 7 }) (nuwe voorwerp) Verskil .diff(ander, 'ure') .sedert(ander).ure Tydsone .tz('Sone/Naam') .withTimeZone('Sone/Naam')
Met die eerste oogopslag kan die verskil effens anders wees (en in die geval van Temporal, soms meer verbose en strenger) sintaksis, maar daar is verskeie sleutelvoordele verbonde aan die gebruik van Temporal bo Moment.js:
Om meer eksplisiet te wees, beteken minder verrassings en onbedoelde foute. Oomblik lyk dalk meer toegeeflik, maar dit behels "raaiwerk", wat soms tot verkeerde datums kan lei. As jy Temporal iets ongeldig gee, gooi dit 'n fout. As die kode loop, weet jy dat jy 'n geldige datum het. Moment kan aansienlike grootte byvoeg tot die toepassing se bondel, veral as jy die oomblik-tydsone-pakket gebruik. Temporal voeg niks by nie (sodra dit in jou teikenblaaiers gestuur is). Onveranderlikheid gee jou die vertroue dat jy nooit data sal verloor of oorskryf wanneer jy datumomskakelings en -bewerkings uitvoer nie. Verskillende voorstellings van tyd (Instant, PlainDateTime, ZonedDateTime) afhangende van jou vereistes, waar Moment altyd 'n omhulsel om 'n UTC-tydstempel is. Temporal gebruik die Intl API's vir datumformatering, wat beteken dat jy plek-bewuste formatering kan hê sonder om tokens uitdruklik te spesifiseer.
Notas oor die Polyfill Soos vroeër genoem, is daar 'n Temporal polyfill beskikbaar, versprei as 'n npm-pakket genaamd @js-temporal/polyfill. As jy vandag Temporal wil gebruik, sal jy hierdie polyfill nodig hê om blaaiers soos Safari te ondersteun wat nog nie die API gestuur het nie. Die slegte nuus hiermee is dat dit by jou bondelgrootte sal bydra. Die goeie nuus is dat dit steeds aansienlik minder as oomblik of oomblik-tydsone byvoeg. Hier is 'n vergelyking van die bondelgroottes soos gerapporteer deur Bundlephobia.com, 'n webwerf wat inligting oor npm-pakketgroottes aanbied (klik op elke pakketnaam om die Bundlephobia-analise te sien):
Pakket Verklein Verklein en gezip @js-temporal/polyfill 154,1 kB 44,1 kB oomblik 294,4 kB 75,4 kB oomblik-tydsone 1 MB 114,2 kB
Die polyfill het ook histories 'n paar prestasieprobleme gehad rondom geheuegebruik, en ten tyde van die skryf daarvan word dit as in 'n alfa-toestand beskou. As gevolg hiervan wil jy dit dalk nie in produksie gebruik totdat dit 'n meer volwasse toestand bereik nie. Die ander goeie nuus is dat die polyfill hopelik nie veel langer nodig sal wees nie (tensy jy natuurlik ouer blaaiers moet ondersteun). Met die skryf hiervan is Temporal in Chrome, Edge en Firefox verskeep. Dit is nog nie heeltemal gereed in Safari nie, alhoewel dit blykbaar beskikbaar is met 'n runtime-vlag op die nuutste Tegnologievoorskou.
