JavaScript-en idatzitako ia edozein aplikaziok orduekin edo datarekin funtzionatzen du nolabaiteko gaitasunarekin. Hasieran, Data API integratuta zegoen hori. API honek oinarrizko funtzionalitateak ditu, baina nahiko mugatua da zer egin dezakeen. Moment.js bezalako hirugarrenen liburutegiek, eta geroago integratutako APIek, hala nola Intl APIak eta Temporal API berriak, askoz malgutasun handiagoa ematen diote orduekin eta datekin lan egiteko. The Rise And Fall of Moment.js Moment.js orduak eta datak lantzeko utilitate indartsuak dituen JavaScript liburutegia da. Oinarrizko Data APIan falta diren eginbideak biltzen ditu, hala nola ordu-eremuaren manipulazioa, eta ohiko eragiketa asko errazten ditu. Momentek datak eta orduak formateatzeko funtzioak ere biltzen ditu. Oso erabilia den liburutegia bihurtu zen aplikazio ezberdin askotan. Hala ere, Momentuak ere izan zituen bere arazoen zatiak. Liburutegi handia da, eta aplikazio baten sortaren tamaina nabarmen gehi dezake. Liburutegiak ez duelako zuhaitz astintzea onartzen (erabiltzen ez diren liburutegien zatiak ken ditzaketen sorta modernoen ezaugarria), Moment liburutegi osoa sartzen da bere funtzioetako bat edo bi bakarrik erabiltzen badituzu ere. Moment-en beste arazo bat sortzen dituen objektuak aldagarriak direla da. Momentuko objektu batean zenbait funtzio deitzeak albo-ondorioak ditu eta objektu horren balioa aldatzen du. Horrek ustekabeko portaera edo akatsak sor ditzake. 2020an, Moment-eko arduradunek liburutegia mantentze moduan jartzea erabaki zuten. Ez da ezaugarri berririk garatzen ari, eta mantentzaileek proiektu berrietarako ez erabiltzea gomendatzen dute. Badaude beste JavaScript data liburutegiak, hala nola date-fns, baina erreproduzitzaile berri bat dago herrian, JavaScript-en zuzenean eraikitako API bat: Temporal. Jatorrizko Date APIaren zuloak betetzen dituen estandar berria da, baita Moment eta beste liburutegietan aurkitutako muga batzuk konpontzen dituena. Zer da tenporala? Temporal ECMAScript estandarrera gehitzen ari den ordu eta data API berria da, JavaScript modernoa definitzen duena. 20266ko martxotik aurrera, TC39 prozesuaren 4. fasera iritsi da (JavaScript hizkuntzaren proposamenak eta gehiketak gainbegiratzen dituen batzordea), eta ECMAScript zehaztapenaren hurrengo bertsioan sartuko da. Dagoeneko hainbat arakatzailetan inplementatu da: Chrome 144+ eta Firefox 139+, eta Safari laster espero da. Polyfill ere erabilgarri dago onartzen ez diren arakatzaileentzat eta Node.js. Temporal APIak, oro har, denboraren uneak adierazten dituzten objektuak sortzen ditu. Hauek ordu-eremu jakin bateko denbora osoko eta data-zigiluak izan daitezke, edo "hormako erlojuaren" orduaren instantzia generikoa izan daiteke ordu-eremu edo data-informaziorik gabe. Temporal-en ezaugarri nagusietako batzuk hauek dira:
Datarekin edo datarik gabeko orduak. Objektu tenporal batek data zehatz batean ordu zehatz bat irudika dezake, edo datarik gabeko ordu bat. Data zehatz bat, ordurik gabe, ere irudika daiteke. Ordu-eremuaren laguntza. Objektu tenporalak ordu-eremua guztiz ezagutzen dute eta ordu-eremu ezberdinetan bihur daitezke. Moment-ek ordu-eremuak ere onartzen ditu, baina une-ordu-eremuaren liburutegi gehigarria behar du. Aldaezintasuna.Objektu tenporala sortu ondoren, ezin da aldatu. Denbora-aritmetikak edo ordu-eremuaren bihurketak ez du azpiko objektua aldatzen. Horren ordez, denborazko objektu berri bat sortzen dute. 1-en oinarritutako indexazioa. Data APIarekin (baita Momentarekin ere) akatsen iturri arrunta hilabeteak zero indexatzen direla da. Horrek esan nahi du urtarrila 0 hilabetea dela, bizitza errealean denok ulertzen dugun bezala 1 hilabetea baino. Temporal-ek 1-en oinarritutako indexazioa erabiliz konpontzen du. Urtarrila 1. hilabetea da. Arakatzailean sartuta dago. Temporal arakatzailean bertan API bat denez, ez du ezer gehitzen zure aplikazioaren sortaren tamainari.
Garrantzitsua da ere Data APIa ez dela desagertuko. Temporal-ek API hau ordezkatzen duen arren, ez da kentzen edo zaharkitzen ari. Aplikazio asko hautsiko lirateke arakatzaileek bat-batean Date APIa kenduko balute. Dena den, kontuan izan ere Moment mantentze-moduan ondare-proiektutzat hartzen dela. Gainontzeko artikuluan, Momentuan oinarritutako kodea Temporal API berrira migratzeko "errezeta" batzuk ikusiko ditugu. Has gaitezen birfaktorizazioa! Data eta ordua objektuak sortzea Datak eta orduak manipulatu aurretik, horiek irudikatzen dituzten objektuak sortu behar ditugu. Uneko data eta ordua adierazten dituen Momentu objektu bat sortzeko, erabili une funtzioa. const orain = momentua(); console.log(orain); // Momentua<2026-02-18T21:26:29-05:00>
Objektu hau orain behar den moduan formateatu edo manipula daiteke.
// UTC bihurtu //abisua: honek Moment objektua aldatzen du eta UTC moduan jartzen du! console.log(now.utc()); // Momentua<2026-02-19T02:26:29Z>
// formateatutako kate bat inprimatu - kontuan izan UTC ordua erabiltzen ari dela orain console.log(now.format('MM/DD/AAAA hh:mm:ss a')); // 2026/02/19 02:27:07
Momentuari buruz gogoratu beharreko gauza nagusia Moment objektu batek orduari eta datari buruzko informazioa dakar beti. Ordu-informazioarekin soilik lan egin behar baduzu, ondo egon ohi da, baina ustekabeko portaera eragin dezake Udako Ordua edo bisurte-urteetan, non datak eragina izan dezakeen denbora-kalkuluetan. Denboraldia malguagoa da. Uneko data eta ordua adierazten dituen objektu bat sor dezakezu Temporal.Instant objektu bat sortuz. Honek "garaitik" (1970eko urtarrilaren 1eko gauerdia UTC) denboraren arabera definitutako denbora-puntua adierazten du. Tenporalak une honetan erreferentzia egin dezake denboran nanosegundo-mailako zehaztasunarekin. const now = Denboraldia.Orain.instant();
// ikusi nanosegundo gordinak garaitik console.log(orain.epochNanoseconds); // 1771466342612000000n
// UTCrako formatua console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// ordu-eremu jakin baterako formatua console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Denboraldia. Berehalako objektuak ordu eta data zehatz baterako ere sor daitezke from static metodoa erabiliz.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// Formateatu momentua tokiko ordu-eremuan. Kontuan izan honek bakarrik kontrolatzen duela // formatua - ez du objektua aldatzen moment.utc-k egiten duen bezala. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Beste denborazko objektu mota batzuk ere sor ditzakezu, besteak beste:
Temporal.PlainDate: orduko informaziorik gabeko data. Temporal.PlainTime: data informaziorik gabeko ordua. Temporal.ZonedDateTime: ordu-eremu zehatz bateko data eta ordua.
Horietako bakoitzak from metodo bat du, data eta/edo ordua zehazten duen objektu batekin dei daitekeena, edo analizatu beharreko data kate batekin. // Data bat besterik ez const gaur = Temporal.PlainDate.from({ urtea: 2026 hilabetea: 2, // ohartu otsailerako 2 erabiltzen ari garela Eguna: 18 }); console.log(gaur.toString()); // 2026-02-18
// Denbora bat besterik ez const lunchTime = Temporal.PlainTime.from ({ ordua: 12 }); console.log(lunchTime.toString()); // 12:00:00
// AEBetako Ekialdeko ordu-eremuko data eta ordua const dueAt = Temporal.ZonedDateTime.from({ timeZone: 'America/New_York', urtea: 2026 hilabetea: 3, eguna: 1, ordua: 12, minutu: 0, bigarrena: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[Amerika/New_York]
Analisia Data eta orduaren informazioaren sorrera programatikoa aztertu dugu. Ikus dezagun orain analisia. Analisia Moment barneko Temporal APIa baino malguagoa den eremu bat da. Data-kate bat analizatu dezakezu une funtziora pasatuz. Argumentu bakar batekin, Moment-ek ISO data-katea espero du, baina formatu alternatiboak erabil ditzakezu erabiltzen ari den data-formatua zehazten duen bigarren argumentua ematen baduzu.
const isoDate = une ('2026-02-21T09:00:00'); const formattedDate = une ('2/21/26 9:00:00', 'L/G/AA h:mm:ss');
console.log(isoDate); // Momentua<2026-02-21T09:00:00-05:00>
console.log(formateatuData); // Momentua<2026-02-21T09:00:00-05:00>
Bertsio zaharretan, Moment-ek aukerarik onena izango luke formateatutako edozein data-kate analizatzeko. Horrek ezusteko emaitzak ekar ditzake. Adibidez, 2026-03-02 otsailaren 2a ala martxoaren 3a da? Hori dela eta, Moment-en bertsio berriek zaharkitze-abisu nabarmena erakusten dute ISO formatuko data-katerik gabe deitzen bada (nahi den formatua duen bigarren argumentua ere ematen ez bada). Temporal-ek formateatutako data-katea soilik analizatuko du. Kateak ISO 8601 formatua edo bere luzapena, RFC 9557, bete behar du. Bat ez datorren data kate bat from metodo batera pasatzen bada, Temporal-ek RangeError bat botako du.
// RFC 9557 data kate bat erabiliz const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// Data kate ezezagun bat erabiliz const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Denbora-errorea: Karaktere baliogabea urteko balioa analizatzean.
Data-katearen eskakizun zehatzak sortzen ari zaren denborazko objektu motaren araberakoak dira. Goiko adibidean, Temporal.Instant-ek ISO osoa behar du8601 edo RFC 9557 data-katea ordu-eremuaren desplazamenduarekin data eta ordua zehazten dituena, baina PlainDate edo PlainTime objektuak ere sor ditzakezu data-formatuaren azpimultzo bat erabiliz. 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
Kontuan izan kate hauek oraindik espero den formatua bete behar dutela, bestela errore bat botako da.
// Bat ez datozen denbora-kateak erabiliz. Hauek guztiek RangeError bat botako dute. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Pro aholkua: ISO ez diren kateak maneiatzea Temporal-ek fidagarritasuna lehenesten duelako, ez da 2026-01-02 bezalako kate baten formatua asmatzen saiatuko. Zure datu-iturburuak halako kateak erabiltzen baditu, kateen manipulazioa egin beharko duzu balioak 2026-02-01 bezalako ISO kate batean berrantolatzeko, Temporal-ekin erabiltzen saiatu aurretik.
Formateatzea Momentu edo Denborazko objektu bat duzunean, ziurrenik formateatutako kate bihurtu nahi izango duzu noizbait. Momentua pixka bat laburragoa den kasua da. Objektuaren formatu-metodoari deitzen diozu nahi duzun data-formatua deskribatzen duen token kate batekin. const data = momentua();
console.log(data.format('MM/DD/AAAA')); // 2026/02/22
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 2026ko otsailaren 22a, 20:18:30
Bestalde, Temporal-ek pixka bat hitz gehiago izatea eskatzen dizu. Objektu tenporalak, Instant adibidez, toLocaleString metodo bat dute, objektu baten propietate gisa zehaztutako hainbat formatu-aukera onartzen dituena.
const data = Denboraldia.Orain.instant();
// argumenturik gabe, uneko lokalerako formatu lehenetsia lortuko dugu console.log(date.toLocaleString()); // 2026/02/22, 20:23:36 (en-US-en lokalizazioa suposatuz)
// formatu-aukerak pasatu formatu-kate pertsonalizatu bat sortzeko console.log(date.toLocaleString('eu-US', { hilabete: 'luze', eguna: 'zenbakizkoa', urtea: 'zenbakizkoa', ordua: '2 zifra', minutua: '2 zifra' })); // 2026ko otsailaren 22an, 20:23an
// formatu-katean nahi dituzun eremuak soilik pasatu console.log(date.toLocaleString('eu-US', { hilabete: 'laburra', eguna: 'zenbakizkoa' })); // Otsailak 22
Data tenporalaren formatuak Intl.DateTimeFormat APIa erabiltzen du (nabigatzaile modernoetan jada eskuragarri dagoena) kaputxa azpian. Horrek esan nahi du DateTimeFormat objektu berrerabilgarri bat sor dezakezula zure formatu-aukera pertsonalizatuekin, eta, ondoren, denborazko objektuak bere formatu-metodora pasa ditzakezu. Horregatik, ez du onartzen Moment-ek bezalako data formatu pertsonalizatuak. 'Q1 2026' edo beste formatu espezializatu bat bezalako zerbait behar baduzu, baliteke data-formateatzeko kode pertsonalizaturen bat behar izatea edo hirugarrenen liburutegi batera jotzea. const formateatu = new Intl.DateTimeFormat('eu-US', { hilabetea: '2 zifra', eguna: '2 zifra', urtea: 'zenbakizkoa' });
const data = Denboraldia.Orain.instant(); console.log(formateatu.formatua(data)); // 2026/02/22
Moment-en formatu-tokenak idazteko errazagoak dira, baina ez dira tokiko errespetatzen. Formatuak "kode gogorra" adierazten du, hala nola hilabete/egun ordena. Konfigurazio-objektu bat erabiltzearen abantaila, Temporal-ek egiten duen bezala, da automatikoki egokituko dela edozein tokitara eta formatu egokia erabiltzea. const data = Denboraldia.Orain.instant();
const formatOptions = { hilabetea: 'zenbakizkoa', eguna: 'zenbakizkoa', urtea: 'zenbakizkoa' };
console.log(date.toLocaleString('eu-US', formatOptions)); // 2026/02/22
console.log(date.toLocaleString('eu-GB', formatOptions)); // 2026/02/22
Dataren kalkuluak Aplikazio askotan, data batean kalkulu batzuk egiten amaitu beharko duzu. Baliteke denbora-unitateak gehitu edo kendu nahi izatea (egunak, orduak, segundoak, etab.). Esate baterako, uneko data baduzu, baliteke erabiltzaileari hemendik astebeteko data erakutsi nahi izatea. Momentuko objektuek batuketa eta kenketa bezalako metodoak dituzte eragiketa horiek egiten dituztenak. Funtzio hauek balio bat eta unitate bat hartzen dute, adibidez: add(7, 'egun'). Momentuaren eta Tenporalaren arteko desberdintasun oso garrantzitsu bat, ordea, dataren kalkulu hauek egitean, azpian dagoen objektua aldatu egiten da eta jatorrizko balioa galtzen da. const orain = momentua();
console.log(orain); // Momentua<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'egunak'); console.log(hurrengo astean); // Momentua<2026-03-03T20:08:36-05:00>
// Gotcha - jatorrizko objektua mutatu egin zen console.log(orain); // Momentua<2026-03-03T20:08:36-05:00>
Jatorrizko data gal ez dadin, Moment objektuan klonari dei diezaiokezu kopia bat sortzeko. const orain= momentua(); const nextWeek = now.clone().add(7, 'egunak');
console.log(orain); // Momentua<2026-02-24T20:12:55-05:00>
console.log(hurrengo astean); // Momentua<2026-03-03T20:12:55-05:00>
Bestalde, denborazko objektuak aldaezinak dira. Instant, PlainDate eta abar bezalako objektu bat sortu ondoren, objektu horren balioa ez da inoiz aldatuko. Objektu tenporalek batuketa eta kenketa metodoak ere badituzte. Denboraldia apur bat hauskorra da zein denbora-unitate gehi daitezkeen objektu-motari buruz. Adibidez, ezin dituzu egunak gehitu Instant batean:
const now = Denboraldia.Orain.instant(); const hurrengo astea = orain.gehitu({ egun: 7}); // RangeError: Denbora-errorea: Unitate handiena ezin da data-unitatea izan
Hau da, Instant objektuek denbora-puntu zehatz bat adierazten dutelako UTC-n eta egutegiarekiko agnostiko direlako. Egunaren iraupena ordu-eremuaren arauetan oinarrituta alda daitekeenez, adibidez, Udako Ordua, kalkulu hau ez dago erabilgarri Instant batean. Hala ere, eragiketa hau beste objektu mota batzuetan egin dezakezu, hala nola PlainDateTime batean: const now = Temporal.Now.plainDateTimeISO (); console.log(now.toLocaleString()); // 2026/02/24, 20:23:59
const hurrengo astea = orain.gehitu({ egun: 7});
// Kontuan izan jatorrizko PlainDateTime-k aldatu gabe jarraitzen duela console.log(now.toLocaleString()); // 2026/02/24, 20:23:59
console.log(nextWeek.toLocaleString()); // 2026/03/03, 20:23:59
Bi Momentu edo Denborazko objekturen artean zenbat denbora dagoen ere kalkula dezakezu. Moment-en diff funtzioarekin, granularitaterako unitate bat eman behar duzu, bestela milisegundotan itzuliko du aldea. konst data1 = une ('2026-02-21T09:00:00'); konst data2 = une ('2026-02-22T10:30:00');
console.log(data2.diff(data1)); // 91800000
console.log (data2.diff (data1, 'egunak')); // 1
Temporal objektu batekin hori egiteko, beste Temporal objektu bat pasa diezaiokezu bere metodoetara arte edo geroztik. Honek denbora-diferentziari buruzko informazioa duen Temporal.Duration objektu bat itzultzen du. Iraupena objektuak diferentziaren osagai bakoitzerako propietateak ditu, eta ISO 8601 iraupen-katea ere sor dezake denbora-aldea adierazten duena.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// greatUnit-ek irudikatzeko denbora-unitate handiena zehazten du // iraupenaren kalkuluan const diff = data2.hastatik (data1, {Unitate handiena: 'eguna' });
console.log(diff.days); // 1
console.log (ordu desberdinak); // 1
console.log (diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 iraupen katea: egun 1, ordu 1, 30 minutu)
Datak eta orduak alderatuz Momentek eta Temporalek datak eta orduak konparatzen uzten dizute zein den bestearen aurretik zehazteko, baina APIarekin ikuspegi desberdinak hartu. Momentu-k isBefore, isAfter eta isSame bezalako metodoak eskaintzen ditu Moment bi objektu alderatzeko. konst data1 = une ('2026-02-21T09:00:00'); konst data2 = une ('2026-02-22T10:30:00');
console.log(data1.isBefore(data2)); // egia
Temporal-ek konparazio-metodo estatiko bat erabiltzen du mota bereko bi objekturen arteko konparazioa egiteko. -1 ematen du lehen data bigarrenaren aurretik badator, 0 berdinak badira edo 1 lehen data bigarrenaren ondoren badator. Hurrengo adibideak PlainDate bi objektu nola alderatu erakusten du. Temporal.PlainDate.compare-ren bi argumentu PlainDate objektuak izan behar dira.
const date1 = Temporal.PlainDate.from ({ urtea: 2026, hilabetea: 2, eguna: 24}); const date2 = Temporal.PlainDate.from ({ urtea: 2026, hilabetea: 3, eguna: 24});
// data1 data2 baino lehen dator, beraz -1 console.log(Temporal.PlainDate.compare(data1, date2));
// Errorea mota ezberdineko bi objektu konparatzen saiatzen bagara console.log(Temporal.PlainDate.compare(data1, Temporal.Now.instant())); // TypeError: Denbora-errorea: PlainDate eremu baliogabeak eman dira.
Bereziki, honek denborazko objektuen array bat kronologikoki ordenatzea errazten du. // Temporal.PlainDate objektuen array bat konst datak = [ ... ];
// Erabili Temporal.PlainDate.compare konparatzaile funtzio gisa datak.sort(Temporal.PlainDate.compare);
Ordu-eremuaren bihurketak Oinarrizko Moment liburutegiak ez du onartzen ordu-eremuaren bihurketak. Funtzionalitate hau behar baduzu, une-timezone paketea ere instalatu behar duzu. Pakete hau ez da zuhaitzez astintzen, eta, beraz, zure sortaren tamainan nabarmen gehi dezake. Une-ordu-zona instalatu ondoren, Moment objektuak ordu-eremu desberdinetara bihur ditzakezu tz metodoarekin. Momentuko beste eragiketekin gertatzen den bezala, honek azpian dagoena aldatzen duobjektua. // AEBetako Ekialdeko ordua suposatuz const orain = momentua(); console.log(orain); // Momentua<2026-02-28T20:08:20-05:00>
// Bihurtu Pazifikoko ordura. // Jatorrizko Ekialdeko denbora galdu da. now.tz('America/Los_Angeles'); console.log(orain); // Momentua<2026-02-28T17:08:20-08:00>
Ordu-eremuaren funtzionaltasuna Temporal APIan integratuta dago Temporal.ZonedDateTime objektu bat erabiltzean. Objektu horiek withTimeZone metodo bat barne hartzen dute, ZonedDateTime berri bat itzultzen duena, une bera adierazten duena, baina zehaztutako ordu-eremuan. // Berriz ere, AEBetako Ekialdeko ordua suposatuz const now = Temporal.Now.zonedDateTimeISO (); console.log(now.toLocaleString()); // 2026/02/28, 20:12:02 EST
// Bihurtu Pazifikoko ordura const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 2026/02/28, 17:12:02 PST
// Jatorrizko objektuak aldatu gabe jarraitzen du console.log(now.toLocaleString()); // 2026/02/28, 20:12:02 EST
Oharra: toLocaleString-ek itzultzen dituen formateatutako balioak, izenak dioen bezala, lokalaren araberakoak dira. Lagin-kodea en-US lokalean garatu da, beraz, formatua hau da: 2026/02/28, 5:12:02 PM PST. Beste toki batean, hau ezberdina izan daiteke. Adibidez, en-GB lokalean, 28/2/2026, 17:12:02 GMT-8 bezalako zerbait lortuko zenuke. Mundu errealeko birfaktorizazioa Demagun ordu-zonetan gertaerak antolatzeko aplikazio bat eraikitzen ari garela. Aplikazio honen zati bat funtzio bat da, getEventTimes, eta ISO 8601 kate bat hartzen du gertaeraren ordua eta data, tokiko ordu-eremua eta xede-ordu-eremua adierazten dituena. Funtzioak formateatutako ordu- eta data-kateak sortzen ditu ekitaldirako bi ordu-eremuetan. Funtzioari baliozko ordua/data kate bat ematen bazaio, errore bat botako du. Hona hemen jatorrizko inplementazioa, Moment erabiliz (une-timezone paketea ere erabili behar da).
inportatu unea 'moment-timezone'-tik;
getEventTimes funtzioa (inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Sortu hasierako unea erabiltzailearen ordu-eremuan const gertaeraDenbora = momentua.tz( inputString, momentua.ISO_8601, // ISO 8601 kate bat espero egia, // Analisi zorrotza userTimeZone );
// Errore bat bota inputString-ek baliozko datarik adierazten ez badu bada (!eventTime.isValid()) { throw new Error('Data/orduaren sarrera baliogabea'); }
// 2. Kalkulatu xede-denbora // KRITIKOA: Klonatu behar dugu, edo 'eventTime' betiko aldatzen da! const targetTime = eventTime.clone().tz(targetTimeZone);
itzuli { tokikoa: eventTime.format(timeFormat), xedea: targetTime.format(timeFormat), }; }
const ordutegia = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/Londres', );
console.log(ordutegia.local); // 2026ko martxoak 5, 15:00:00 EST
console.log (programazioa.helburua); // 2026ko martxoaren 5a, 20:00:00 GMT
Adibide honetan, espero den data-formatua erabiltzen ari gara ISO 8601, Moment-en integratuta dagoena. Analisi zorrotza ere erabiltzen ari gara, hau da, Moment ez da formatuarekin bat ez datorren data kate batekin asmatzen saiatuko. ISO ez den data kate bat pasatzen bada, data objektu baliogabea izango da eta errore bat botako dugu. Denboraldiaren ezarpenak antzeko itxura du, baina funtsezko desberdintasun batzuk ditu.
getEventTimes funtzioa (inputString, userTimeZone, targetTimeZone) { // 1. Analizatu sarrera zuzenean Instant batean, eta gero sortu // ZonedDateTime bat erabiltzailearen eremuan. const instant = Temporal.Instant.from (inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. Bihurtu xede-zona // Honek automatikoki objektu BERRIA itzultzen du; 'eventTime' segurua da. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formateatu Intl erabiliz (integratua) konst aukerak = { urtea: 'zenbakizkoa', hilabete: 'laburra', eguna: 'zenbakizkoa', ordua: 'zenbakizkoa', minutua: '2 zifra', bigarrena: '2 zifra', timeZoneName: 'laburra' };
itzuli { lokala: eventTime.toLocaleString (nabigatzailea.hizkuntza, aukerak), xedea: targetTime.toLocaleString(nabigatzailea.hizkuntza, aukerak) }; }
const ordutegia = getEventTimes( '2026-03-05T15:00-05:00', 'Amerika/New_York', 'Europa/Londres', );
console.log(ordutegia.local); // 2026ko martxoak 5, 15:00:00 EST
console.log (programazioa.helburua); // 2026ko martxoaren 5a, 20:00:00 GMT
Momentuarekin, ondoriozko data-kateetarako formatu-kate bat esplizituki zehaztu behar dugu. Erabiltzailearen kokapena edo tokikoa edozein izanda ere, gertaeren orduak 2026ko martxoaren 5a, 3:00:00 gisa formatuko dira beti.pm EST. Gainera, ez dugu esplizituki salbuespenik bota beharrik. Temporal.Instant.from kate baliogabe bat pasatzen bada, Temporal-ek salbuespena botako digu. Kontuan izan behar den gauza bat da analisi zorrotzarekin ere, Moment bertsioa arinagoa dela. Tenporalak katearen amaieran ordu-eremuaren desplazamendua behar du. Kontuan izan behar duzu navigator.language erabiltzen ari garenez, kode hau arakatzaile-ingurunean soilik exekutatuko dela, navigator ez baitago Node.js ingurune batean definituta. Temporal inplementazioak arakatzailearen uneko lokalizazioa erabiltzen du (navigator.language), beraz, erabiltzaileak automatikoki jasoko ditu gertaeren orduak bere tokiko orduaren formatuan formateatuta. AEBetako lokalean, hau da 2026ko martxoaren 5a, 15:00:00 EST. Hala ere, erabiltzailea Londresen badago, adibidez, gertaeren orduak 2026ko martxoaren 5ean, 15:00:00 GMT-5 gisa formatuko dira. Laburpena
Ekintza Momentua.js Tenporala Uneko ordua momentua() Temporal.Now.zonedDateTimeISO() ISO analizatzen une (str) Denboral.Istantea.from(str) Gehitu denbora .add(7, 'egunak') (aldatzen du) .add({ egun: 7}) (objektu berria) Aldea .diff(besteak, 'orduak') .zenetik(beste).orduak Ordu-eremua .tz('Zona/Izena') .withTimeZone('Zona/Izena')
Lehen begiratuan, aldea zertxobait desberdina izan daiteke (eta Temporal-en kasuan, batzuetan zehatzagoa eta zorrotzagoa) sintaxia, baina Moment.js-en gainean Temporal erabiltzeak abantaila nagusi batzuk ditu:
Esplizituagoa izateak ezusteko eta nahi gabeko akats gutxiago esan nahi du. Momentua arinagoa dela dirudi, baina "asmakizunak" dakartza, eta horrek batzuetan data okerrak sor ditzake. Temporal zerbait baliogabea ematen badiozu, errore bat botatzen du. Kodea exekutatzen bada, badakizu baliozko data bat duzula. Momentu-k tamaina garrantzitsua gehitu diezaioke aplikazio-sortari, batez ere une-ordu-eremuaren paketea erabiltzen ari bazara. Temporal-ek ez du ezer gehitzen (zure xede arakatzaileetan bidalitakoan). Aldaezintasunak datu-aldaketak eta eragiketak egitean datuak inoiz galduko edo gainidatziko ez dituzula konfiantza ematen dizu. Denboraren irudikapen desberdinak (Instant, PlainDateTime, ZonedDateTime) zure eskakizunen arabera, non Moment beti UTC ordu-zigilu baten inguruko bilgarri bat den. Temporal-ek Intl APIak erabiltzen ditu data formateatzeko, hau da, tokian tokiko formatua izan dezakezula tokenak esplizituki zehaztu beharrik gabe.
Polyfill-ari buruzko oharrak Arestian esan bezala, Temporal polyfill bat dago eskuragarri, @js-temporal/polyfill izeneko npm pakete gisa banatuta. Gaur egun Temporal erabili nahi baduzu, polyfill hau beharko duzu oraindik APIa bidali ez duten Safari bezalako arakatzaileak onartzeko. Honen berri txarra da zure sortaren tamainara gehituko dela. Berri ona da oraindik momentu edo une-ordu-zona baino nabarmen gutxiago gehitzen duela. Hona hemen Bundlephobia.com-ek, npm paketeen tamainari buruzko informazioa aurkezten duen webguneak, Bundlephobia.com-ek jakinarazitako sorta-tamainen konparaketa bat (egin klik pakete-izen bakoitzaren gainean Bundlephobia azterketa ikusteko):
Paketea Txikitua Txikitua eta gzipped @js-temporal/polyfill 154,1 kB 44,1 kB momentua 294,4 kB 75,4 kB une-ordu-eremua 1 MB 114,2 kB
Polyfill-ek memoriaren erabileraren inguruan errendimendu arazo batzuk ere izan ditu historikoki, eta idazteko unean, alfa egoeran dagoela jotzen da. Horregatik, agian ez duzu ekoizpenean erabili nahi egoera helduago batera iritsi arte. Beste berri ona da, zorionez, polyfill-a askoz gehiago beharko ez dela (arakatzaile zaharragoak onartzen ez badituzu, noski). Idazteko unean, Temporal Chrome, Edge eta Firefox-en bidali da. Oraindik ez dago Safari-n guztiz prest, nahiz eta badirudi azken Teknologiaren Aurrebista exekutatzeko bandera batekin erabilgarri dagoela.
