Oibríonn beagnach aon chineál iarratais scríofa i JavaScript le hamanna nó dátaí i gcáil éigin. Ar dtús, bhí sé seo teoranta don API Dáta ionsuite. Áirítear leis an API feidhmiúlacht bhunúsach, ach tá sé teoranta go leor maidir le cad is féidir leis a dhéanamh. Cuireann leabharlanna tríú páirtí ar nós Moment.js, agus APInna ionsuite níos déanaí ar nós na APIanna Intl agus an API Temporal nua, solúbthacht i bhfad níos mó le bheith ag obair le hamanna agus dátaí. Ardú agus Titim Moment.js Is leabharlann JavaScript í Moment.js le fóntais chumhachtacha chun oibriú le hamanna agus dátaí. Áiríonn sé gnéithe atá ar iarraidh ón API Dáta bunúsach, mar ionramháil crios ama, agus déanann sé go leor oibríochtaí coitianta níos simplí. Áirítear le Nóiméad freisin feidhmeanna chun dátaí agus amanna a fhormáidiú. Bhí sé ina leabharlann a úsáidtear go forleathan i go leor feidhmeanna éagsúla. Mar sin féin, bhí a sciar de cheisteanna ag Moment freisin. Leabharlann mhór atá ann, agus féadann sé cur go mór le méid beart feidhmchláir. Toisc nach dtacaíonn an leabharlann le crainn a chroitheadh (gné de chúngadóirí nua-aimseartha ar féidir leo codanna neamhúsáidte de leabharlanna a bhaint), cuirtear an leabharlann Moment iomlán san áireamh fiú mura n-úsáideann tú ach ceann amháin nó dhá cheann dá feidhmeanna. Saincheist eile le Nóiméad is ea an fhíric go bhfuil na rudaí a chruthaíonn sé mutable. Bíonn fo-iarmhairtí ag baint le glaoch ar fheidhmeanna áirithe ar réad Nóiméad agus sócháintear luach an réada sin. Féadfaidh iompar nó fabhtanna gan choinne a bheith mar thoradh air seo. In 2020, chinn cothaitheoirí Moment an leabharlann a chur i modh cothabhála. Níl aon fhorbairt ar ghné nua á dhéanamh, agus molann na cothóirí gan é a úsáid do thionscadail nua. Tá leabharlanna dáta JavaScript eile ann, mar date-fns, ach tá imreoir nua sa bhaile, API a tógadh go díreach i JavaScript: Temporal. Is caighdeán nua é a líonann poill an bhun-API Dáta agus a réitíonn cuid de na teorainneacha a aimsítear i Moment agus i leabharlanna eile. Cad é Sealadach? Is API nua ama agus dáta é Temporal atá á chur leis an gcaighdeán ECMAScript, a shainíonn JavaScript nua-aimseartha. Ó Mhárta 20266, tá Céim 4 de phróiseas TC39 sroichte aige (an coiste a dhéanann maoirsiú ar thograí agus ar bhreiseanna leis an teanga JavaScript), agus áireofar é sa chéad leagan eile de shonraíocht ECMAScript. Tá sé curtha i bhfeidhm cheana féin i roinnt brabhsálaithe: Chrome 144+ agus Firefox 139+, agus táthar ag súil go leanfaidh Safari go luath. Tá polyfill ar fáil freisin do bhrabhsálaithe nach dtacaítear leo agus Node.js. Cruthaíonn an API Temporal réada a léiríonn, go ginearálta, chuimhneacháin in am. Is féidir iad seo a bheith ina stampaí lánaimseartha agus dáta i gcrios ama ar leith, nó is féidir gur sampla cineálach ama “cloig balla” iad gan aon eolas crios ama nó dáta. I measc cuid de phríomhghnéithe Tempal tá:
Amanna le dátaí nó gan iad. Is féidir le réad ama am ar leith a léiriú ar dháta faoi leith, nó am gan aon eolas dáta. Is féidir dáta sonrach, gan am, a léiriú freisin. Tá rudaí tacaíochta crios ama go hiomlán ar an eolas faoi chrios ama agus is féidir iad a thiontú ar fud criosanna ama éagsúla. Tacaíonn Nóiméad le criosanna ama freisin, ach teastaíonn leabharlann chrios ama breise de chuid nóiméad. Immutability.Nuair a chruthaítear réad Temporal, ní féidir é a athrú. Ní athraíonn uimhríocht ama nó tiontuithe crios ama an bunréad. Ina áit sin, gineann siad réad Sealadach nua. Innéacsú 1-bhunaithe.Is foinse coiteann fabhtanna leis an Dáta API (chomh maith le Nóiméad) ná go bhfuil míonna innéacsaithe nialasach. Ciallaíonn sé seo gurb é Eanáir mí 0, seachas mí 1 mar a thuigimid go léir sa saol fíor. Ceartaítear é seo go sealadach trí innéacsú bunaithe ar 1 a úsáid - is é Eanáir mí 1. Tá sé ionsuite sa bhrabhsálaí. Ós rud é gur API sa bhrabhsálaí féin é Temporal, ní chuireann sé aon rud le méid cuachta d’fheidhmchláir.
Tá sé tábhachtach a thabhairt faoi deara freisin nach bhfuil an Date API ag imeacht. Cé go dtagann Temporal in ionad an API seo, níl sé á bhaint ná ag dul i léig. Bhrisfeadh go leor feidhmchlár dá mbainfeadh brabhsálaithe an Dáta API go tobann. Mar sin féin, cuimhnigh freisin go meastar Moment anois mar thionscadal oidhreachta i mód cothabhála. Sa chuid eile den alt, féachfaimid ar roinnt “oidis” chun cód bunaithe ar Nóiméad a aistriú chuig an API Temporal nua. Tosaímid ag athmhacrú! Ag Cruthú Réada Dáta Agus Ama Sular féidir linn dátaí agus amanna a láimhseáil, ní mór dúinn rudaí a chruthú a léiríonn iad. Chun réad Nóiméad a chruthú a sheasann don dáta agus don am reatha, bain úsáid as an fheidhm nóiméad. const anois = nóiméad(); console.log(anois); // Nóiméad<2026-02-18T21:26:29-05:00>
Is féidir an réad seo a fhormáidiú nó a ionramháil anois de réir mar is gá.
// thiontú go UTC //rabhadh: Mutálann sé seo an réad Nóiméad agus cuireann sé i mód UTC é! console.log(now.utc()); // Nóiméad<2026-02-19T02:26:29Z>
// teaghrán formáidithe a phriontáil - tabhair faoi deara go bhfuil an t-am UTC á úsáid aige anois console.log(now.format('MM/DD/BBBB hh:mm:ss a')); // 02/19/2026 02:27:07 r.n
Is é an rud is tábhachtaí le cuimhneamh faoi Nóiméad ná go n-áiríonn réad Nóiméad faisnéis faoin am agus faoin dáta i gcónaí. Más rud é nach gá duit ach a bheith ag obair le faisnéis ama, is gnách go bhfuil sé seo fíneáil, ach is féidir go n-eascródh iompar gan choinne i gcásanna mar Am Coigilt Solas an Lae nó blianta léime, nuair is féidir leis an dáta tionchar a bheith aige ar ríomhanna ama. Tá an t-am níos solúbtha. Is féidir leat réad a léiríonn an dáta agus an t-am reatha a chruthú trí réad Temporal.Instant a chruthú. Seasann sé seo do phointe ama arna shainmhíniú ag an am ó “an ré” (UTC meán oíche an 1 Eanáir, 1970). Is féidir le Tempal tagairt a dhéanamh don mheandar seo in am le beachtas leibhéal nana-dara. const anois = Temporal.Now.instant();
// féach nanascoicindí amh ón aga console.log(now.epochNanoseconds); // 1771466342612000000n
// formáid le haghaidh UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// formáid do chrios ama ar leith console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Is féidir rudaí Temporal.Instant a chruthú freisin ar feadh am agus dáta ar leith trí úsáid a bhaint as an modh as statach.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formáid an toirt sa chrios ama áitiúil. Tabhair faoi deara nach rialaíonn sé seo ach // an fhormáidiú - ní mutaíonn sé an réad mar a dhéanann moment.utc. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Is féidir leat cineálacha eile réad ama a chruthú freisin, lena n-áirítear:
Temporal.PlainDate: Dáta gan aon eolas ama. Temporal.PlainTime: Am gan aon eolas dáta. Temporal.ZonedDateTime: Dáta agus am i gcrios ama ar leith.
Tá modh ó gach ceann díobh seo ar féidir a ghlaoch le réad a shonraíonn an dáta agus/nó an t-am, nó teaghrán dáta le parsáil. // Just a date const inniu = Temporal.PlainDate.from({ Bliain: 2026, mí: 2, // nóta táimid ag úsáid 2 le haghaidh Feabhra lá: 18 }); console.log(day.toString()); // 2026-02-18
// Just a time const lunchTime = Temporal.PlainTime.from({ uair:12 }); console.log(Am lóin.toString()); // 12:00:00
// Dáta agus am i gcrios ama an Oirthir de chuid SAM const dueAt = Temporal.ZonedDateTime.from({ Crios ama: 'Meiriceá/Nua_Eabhrac', Bliain: 2026, mí: 3, Lá: 1, uair: 12, nóiméad: 0, dara:0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Meiriceá/Nua_Eabhrac]
Parsáil Tá cruthú cláir faisnéise dáta agus ama clúdaithe againn. Anois féachaimis ar pharsáil. Is réimse amháin é parsáil ina bhfuil Moment níos solúbtha ná an API Temporal ionsuite. Is féidir leat teaghrán dáta a pharsáil trína chur ar aghaidh chuig an bhfeidhm nóiméad. Le argóint amháin, tá Moment ag súil le teaghrán dáta ISO, ach is féidir leat formáidí eile a úsáid má sholáthraíonn tú an dara argóint a shonraíonn an fhormáid dáta atá in úsáid.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = nóiméad ('2/21/26 9:00:00', 'M/L/BB h:mm:ss');
console.log(isoDate); // Nóiméad<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Nóiméad<2026-02-21T09:00:00-05:00>
I leaganacha níos sine, is fearr a dhéanfadh Moment buille faoi thuairim aon teaghrán dáta atá formáidithe go treallach a pharsáil. D’fhéadfadh torthaí nach féidir a thuar a bheith mar thoradh air seo. Mar shampla, an é 02-03-2026 2 Feabhra nó 3 Márta? Ar an ábhar sin, taispeánann leaganacha níos nuaí de Moment rabhadh dímheasa feiceálach má ghlaotar air gan teaghrán dáta formáidithe ISO (mura dtugtar an dara argóint leis an bhformáid atá ag teastáil freisin). Ní dhéanfaidh sealadach ach teaghrán dáta atá formáidithe go sonrach a pharsáil. Caithfidh an teaghrán a bheith comhlíontach le formáid ISO 8601 nó lena síneadh, RFC 9557. Má chuirtear teaghrán dáta neamhchomhlíonta ar aghaidh chuig modh ó, caithfidh Temporal RangeError.
// Ag baint úsáide as teaghrán dáta RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[Meiriceá/Nua_Eabhrac]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// Ag baint úsáide as teaghrán dáta anaithnid const otherDate = Temporal.Instant.from( '2/21/26 9:00:00'); // RangeError: Earráid ama: Carachtar neamhbhailí agus luach bliana á pharsáil.
Braitheann riachtanais bheachta an teaghráin dáta ar an gcineál réad ama atá á chruthú agat. Sa sampla thuas, éilíonn Temporal.Instant ISO iomlánTeaghrán dáta 8601 nó RFC 9557 a shonraíonn an dáta agus an t-am le fritháireamh crios ama, ach is féidir leat rudaí PlainDate nó PlainTime a chruthú freisin ag baint úsáide as fo-thacar den fhormáid dáta. 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
Tabhair faoi deara go gcaithfidh na teaghráin seo fós cloí leis an bhformáid a bhfuiltear ag súil leis, nó déanfar earráid a chaitheamh.
// Ag baint úsáide as teaghráin ama neamhchomhlíonta. Caithfidh siad seo go léir RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Leid Pro: Teaghráin neamh-ISO a láimhseáil Toisc go dtugann Temporal tosaíocht d’iontaofacht, ní dhéanfaidh sé iarracht formáid teaghráin mar 02-01-2026 a thomhas. Má úsáideann do fhoinse sonraí teaghráin den sórt sin, beidh ort roinnt ionramháil teaghrán a dhéanamh chun na luachanna a athshocrú go teaghrán ISO mar 2026-02-01 sula ndéanfaidh tú iarracht é a úsáid le Temporal.
Formáidiú Nuair a bheidh réad Nóiméad nó Sealadach agat, is dócha go mbeidh tú ag iarraidh é a thiontú go teaghrán formáidithe am éigin. Is cás é seo ina bhfuil Nóiméad beagán níos teo. Glaonn tú modh formáide an réada le teaghrán comharthaí a chuireann síos ar an bhformáid dáta atá ag teastáil. const date = nóiméad();
console.log(date.format('MM/DD/BBBB')); // 22/02/2026
console.log(date.format('MMMM Déan BBBB, h:mm:ss a')); // 22 Feabhra 2026, 8:18:30 in
Ar an láimh eile, éilíonn Temporal go bhfuil tú beagán níos briathartha. Tá modh toLocaleString ag réada sealadacha, ar nós Instant, a ghlacann le roghanna formáidithe éagsúla atá sonraithe mar airíonna réad.
const date = Temporal.Now.instant();
// gan aon argóintí, gheobhaidh muid an fhormáid réamhshocraithe don locale reatha console.log(date.toLocaleString()); // 2/22/2026, 8:23:36 PM (ag glacadh le locale en-SAM)
// roghanna formáidithe pas a fháil chun teaghrán formáid saincheaptha a ghiniúint console.log(date.toLocaleString('en-US', { mí: 'fada', lá: 'uimhriúil', bliain: 'uimhriúil', uair an chloig: '2-digit', nóiméad: '2-digit' })); // 22 Feabhra, 2026 ag 8:23 PM
// pas a fháil ach na réimsí atá uait sa teaghrán formáide console.log(date.toLocaleString('en-US', { mí: 'gearr', lá: 'uimhriúil' })); // 22 Feabhra
Úsáideann formáidiú dáta ama i ndáiríre an API Intl.DateTimeFormat (atá ar fáil go héasca i mbrabhsálaithe nua-aimseartha cheana féin) faoin gcochall. Ciallaíonn sé sin gur féidir leat réad DateTimeFormat ath-inúsáidte a chruthú le do roghanna formáidithe saincheaptha, ansin rudaí Temporal a chur ar aghaidh chuig a mhodh formáide. Mar gheall air seo, ní thacaíonn sé le formáidí dáta saincheaptha mar a dhéanann Moment. Má tá rud éigin cosúil le ‘Q1 2026’ nó formáidiú speisialaithe eile ag teastáil uait, b’fhéidir go mbeadh cód formáidithe dáta saincheaptha uait nó rochtain do leabharlann tríú páirtí. const formatter = Intl.DateTimeFormat nua('en-US', { mí: '2-dhigit', lá: '2-dhigit', bliain: 'uimhriúil' });
const date = Temporal.Now.instant(); console.log(formatter.format(dáta)); // 22/02/2026
Tá comharthaí formáidithe nóiméad níos simplí a scríobh, ach ní bhíonn siad cairdiúil don cheantar. Teaghráin an fhormáid "cód crua" rudaí cosúil le mí/ordú lae. Is é an buntáiste a bhaineann le réad cumraíochta a úsáid, mar a dhéanann Temporal, ná go n-oiriúnóidh sé go huathoibríoch d'aon locale ar leith agus go n-úsáidfidh sé an fhormáid cheart. const date = Temporal.Now.instant();
const formatOptions = { mí: 'uimhriúil', lá: 'uimhriúil', bliain: 'uimhriúil' };
console.log(date.toLocaleString('en-US', formatOptions)); // 2/22/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Áireamh dáta I go leor feidhmchlár, beidh ort roinnt ríomhaireachtaí a dhéanamh ar dháta. B'fhéidir gur mhaith leat aonaid ama a shuimiú nó a dhealú (laethanta, uaireanta, soicindí, etc.). Mar shampla, má tá an dáta reatha agat, b'fhéidir gur mhaith leat an dáta a thaispeáint don úsáideoir 1 seachtain ó anois. Tá modhanna mar suimiú agus dealú ag réada nóiméad a dhéanann na hoibríochtaí seo. Glacann na feidhmeanna seo luach agus aonad, mar shampla: add(7, 'days'). Difríocht an-tábhachtach amháin idir Nóiméad agus Sealadach, áfach, is ea, agus na háirimh dátaí seo á ndéanamh, modhnaítear an bunábhar agus cailltear a bhunluach. const anois = nóiméad();
console.log(anois); // Nóiméad<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'lá'); console.log(an tseachtain seo chugainn); // Nóiméad<2026-03-03T20:08:36-05:00>
// Gotcha - bhí an bunréad mutated console.log(anois); // Nóiméad<2026-03-03T20:08:36-05:00>
Chun an dáta bunaidh a sheachaint, is féidir leat clón a chur ar an réad Nóiméad chun cóip a chruthú. const anois= nóiméad(); const nextWeek = now.clone().add(7, 'lá');
console.log(anois); // Nóiméad<2026-02-24T20:12:55-05:00>
console.log(an tseachtain seo chugainn); // Nóiméad<2026-03-03T20:12:55-05:00>
Ar an láimh eile, tá rudaí Sealadacha domhalartaithe. Nuair a bheidh réad ar nós Instant, PlainDate, agus mar sin de cruthaithe agat, ní athróidh luach an réada sin choíche. Tá modhanna suimithe agus dealaithe ag réada ama freisin. Tá an t-am beagán picky faoi na haonaid ama is féidir a chur leis na cineálacha réad. Mar shampla, ní féidir leat laethanta a chur le Meandaracha:
const anois = Temporal.Now.instant(); const nextWeek = now.add({ laethanta: 7 }); // RangeError: Earráid ama: Ní féidir aonad dáta a bheith san aonad is mó
Tá sé seo amhlaidh toisc go léiríonn réada Meandaracha pointe ama ar leith in UTC agus go bhfuil siad féilire-agnostic. Toisc gur féidir fad an lae a athrú bunaithe ar rialacha crios ama ar nós Am Coigilt Solas an Lae, níl an ríomh seo ar fáil ar an toirt. Is féidir leat, áfach, an oibríocht seo a dhéanamh ar chineálacha eile réad, mar shampla PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({ laethanta: 7 });
// Tabhair faoi deara nach bhfuil aon athrú ar an bPlainDateTime bunaidh console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
console.log(nextWeek.toLocaleString()); // 3/3/2026, 8:23:59 PM
Is féidir leat a ríomh freisin cé mhéad ama atá idir dhá réad Nóiméad nó Sealadach. Le feidhm Difríochta Moment, ní mór duit aonad a sholáthar le haghaidh gráinneachta, nó tabharfaidh sé ar ais an difríocht i milleasoicindí. const date1 = nóiméad ('2026-02-21T09:00:00'); const date2 = nóiméad ('2026-02-22T10:30:00');
console.log(date2.dif(date1)); // 91800000
console.log(date2.diff(dáta1, 'laethanta')); //1
Chun seo a dhéanamh le réad Temporal, is féidir leat pas a fháil réad Sealadach eile a modhanna go dtí nó ó shin. Filleann sé seo réad Temporal.Duration ina bhfuil faisnéis faoin difríocht ama. Tá airíonna ag an réad Fadré do gach comhpháirt den difríocht, agus is féidir leis teaghrán fad ISO 8601 a ghiniúint a ionadaíonn an difríocht ama.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// is mó Sonraíonn an tAonad an t-aonad ama is mó le léiriú // sa ríomh ré const diff = date2.since(dáta1, {Aonad is mó: 'lá' });
consól.log(difriúil.laethanta); //1
console.log(difr.uair); //1
console.log(difriúil.minutes); //30
console.log(dif.toString()); // P1DT1H30M // (teaghrán ré ISO 8601: 1 lá, 1 uair, 30 nóiméad)
Ag Comparáid idir Dátaí agus Amanna Ligeann Moment and Temporal duit dátaí agus amanna a chur i gcomparáid lena chinneadh cé acu a thagann roimh an gceann eile, ach glacann tú cuir chuige éagsúla leis an API. Soláthraíonn Moment modhanna mar isBefore, isAfter, agus isSame chun dhá réad Nóiméad a chur i gcomparáid. const date1 = nóiméad ('2026-02-21T09:00:00'); const date2 = nóiméad ('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // fíor
Úsáideann Tempal modh comparáide statach chun comparáid a dhéanamh idir dhá réad den chineál céanna. Filleann sé -1 má thagann an chéad dáta roimh an dara ceann, 0 más comhionann iad, nó 1 má thagann an chéad dáta tar éis an dara ceann. Léiríonn an sampla seo a leanas conas dhá réad PlainDate a chur i gcomparáid. Caithfidh an dá argóint a ghabhann le Temporal.PlainDate.compare a bheith ina réad PlainDate.
const date1 = Temporal.PlainDate.from({ bliain: 2026, mí: 2, lá: 24 }); const date2 = Temporal.PlainDate.from({ bliain: 2026, mí: 3, lá: 24 });
// tagann dáta1 roimh an dáta2, mar sin -1 console.log(Temporal.PlainDate.compare(dáta1, dáta2));
// Earráid má dhéanaimid iarracht dhá réad de chineálacha éagsúla a chur i gcomparáid console.log(Temporal.PlainDate.compare(dáta1, Temporal.Now.instant())); // TypeError: Earráid ama: Réimsí Neamhbhailí PlainDate curtha ar fáil.
Go háirithe, fágann sé seo go bhfuil sé éasca raon de rudaí Sealadacha a shórtáil go croineolaíoch. // Sraith de rudaí Temporal.PlainDate dátaí const = [ ... ];
// úsáid Temporal.PlainDate.compare mar an fheidhm chomparáideora dátaí.sort(Temporal.PlainDate.compare);
Tiontú Crios Ama Ní thacaíonn an croí-leabharlann Moment le tiontuithe crios ama. Má tá an fheidhmiúlacht seo ag teastáil uait, ní mór duit an pacáiste criosanna ama a shuiteáil freisin. Níl an pacáiste seo crann-shakable, agus dá bhrí sin is féidir cur go mór le do cuachta méid. Nuair a bheidh crios ama nóiméad suiteáilte agat, is féidir leat réada Nóiméad a thiontú go criosanna ama éagsúla leis an modh tz. Mar is amhlaidh le hoibríochtaí eile Nóiméad, mutálann sé seo an bunúsacharéad. // Ag glacadh leis am an Oirthir SAM const anois = nóiméad(); console.log(anois); // Nóiméad<2026-02-28T20:08:20-05:00>
// Tiontaigh go ham an Aigéin Chiúin. // Tá am bunaidh an Oirthir caillte. now.tz('America/Los_Angeles'); console.log(anois); // Nóiméad<2026-02-28T17:08:20-08:00>
Tá feidhmiúlacht crios ama ionsuite san API Temporal nuair a úsáidtear réad Temporal.ZonedDateTime. Áirítear leis na cuspóirí seo modh withTimeZone a thugann ZonedDateTime nua ar ais a léiríonn an nóiméad céanna in am, ach sa chrios ama sonraithe. // Arís, ag glacadh leis US Oirthearach am const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
// Tiontaigh go ham an Aigéin Chiúin const nowAn tAigéan Ciúin = now.withTimeZone('America/Los_Angeles'); console.log(anois Pacific.toLocaleString()); // 2/28/2026, 5:12:02 PM PST
// Tá an bunábhar gan athrú console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
Nóta: Mar a thugann an t-ainm le tuiscint, braitheann na luachanna formáidithe ar ais chuig LocaleString. Forbraíodh an cód samplach sa locale en-US, mar sin tá an fhormáid mar seo: 2/28/2026, 5:12:02 PM PST. I locale eile, d'fhéadfadh sé seo a bheith difriúil. Mar shampla, sa locale en-GB, gheobhaidh tú rud éigin cosúil le 28/2/2026, 17:12:02 GMT-8. A Real-world Refactoring Abair go bhfuil aip á tógáil againn chun imeachtaí a sceidealú thar chriosanna ama. Tá feidhm mar chuid den aip seo, getEventTimes, a ghlacann teaghrán ISO 8601 a léiríonn am agus dáta an imeachta, crios ama áitiúil, agus crios ama sprice. Cruthaíonn an fheidhm teaghráin ama agus dáta formáidithe don imeacht sa dá chrios ama. Má thugtar sreang ionchuir don fheidhm nach teaghrán ama/dáta bailí í, caithfidh sé earráid. Seo an cur i bhfeidhm bunaidh, ag baint úsáide as Moment (lena n-áirítear úsáid a bhaint as an bpacáiste crios ama ama freisin).
nóiméad iompórtála ón 'moment-timezone';
feidhm getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, BBBB, h:mm:ss a z';
// 1. Cruthaigh an nóiméad tosaigh i gcrios ama an úsáideora const eventTime = moment.tz( sreang ionchuir, moment.ISO_8601, // Bí ag súil le teaghrán ISO 8601 fíor, // Parsáil docht UserTimeZone );
// Caith earráid murab dáta bailí é an t-ionchurString más rud é (!eventTime.isValid()) { caith Earráid nua ('ionchur dáta/am neamhbhailí'); }
// 2. Ríomh an sprioc-am // CRITICIÚIL: Ní mór dúinn clónáil, nó athraíonn 'EventTime' go deo! const targetTime = eventTime.clone().tz(targetTimeZone);
ar ais { áitiúil: eventTime.format(timeFormat), sprioc: targetTime.format(timeFormat), }; }
sceideal const = getEventTimes( '2026-03-05T15:00-05:00', 'Meiriceá/Nua_Eabhrac', 'An Eoraip/Londain', );
console.log(schedule.local); // 5 Márta, 2026, 3:00:00 pm EST
console.log(schedule.target); // 5 Márta, 2026, 8:00:00 pm GMT
Sa sampla seo, táimid ag baint úsáide as formáid dáta ionchais ISO 8601, atá ionsuite go cabhrach i Moment. Táimid ag baint úsáide as parsáil dhian freisin, rud a chiallaíonn nach ndéanfaidh Moment iarracht buille faoi thuairim le teaghrán dáta nach bhfuil ag teacht leis an bhformáid. Má rithtear teaghrán dáta neamh-ISO, beidh réad dáta neamhbhailí mar thoradh air, agus caithfimid earráid. Breathnaíonn an cur i bhfeidhm Sealadach cosúil, ach tá roinnt príomhdhifríochtaí ann.
feidhm getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Parsáil an t-ionchur go díreach isteach i Meandaracha, ansin cruthaigh // a ZonedDateTime i gcrios an úsáideora. const toirt = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Tiontaigh go dtí an spriocchrios // Tugann sé seo réad NUA ar ais go huathoibríoch; tá ‘EventTime’ sábháilte. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formáid ag baint úsáide as Intl (tógtha i) roghanna const = { bliain: 'uimhriúil', mí: 'gearr', lá: 'uimhriúil', uair: 'uimhriúil', nóiméad: '2-digit', dara: '2-dhigit', timeZoneName: 'gearr' };
ar ais { áitiúil: eventTime.toLocaleString(navigator.language, roghanna), sprioc: targetTime.toLocaleString(navigator.language, roghanna) }; }
sceideal const = getEventTimes( '2026-03-05T15:00-05:00', 'Meiriceá/Nua_Eabhrac', 'An Eoraip/Londain', );
console.log(schedule.local); // 5 Márta, 2026, 3:00:00 PM EST
console.log(schedule.target); // 5 Márta, 2026, 8:00:00 PM GMT
Le Nóiméad, ní mór dúinn teaghrán formáide a shonrú go sainráite do na teaghráin dáta mar thoradh air. Is cuma faoi shuíomh nó logán an úsáideora, déanfar amanna na n-imeachtaí a fhormáidiú i gcónaí mar 5 Márta, 2026, 3:00:00pm EST. Chomh maith leis sin, ní gá dúinn eisceacht a chaitheamh go sainráite. Má chuirtear teaghrán neamhbhailí ar aghaidh chuig Temporal.Instant.from, caithfidh Temporal an eisceacht dúinn. Rud amháin atá le tabhairt faoi deara ná go bhfuil an leagan Nóiméad níos boige fós le parsáil dhian. Teastaíonn go sealadach an crios ama a fhritháireamh ag deireadh na sreinge. Ba chóir duit a thabhairt faoi deara freisin, ós rud é go bhfuil Navigator.language á úsáid againn, nach mbeidh an cód seo ag rith ach i dtimpeallacht bhrabhsálaí, toisc nach bhfuil an loingseoir sainithe i dtimpeallacht Node.js. Úsáideann an cur i bhfeidhm Sealadach logán reatha an bhrabhsálaí (navigator.language), mar sin gheobhaidh an t-úsáideoir amanna imeachta formáidithe go huathoibríoch ina bhformáid ama áitiúil. Sa locale en-US, seo é 5 Márta, 2026, 3:00:00 pm EST. Mar sin féin, má tá an t-úsáideoir i Londain, mar shampla, déanfar amanna an imeachta a fhormáidiú mar 5 Mar 2026, 15:00:00 GMT-5. Achoimre
Gníomh Nóiméad.js Sealadach Am reatha nóiméad () Temporal.Now.zonedDateTimeISO() ISO á pharsáil nóiméad (str) Temporal.Instant.from(str) Cuir am leis .cuir(7, 'lá') (mutates) .add({ laethanta: 7 }) (réad nua) Difríocht .diff(eile, 'uair an chloig') .ó (eile).uaireanta Crios ama .tz('Crios/Ainm') .withTimeZone('Crios/Ainm')
Ar an gcéad amharc, féadfaidh an difríocht a bheith beagán difriúil (agus i gcás comhréire Temporal, uaireanta níos briathartha agus níos déine), ach tá roinnt príomhbhuntáistí ag baint le húsáid Temporal over Moment.js:
Ciallaíonn a bheith níos soiléire níos lú iontas agus fabhtanna neamhbheartaithe. D’fhéadfadh an chuma a bheith ar an nóiméad a bheith níos boige, ach baineann sé le “buille faoi thuairim,” agus uaireanta bíonn dátaí míchearta mar thoradh air. Má thugann tú rud éigin Temporal neamhbhailí, caitheann sé earráid. Má ritheann an cód, tá a fhios agat go bhfuil dáta bailí agat. Is féidir le nóiméad méid suntasach a chur le beart an fheidhmchláir, go háirithe má tá an pacáiste crios ama in úsáid agat. Ní chuireann Tempal aon rud leis (a luaithe a sheoltar é i do spriocbhrabhsálaithe). Tugann neamh-luaineacht an mhuinín duit nach gcaillfidh tú nó nach ndéanfaidh tú sonraí a fhorscríobh go deo agus tú ag déanamh tiontaithe dáta agus oibríochtaí. Léirithe éagsúla ama (Instant, PlainDateTime, ZonedDateTime) ag brath ar do chuid riachtanas, áit a mbíonn Moment ina chumhdach timpeall stampa ama UTC i gcónaí. Úsáideann Tempal na APIanna Intl chun dáta a fhormáidiú, rud a chiallaíonn gur féidir leat formáidiú atá feasach ar logánú a bheith agat gan comharthaí a shonrú go sainráite.
Nótaí Ar An Polyfill Mar a luadh cheana, tá polyfill Temporal ar fáil, a dháileadh mar phacáiste npm darb ainm @js-temporal/polyfill. Más mian leat Temporal a úsáid inniu, beidh an t-illíon seo uait chun tacú le brabhsálaithe cosúil le Safari nach bhfuil an API seolta acu go fóill. Is é an drochscéal leis seo ná go gcuirfidh sé le do mhéid bundle. Is é an dea-scéal go gcuireann sé fós i bhfad níos lú ná nóiméad nó móimint-am-crios. Seo comparáid idir na méideanna beart mar a thuairiscigh Bundlephobia.com, suíomh Gréasáin a chuireann faisnéis ar fáil faoi mhéideanna pacáiste npm (cliceáil ar gach ainm pacáiste chun an anailís Bundlephobia a fheiceáil):
Pacáiste Mionaithe Miondealaithe & gzipped @js-temporal/polyfill 154.1 kB 44.1 kB nóiméad 294.4 kB 75.4 kB nóiméad-crios ama 1 MB 114.2 kB
Go stairiúil bhí roinnt saincheisteanna feidhmíochta ag an polyfill freisin maidir le húsáid chuimhne, agus ag an am seo á scríobh, meastar go bhfuil sé i stát alfa. Mar gheall air seo, b'fhéidir nach dteastaíonn uait é a úsáid i dtáirgeadh go dtí go sroicheann sé stát níos aibí. Is é an dea-scéal eile ná go bhfuil súil againn nach mbeidh an polyfill ag teastáil i bhfad níos faide (ach amháin má theastaíonn uait tacaíocht a thabhairt do bhrabhsálaithe níos sine, ar ndóigh). Agus é seo á scríobh, tá Temporal seolta i Chrome, Edge, agus Firefox. Níl sé réidh go leor i Safari fós, cé gur dealraitheach go bhfuil sé ar fáil le bratach ama rite ar an Réamhamharc Teicneolaíochta is déanaí.
