Halos anumang uri ng application na nakasulat sa JavaScript ay gumagana sa mga oras o petsa sa ilang kapasidad. Sa simula, ito ay limitado sa built-in na Date API. Kasama sa API na ito ang pangunahing pag-andar, ngunit medyo limitado sa kung ano ang magagawa nito. Ang mga third-party na library tulad ng Moment.js, at mga built-in na API sa ibang pagkakataon tulad ng mga Intl API at ang bagong Temporal API, ay nagdaragdag ng higit na kakayahang umangkop sa pagtatrabaho sa mga oras at petsa. Ang Pagbangon At Pagbagsak ng Sandali.js Ang Moment.js ay isang JavaScript library na may makapangyarihang mga utility para sa pagtatrabaho sa mga oras at petsa. Kabilang dito ang mga nawawalang feature mula sa pangunahing Date API, tulad ng pagmamanipula ng time zone, at ginagawang mas simple ang maraming karaniwang operasyon. Kasama rin sa Moment ang mga function para sa pag-format ng mga petsa at oras. Ito ay naging isang malawakang ginagamit na aklatan sa maraming iba't ibang mga aplikasyon. Gayunpaman, nagkaroon din ng bahagi ang Moment sa mga isyu. Ito ay isang malaking library, at maaaring magdagdag ng malaki sa laki ng bundle ng isang application. Dahil hindi sinusuportahan ng library ang tree shaking (isang feature ng mga modernong bundler na maaaring mag-alis ng mga hindi nagamit na bahagi ng mga library), kasama ang buong Moment library kahit na gumamit ka lang ng isa o dalawa sa mga function nito. Ang isa pang isyu sa Moment ay ang katotohanan na ang mga bagay na nilikha nito ay nababago. Ang pagtawag sa ilang partikular na function sa isang Moment object ay may mga side effect at na-mutate ang halaga ng object na iyon. Maaari itong humantong sa hindi inaasahang pag-uugali o mga bug. Noong 2020, nagpasya ang mga maintainer ng Moment na ilagay ang library sa maintenance mode. Walang ginagawang bagong feature development, at inirerekomenda ng mga maintainer ang paggamit nito para sa mga bagong proyekto. Mayroong iba pang mga aklatan ng petsa ng JavaScript, tulad ng date-fns, ngunit mayroong bagong manlalaro sa bayan, isang API na direktang binuo sa JavaScript: Temporal. Isa itong bagong pamantayan na pumupuno sa mga butas ng orihinal na Date API pati na rin ang paglutas ng ilan sa mga limitasyon na makikita sa Moment at iba pang mga library. Ano ang Temporal? Ang Temporal ay isang bagong oras at petsa ng API na idinaragdag sa pamantayan ng ECMAScript, na tumutukoy sa modernong JavaScript. Noong Marso 20266, umabot na ito sa Stage 4 ng proseso ng TC39 (ang komite na nangangasiwa sa mga panukala at pagdaragdag sa wikang JavaScript), at isasama sa susunod na bersyon ng detalye ng ECMAScript. Naipatupad na ito sa ilang mga browser: Chrome 144+ at Firefox 139+, na inaasahang susunod ang Safari. Available din ang polyfill para sa mga hindi sinusuportahang browser at Node.js. Ang Temporal API ay lumilikha ng mga bagay na, sa pangkalahatan, ay kumakatawan sa mga sandali sa oras. Ang mga ito ay maaaring full-time at date stamp sa isang partikular na time zone, o maaari silang maging generic na instance ng "wall clock" na oras nang walang anumang time zone o impormasyon ng petsa. Ang ilan sa mga pangunahing tampok ng Temporal ay kinabibilangan ng:
Mga oras na mayroon o walang mga petsa. Ang isang Temporal na bagay ay maaaring kumatawan sa isang tiyak na oras sa isang tiyak na petsa, o isang oras na walang anumang impormasyon ng petsa. Ang isang tiyak na petsa, nang walang oras, ay maaari ding katawanin. Suporta sa time zone. Ganap na alam ng mga temporal na bagay ang time zone at maaaring i-convert sa iba't ibang time zone. Sinusuportahan din ng Moment ang mga time zone, ngunit nangangailangan ito ng karagdagang library ng moment-timezone. Kawalang pagbabago. Kapag ang isang Temporal na bagay ay nalikha, hindi na ito mababago. Hindi binabago ng mga conversion ng time arithmetic o time zone ang pinagbabatayan na bagay. Sa halip, bumubuo sila ng bagong Temporal na bagay. 1-based na pag-index. Ang isang karaniwang pinagmumulan ng mga bug sa Date API (pati na rin sa Moment) ay ang mga buwan ay zero-index. Nangangahulugan ito na ang Enero ay buwan 0, sa halip na buwan 1 na naiintindihan nating lahat sa totoong buhay. Ang pansamantalang pag-aayos nito sa pamamagitan ng paggamit ng 1-based na pag-index — Enero ay buwan 1. Naka-built in ito sa browser. Dahil ang Temporal ay isang API sa browser mismo, wala itong idaragdag sa laki ng bundle ng iyong application.
Mahalaga ring tandaan na ang Date API ay hindi mawawala. Habang pinapalitan ng Temporal ang API na ito, hindi ito inaalis o hindi na ginagamit. Maraming application ang masisira kung biglang inalis ng mga browser ang Date API. Gayunpaman, tandaan din na ang Moment ay itinuturing na ngayong isang legacy na proyekto sa mode ng pagpapanatili. Sa natitirang bahagi ng artikulo, titingnan natin ang ilang "mga recipe" para sa paglipat ng Moment-based na code sa bagong Temporal API. Simulan natin ang refactoring! Paglikha ng Mga Bagay sa Petsa at Oras Bago natin mamanipula ang mga petsa at oras, kailangan nating lumikha ng mga bagay na kumakatawan sa kanila. Para gumawa ng Moment object na kumakatawan sa kasalukuyang petsa at oras, gamitin ang moment function. const ngayon = sandali(); console.log(ngayon); // Sandali<2026-02-18T21:26:29-05:00>
Ang bagay na ito ay maaari na ngayong i-format o manipulahin kung kinakailangan.
// i-convert sa UTC //babala: Pina-mutate nito ang object ng Moment at inilalagay ito sa UTC mode! console.log(now.utc()); // Sandali<2026-02-19T02:26:29Z>
// mag-print ng na-format na string - tandaan na ginagamit nito ang oras ng UTC ngayon console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // 02/19/2026 02:27:07 am
Ang pangunahing bagay na dapat tandaan tungkol sa Moment ay ang isang Moment object ay palaging may kasamang impormasyon tungkol sa oras at petsa. Kung kailangan mo lang gumamit ng impormasyon sa oras, karaniwan itong maayos, ngunit maaari itong magdulot ng hindi inaasahang pag-uugali sa mga sitwasyon tulad ng Daylight Saving Time o mga leap year, kung saan maaaring magkaroon ng epekto ang petsa sa mga kalkulasyon ng oras. Ang temporal ay mas nababaluktot. Maaari kang lumikha ng isang bagay na kumakatawan sa kasalukuyang petsa at oras sa pamamagitan ng paggawa ng isang Temporal.Instant na bagay. Ito ay kumakatawan sa isang punto sa oras na tinukoy ng oras mula noong “the epoch” (hatinggabi UTC noong Enero 1, 1970). Maaaring i-refer ng Temporal ang instant na ito sa oras na may katumpakan sa antas ng nanosecond. const now = Temporal.Now.instant();
// tingnan ang mga raw nanosecond mula noong panahon console.log(now.epochNanoseconds); // 1771466342612000000n
// format para sa UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// format para sa isang partikular na time zone console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Maaari ding malikha ang mga instant na bagay para sa isang tiyak na oras at petsa sa pamamagitan ng paggamit ng mula sa static na pamamaraan.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// I-format ang instant sa lokal na time zone. Tandaan na ito lang ang kumokontrol // ang pag-format - hindi nito binabago ang bagay tulad ng ginagawa ng moment.utc. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
Maaari ka ring lumikha ng iba pang mga uri ng Temporal na bagay, kabilang ang:
Temporal.PlainDate: Isang petsa na walang impormasyon sa oras. Temporal.PlainTime: Isang oras na walang impormasyon sa petsa. Temporal.ZonedDateTime: Isang petsa at oras sa isang partikular na time zone.
Ang bawat isa sa mga ito ay may isang mula sa pamamaraan na maaaring tawagan sa isang bagay na tumutukoy sa petsa at/o oras, o isang string ng petsa upang i-parse. // Date lang const ngayon = Temporal.PlainDate.from({ taon: 2026, buwan: 2, // tandaan na ginagamit namin ang 2 para sa Pebrero araw: 18 }); console.log(today.toString()); // 2026-02-18
// Sandali lang const lunchTime = Temporal.PlainTime.from({ oras: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Isang petsa at oras sa US Eastern time zone const dueAt = Temporal.ZonedDateTime.from({ timeZone: 'America/New_York', taon: 2026, buwan: 3, araw: 1, oras: 12, minuto: 0, pangalawa: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
Pag-parse Sinakop namin ang programmatic na paglikha ng impormasyon sa petsa at oras. Ngayon tingnan natin ang pag-parse. Ang pag-parse ay isang lugar kung saan mas flexible ang Moment kaysa sa built-in na Temporal API. Maaari mong i-parse ang isang string ng petsa sa pamamagitan ng pagpasa nito sa function ng sandali. Sa isang argumento, inaasahan ng Moment ang isang string ng petsa ng ISO, ngunit maaari kang gumamit ng mga alternatibong format kung magbibigay ka ng pangalawang argumento na tumutukoy sa format ng petsa na ginagamit.
const isoDate = sandali('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // Sandali<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Sandali<2026-02-21T09:00:00-05:00>
Sa mas lumang mga bersyon, ang Moment ay gagawa ng pinakamahusay na hula upang mai-parse ang anumang arbitraryong na-format na string ng petsa. Ito ay maaaring humantong sa mga hindi inaasahang resulta. Halimbawa, ang 02-03-2026 ba ay Pebrero 2 o Marso 3? Para sa kadahilanang ito, ang mga mas bagong bersyon ng Moment ay nagpapakita ng kitang-kitang babala sa paghinto sa paggamit kung ito ay tinatawag na walang ISO formatted date string (maliban kung ang pangalawang argumento na may gustong format ay ibinigay din). Ipapa-parse lang ng Temporal ang isang partikular na na-format na string ng petsa. Ang string ay dapat na sumusunod sa ISO 8601 na format o ang extension nito, RFC 9557. Kung ang isang hindi sumusunod na string ng petsa ay ipapasa sa isang mula sa paraan, ang Temporal ay magtapon ng isang RangeError.
// Gamit ang isang string ng petsa ng RFC 9557 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
// Paggamit ng hindi kilalang string ng petsa const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Temporal na error: Di-wastong character habang pinag-parse ang halaga ng taon.
Ang eksaktong mga kinakailangan ng string ng petsa ay nakasalalay sa kung anong uri ng Temporal na bagay ang iyong ginagawa. Sa halimbawa sa itaas, ang Temporal.Instant ay nangangailangan ng isang buong ISO8601 o RFC 9557 na string ng petsa na tumutukoy sa petsa at oras na may offset na time zone, ngunit maaari ka ring gumawa ng mga bagay na PlainDate o PlainTime gamit lamang ang isang subset ng format ng petsa. 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
Tandaan na ang mga string na ito ay dapat pa ring sumunod sa inaasahang format, kung hindi, magkakaroon ng error.
// Paggamit ng hindi sumusunod na mga string ng oras. Ang lahat ng ito ay magtapon ng isang RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
Pro tip: Pangangasiwa sa mga hindi ISO na stringDahil inuuna ng Temporal ang pagiging maaasahan, hindi nito susubukang hulaan ang format ng isang string tulad ng 02-01-2026. Kung gumagamit ang iyong data source ng mga ganoong string, kakailanganin mong gumawa ng ilang manipulasyon ng string upang muling ayusin ang mga value sa isang ISO string tulad ng 2026-02-01 bago subukang gamitin ito sa Temporal.
Pag-format Kapag mayroon ka nang Moment o Temporal na bagay, malamang na gusto mong i-convert ito sa isang naka-format na string sa isang punto. Ito ay isang pagkakataon kung saan ang Moment ay medyo mas maikli. Tinatawag mo ang paraan ng pag-format ng bagay na may isang string ng mga token na naglalarawan sa nais na format ng petsa. const date = sandali();
console.log(date.format('MM/DD/YYYY')); // 02/22/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // ika-22 ng Pebrero 2026, 8:18:30 ng gabi
Sa kabilang banda, hinihiling sa iyo ng Temporal na maging mas verbose. Ang mga temporal na bagay, tulad ng Instant, ay may toLocaleString na paraan na tumatanggap ng iba't ibang mga opsyon sa pag-format na tinukoy bilang mga katangian ng isang bagay.
const date = Temporal.Now.instant();
// na walang mga argumento, makukuha natin ang default na format para sa kasalukuyang lokal console.log(date.toLocaleString()); // 2/22/2026, 8:23:36 PM (ipagpalagay na isang lokal na en-US)
// pass formatting options para makabuo ng custom na format string console.log(date.toLocaleString('en-US', { buwan: 'mahaba', araw: 'numeric', taon: 'numeric', oras: '2-digit', minuto: '2-digit' })); // Pebrero 22, 2026 nang 8:23 PM
// ipasa lang ang mga field na gusto mo sa string ng format console.log(date.toLocaleString('en-US', { buwan: 'maikli', araw: 'numeric' })); // Peb 22
Ang pag-format ng temporal na petsa ay aktwal na gumagamit ng Intl.DateTimeFormat API (na madaling magagamit sa mga modernong browser) sa ilalim ng hood. Nangangahulugan iyon na maaari kang lumikha ng isang magagamit muli na DateTimeFormat object gamit ang iyong mga custom na opsyon sa pag-format, pagkatapos ay ipasa ang mga Temporal na bagay sa paraan ng pag-format nito. Dahil dito, hindi nito sinusuportahan ang mga custom na format ng petsa tulad ng ginagawa ng Moment. Kung kailangan mo ng isang bagay tulad ng 'Q1 2026' o iba pang espesyal na pag-format, maaaring kailangan mo ng ilang custom na code sa pag-format ng petsa o abot para sa isang third-party na library. const formatter = bagong Intl.DateTimeFormat('en-US', { buwan: '2-digit', araw: '2-digit', taon: 'numeric' });
const date = Temporal.Now.instant(); console.log(formatter.format(date)); // 02/22/2026
Ang mga token sa pag-format ng sandali ay mas simple na isulat, ngunit hindi sila locale-friendly. Ang format na string ay "hard code" na mga bagay tulad ng buwan/araw na pagkakasunud-sunod. Ang bentahe ng paggamit ng object ng pagsasaayos, tulad ng ginagawa ng Temporal, ay awtomatikong iaangkop ito sa anumang partikular na lokal at gagamitin ang tamang format. const date = Temporal.Now.instant();
const formatOptions = { buwan: 'numeric', araw: 'numeric', taon: 'numeric' };
console.log(date.toLocaleString('en-US', formatOptions)); // 2/22/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
Mga kalkulasyon ng petsa Sa maraming application, kakailanganin mong magsagawa ng ilang kalkulasyon sa isang petsa. Maaaring gusto mong magdagdag o magbawas ng mga yunit ng oras (mga araw, oras, segundo, atbp.). Halimbawa, kung mayroon kang kasalukuyang petsa, maaaring gusto mong ipakita sa user ang petsa 1 linggo mula ngayon. Ang mga bagay na sandali ay may mga pamamaraan tulad ng pagdaragdag at pagbabawas na nagsasagawa ng mga operasyong ito. Ang mga function na ito ay kumukuha ng value at isang unit, halimbawa: add(7, 'days'). Ang isang napakahalagang pagkakaiba sa pagitan ng Moment at Temporal, gayunpaman, ay kapag ginagawa ang mga kalkulasyon ng petsa na ito, ang pinagbabatayan na bagay ay binago at ang orihinal na halaga nito ay nawala. const ngayon = sandali();
console.log(ngayon); // Sandali<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log(nextWeek); // Sandali<2026-03-03T20:08:36-05:00>
// Gotcha - ang orihinal na bagay ay na-mutate console.log(ngayon); // Sandali<2026-03-03T20:08:36-05:00>
Upang maiwasang mawala ang orihinal na petsa, maaari kang tumawag ng clone sa object ng Moment para gumawa ng kopya. const ngayon= sandali(); const nextWeek = now.clone().add(7, 'days');
console.log(ngayon); // Sandali<2026-02-24T20:12:55-05:00>
console.log(nextWeek); // Sandali<2026-03-03T20:12:55-05:00>
Sa kabilang banda, ang mga Temporal na bagay ay hindi nababago. Kapag nakagawa ka na ng object tulad ng Instant, PlainDate, at iba pa, hindi na magbabago ang value ng object na iyon. Ang mga temporal na bagay ay mayroon ding mga paraan ng pagdaragdag at pagbabawas. Ang temporal ay medyo mapili kung aling mga yunit ng oras ang maaaring idagdag sa kung aling mga uri ng bagay. Halimbawa, hindi ka maaaring magdagdag ng mga araw sa isang Instant:
const now = Temporal.Now.instant(); const nextWeek = now.add({ days: 7 }); // RangeError: Temporal na error: Ang pinakamalaking unit ay hindi maaaring isang unit ng petsa
Ito ay dahil ang mga Instant na bagay ay kumakatawan sa isang partikular na punto ng oras sa UTC at mga kalendaryo-agnostiko. Dahil maaaring magbago ang haba ng isang araw batay sa mga panuntunan sa time zone gaya ng Daylight Saving Time, hindi available ang kalkulasyong ito sa isang Instant. Gayunpaman, maaari mong isagawa ang operasyong ito sa iba pang mga uri ng mga bagay, tulad ng isang PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({ days: 7 });
// Tandaan na ang orihinal na PlainDateTime ay nananatiling hindi nagbabago console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
console.log(nextWeek.toLocaleString()); // 3/3/2026, 8:23:59 PM
Maaari mo ring kalkulahin kung gaano katagal ang pagitan ng dalawang Moment o Temporal na bagay. Sa diff function ng Moment, kailangan mong magbigay ng unit para sa granularity, kung hindi, ibabalik nito ang pagkakaiba sa millisecond. const date1 = sandali('2026-02-21T09:00:00'); const date2 = sandali('2026-02-22T10:30:00');
console.log(date2.diff(date1)); // 91800000
console.log(date2.diff(date1, 'days')); // 1
Upang gawin ito sa isang Temporal na bagay, maaari mong ipasa ang isa pang Temporal na bagay sa mga pamamaraan nito hanggang o mula noong. Nagbabalik ito ng Temporal.Duration na bagay na naglalaman ng impormasyon tungkol sa pagkakaiba ng oras. Ang bagay na Duration ay may mga katangian para sa bawat bahagi ng pagkakaiba, at maaari ding bumuo ng string ng tagal ng ISO 8601 na kumakatawan sa pagkakaiba ng oras.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// Tinukoy ng pinakamalakingUnit ang pinakamalaking yunit ng oras na kakatawanin // sa pagkalkula ng tagal const diff = date2.since(date1, { largestUnit: 'day' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 duration string: 1 araw, 1 oras, 30 minuto)
Paghahambing ng mga Petsa at Oras Parehong hinahayaan ka ng Moment at Temporal na ihambing ang mga petsa at oras upang matukoy kung alin ang mauuna sa isa, ngunit gumamit ng iba't ibang diskarte sa API. Nagbibigay ang Moment ng mga pamamaraan tulad ng isBefore, isAfter, at isSame para ihambing ang dalawang object ng Moment. const date1 = sandali('2026-02-21T09:00:00'); const date2 = sandali('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // totoo
Gumagamit ang Temporal ng static na paraan ng paghahambing upang magsagawa ng paghahambing sa pagitan ng dalawang bagay na may parehong uri. Nagbabalik ito ng -1 kung ang unang petsa ay nauuna sa pangalawa, 0 kung sila ay pantay, o 1 kung ang unang petsa ay dumating pagkatapos ng pangalawa. Ipinapakita ng sumusunod na halimbawa kung paano ihambing ang dalawang bagay na PlainDate. Ang parehong mga argumento sa Temporal.PlainDate.compare ay dapat na mga PlainDate object.
const date1 = Temporal.PlainDate.from({ year: 2026, month: 2, day: 24 }); const date2 = Temporal.PlainDate.from({ year: 2026, month: 3, day: 24 });
// nauuna ang date1 bago ang date2, kaya -1 console.log(Temporal.PlainDate.compare(date1, date2));
// Error kung susubukan nating paghambingin ang dalawang bagay na magkaibang uri console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Temporal na error: Di-wastong PlainDate field na ibinigay.
Sa partikular, ginagawa nitong madali ang pag-uri-uriin ang isang hanay ng mga Temporal na bagay ayon sa pagkakasunod-sunod. // Isang hanay ng mga bagay na Temporal.PlainDate const petsa = [ ... ];
// gamitin ang Temporal.PlainDate.compare bilang comparator function dates.sort(Temporal.PlainDate.compare);
Mga Conversion ng Time Zone Hindi sinusuportahan ng core Moment library ang mga conversion ng time zone. Kung kailangan mo ang functionality na ito, kailangan mo ring i-install ang moment-timezone package. Ang package na ito ay hindi naaalog ng puno, at samakatuwid ay maaaring magdagdag ng malaki sa laki ng iyong bundle. Kapag na-install mo na ang moment-timezone, maaari mong i-convert ang mga Moment object sa iba't ibang time zone gamit ang tz method. Tulad ng iba pang mga operasyon ng Moment, binabago nito ang pinagbabatayanbagay. // Sa pag-aakalang US Eastern time const ngayon = sandali(); console.log(ngayon); // Sandali<2026-02-28T20:08:20-05:00>
// I-convert sa oras ng Pasipiko. // Nawala ang orihinal na oras sa Silangan. now.tz('America/Los_Angeles'); console.log(ngayon); // Sandali<2026-02-28T17:08:20-08:00>
Ang functionality ng time zone ay binuo sa Temporal API kapag gumagamit ng Temporal.ZonedDateTime object. Kasama sa mga object na ito ang isang withTimeZone method na nagbabalik ng bagong ZonedDateTime na kumakatawan sa parehong sandali sa oras, ngunit sa tinukoy na time zone. // Muli, sa pag-aakalang US Eastern time const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
// I-convert sa oras ng Pasipiko const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 2/28/2026, 5:12:02 PM PST
// Ang orihinal na bagay ay nananatiling hindi nagbabago console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
Tandaan: Ang mga naka-format na halaga na ibinalik ng toLocaleString ay, gaya ng ipinahihiwatig ng pangalan, nakadepende sa lokal. Ang sample code ay binuo sa en-US locale, kaya ang format ay ganito: 2/28/2026, 5:12:02 PM PST. Sa ibang lokal, maaaring iba ito. Halimbawa, sa en-GB locale, makakakuha ka ng isang bagay tulad ng 28/2/2026, 17:12:02 GMT-8. Isang Real-world Refactoring Ipagpalagay na gumagawa kami ng app para sa pag-iskedyul ng mga kaganapan sa mga time zone. Bahagi ng app na ito ay isang function, getEventTimes, na kumukuha ng ISO 8601 string na kumakatawan sa oras at petsa ng kaganapan, isang lokal na time zone, at isang target na time zone. Lumilikha ang function ng mga naka-format na string ng oras at petsa para sa kaganapan sa parehong time zone. Kung bibigyan ang function ng input string na hindi wastong string ng oras/petsa, magkakaroon ito ng error. Narito ang orihinal na pagpapatupad, gamit ang Moment (nangangailangan din ng paggamit ng package ng moment-timezone).
mag-import ng sandali mula sa 'moment-timezone';
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Lumikha ng paunang sandali sa time zone ng user const eventTime = moment.tz( inputString, moment.ISO_8601, // Asahan ang isang ISO 8601 string totoo, // Mahigpit na pag-parse userTimeZone );
// Magtapon ng error kung ang inputString ay hindi kumakatawan sa isang wastong petsa kung (!eventTime.isValid()) { throw new Error('Invalid date/time input'); }
// 2. Kalkulahin ang target na oras // KRITIKAL: Dapat nating i-clone, o ang 'eventTime' ay magbabago magpakailanman! const targetTime = eventTime.clone().tz(targetTimeZone);
ibalik { lokal: eventTime.format(timeFormat), target: targetTime.format(timeFormat), }; }
const schedule = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_York', 'Europe/London', );
console.log(schedule.local); // Mar 5, 2026, 3:00:00 pm EST
console.log(schedule.target); // Mar 5, 2026, 8:00:00 pm GMT
Sa halimbawang ito, gumagamit kami ng inaasahang format ng petsa na ISO 8601, na kapaki-pakinabang na binuo sa Moment. Gumagamit din kami ng mahigpit na pag-parse, na nangangahulugang hindi susubukan ng Moment na hulaan gamit ang string ng petsa na hindi tumutugma sa format. Kung ang isang string ng petsa na hindi ISO ay naipasa, magreresulta ito sa isang di-wastong object ng petsa, at magtapon kami ng isang error. Ang Temporal na pagpapatupad ay mukhang magkatulad, ngunit may ilang pangunahing pagkakaiba.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. I-parse ang input nang direkta sa isang Instant, pagkatapos ay lumikha // isang ZonedDateTime sa zone ng user. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. I-convert sa target zone // Ito ay awtomatikong nagbabalik ng isang BAGONG bagay; Ligtas ang 'eventTime'. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Format gamit ang Intl (built-in) mga pagpipilian sa const = { taon: 'numeric', buwan: 'maikli', araw: 'numeric', oras: 'numeric', minuto: '2-digit', pangalawa: '2-digit', timeZoneName: 'maikli' };
ibalik { lokal: eventTime.toLocaleString(navigator.language, mga opsyon), target: targetTime.toLocaleString(navigator.language, mga opsyon) }; }
const schedule = getEventTimes( '2026-03-05T15:00-05:00', 'America/New_York', 'Europe/London', );
console.log(schedule.local); // Mar 5, 2026, 3:00:00 PM EST
console.log(schedule.target); // Mar 5, 2026, 8:00:00 PM GMT
Sa Moment, kailangan nating tahasang tukuyin ang isang format na string para sa mga resultang string ng petsa. Anuman ang lokasyon o lokal ng user, ang mga oras ng kaganapan ay palaging ipo-format bilang Mar 5, 2026, 3:00:00pm EST. Gayundin, hindi namin kailangang tahasang magtapon ng pagbubukod. Kung may ipapasa na di-wastong string sa Temporal.Instant.from, itatapon ng Temporal ang exception para sa amin. Isang bagay na dapat tandaan na kahit na may mahigpit na pag-parse, ang bersyon ng Moment ay mas maluwag pa rin. Ang temporal ay nangangailangan ng time zone offset sa dulo ng string. Dapat mo ring tandaan na dahil gumagamit kami ng navigator.language, tatakbo lang ang code na ito sa isang browser environment, dahil hindi tinukoy ang navigator sa isang Node.js environment. Ginagamit ng Temporal na pagpapatupad ang kasalukuyang locale ng browser (navigator.language), kaya awtomatikong ma-format ng user ang mga oras ng kaganapan sa kanilang lokal na format ng oras. Sa en-US locale, ito ay Mar 5, 2026, 3:00:00 pm EST. Gayunpaman, kung ang user ay nasa London, halimbawa, ang mga oras ng kaganapan ay ipo-format bilang 5 Mar 2026, 15:00:00 GMT-5. Buod
Aksyon Moment.js Temporal Kasalukuyang panahon sandali() Temporal.Now.zonedDateTimeISO() Pag-parse ng ISO sandali(str) Temporal.Instant.from(str) Magdagdag ng oras .add(7, 'days') (mutates) .add({ days: 7 }) (bagong object) Pagkakaiba .diff(other, 'hours') .since(other).oras Time zone .tz('Zone/Pangalan') .withTimeZone('Zone/Pangalan')
Sa unang tingin, ang pagkakaiba ay maaaring bahagyang naiiba (at sa kaso ng Temporal, kung minsan ay mas verbose at mas mahigpit) syntax, ngunit mayroong ilang pangunahing bentahe sa paggamit ng Temporal sa Moment.js:
Ang pagiging mas tahasan ay nangangahulugan ng mas kaunting mga sorpresa at hindi sinasadyang mga bug. Ang sandali ay maaaring mukhang mas maluwag, ngunit ito ay nagsasangkot ng "hula," na kung minsan ay maaaring magresulta sa mga maling petsa. Kung bibigyan mo ang Temporal ng isang bagay na hindi wasto, ito ay magtapon ng isang error. Kung tatakbo ang code, alam mong mayroon kang wastong petsa. Maaaring magdagdag ng malaking laki ang moment sa bundle ng application, lalo na kung ginagamit mo ang package ng moment-timezone. Walang idinagdag ang Temporal (kapag naipadala na ito sa iyong mga target na browser). Ang kawalan ng pagbabago ay nagbibigay sa iyo ng kumpiyansa na hinding-hindi ka mawawala o mag-o-overwrite ng data kapag nagsasagawa ng mga conversion at pagpapatakbo ng petsa. Iba't ibang representasyon ng oras (Instant, PlainDateTime, ZonedDateTime) depende sa iyong mga kinakailangan, kung saan ang Moment ay palaging isang wrapper sa paligid ng UTC timestamp. Ginagamit ng Temporal ang mga Intl API para sa pag-format ng petsa, na nangangahulugang maaari kang magkaroon ng locale-aware na pag-format nang hindi kinakailangang tahasang tukuyin ang mga token.
Mga Tala Sa Polyfill Gaya ng nabanggit kanina, mayroong available na Temporal polyfill, na ibinahagi bilang npm package na pinangalanang @js-temporal/polyfill. Kung gusto mong gumamit ng Temporal ngayon, kakailanganin mo ang polyfill na ito upang suportahan ang mga browser tulad ng Safari na hindi pa naipapadala ang API. Ang masamang balita dito ay magdaragdag ito sa laki ng iyong bundle. Ang magandang balita ay nagdaragdag pa rin ito ng mas kaunti kaysa sa moment o moment-timezone. Narito ang isang paghahambing ng mga laki ng bundle tulad ng iniulat ng Bundlephobia.com, isang website na nagpapakita ng impormasyon sa mga laki ng npm package (mag-click sa bawat pangalan ng package upang makita ang pagsusuri sa Bundlephobia):
Package Pinaliit Minified at na-gzip @js-temporal/polyfill 154.1 kB 44.1 kB sandali 294.4 kB 75.4 kB sandali-timezone 1 MB 114.2 kB
Ang polyfill ay mayroon ding kasaysayan na nagkaroon ng ilang mga isyu sa pagganap tungkol sa paggamit ng memorya, at sa oras ng pagsulat, ito ay itinuturing na nasa alpha state. Dahil dito, maaaring hindi mo gustong gamitin ito sa produksyon hanggang sa umabot ito sa isang mas mature na estado. Ang iba pang magandang balita ay sana ay hindi na kakailanganin ang polyfill (maliban kung kailangan mong suportahan ang mga mas lumang browser, siyempre). Sa oras ng pagsulat, ang Temporal ay naipadala sa Chrome, Edge, at Firefox. Hindi pa ito handa sa Safari, bagama't mukhang available ito sa isang runtime na flag sa pinakabagong Technology Preview.
