ស្ទើរតែគ្រប់ប្រភេទនៃកម្មវិធីដែលសរសេរក្នុង JavaScript ដំណើរការជាមួយពេលវេលា ឬកាលបរិច្ឆេទក្នុងសមត្ថភាពមួយចំនួន។ នៅដើមដំបូង វាត្រូវបានកំណត់ចំពោះ API កាលបរិច្ឆេទដែលភ្ជាប់មកជាមួយ។ API នេះរួមបញ្ចូលមុខងារជាមូលដ្ឋាន ប៉ុន្តែវាមានកម្រិតណាស់នៅក្នុងអ្វីដែលវាអាចធ្វើបាន។ បណ្ណាល័យភាគីទីបីដូចជា Moment.js និង APIs ដែលភ្ជាប់មកជាមួយនៅពេលក្រោយដូចជា Intl APIs និង Temporal API ថ្មី បន្ថែមភាពបត់បែនកាន់តែច្រើនក្នុងការធ្វើការជាមួយពេលវេលា និងកាលបរិច្ឆេទ។ ការកើនឡើង និងការដួលរលំនៃ Moment.js Moment.js គឺជាបណ្ណាល័យ JavaScript ដែលមានឧបករណ៍ប្រើប្រាស់ដ៏មានអានុភាពសម្រាប់ធ្វើការជាមួយពេលវេលា និងកាលបរិច្ឆេទ។ វារួមបញ្ចូលលក្ខណៈពិសេសដែលបាត់ពី Date API មូលដ្ឋាន ដូចជាការរៀបចំតំបន់ពេលវេលា និងធ្វើឱ្យប្រតិបត្តិការទូទៅជាច្រើនកាន់តែសាមញ្ញ។ Moment ក៏រួមបញ្ចូលមុខងារសម្រាប់ធ្វើទ្រង់ទ្រាយកាលបរិច្ឆេទ និងពេលវេលាផងដែរ។ វាបានក្លាយជាបណ្ណាល័យដែលប្រើយ៉ាងទូលំទូលាយនៅក្នុងកម្មវិធីផ្សេងៗជាច្រើន។ ទោះជាយ៉ាងណាក៏ដោយ Moment ក៏មានបញ្ហារបស់វាដែរ។ វាជាបណ្ណាល័យធំ ហើយអាចបន្ថែមយ៉ាងសំខាន់ទៅលើទំហំកញ្ចប់របស់កម្មវិធី។ ដោយសារតែបណ្ណាល័យមិនគាំទ្រការរញ្ជួយដើមឈើ (លក្ខណៈនៃបណ្តុំទំនើបដែលអាចដកផ្នែកដែលមិនប្រើនៃបណ្ណាល័យ) បណ្ណាល័យ Moment ទាំងមូលត្រូវបានរួមបញ្ចូល បើទោះបីជាអ្នកគ្រាន់តែប្រើមុខងារមួយ ឬពីររបស់វាក៏ដោយ។ បញ្ហាមួយទៀតជាមួយ Moment គឺការពិតដែលថាវត្ថុដែលវាបង្កើតគឺអាចផ្លាស់ប្តូរបាន។ ការហៅមុខងារជាក់លាក់នៅលើវត្ថុ Moment មានផលប៉ះពាល់ និងផ្លាស់ប្តូរតម្លៃនៃវត្ថុនោះ។ នេះអាចនាំឱ្យមានអាកប្បកិរិយា ឬកំហុសដែលមិននឹកស្មានដល់។ នៅឆ្នាំ 2020 អ្នកថែទាំ Moment បានសម្រេចចិត្តដាក់បណ្ណាល័យទៅក្នុងរបៀបថែទាំ។ មិនមានការអភិវឌ្ឍមុខងារថ្មីកំពុងត្រូវបានធ្វើទេ ហើយអ្នកថែទាំណែនាំកុំឱ្យប្រើវាសម្រាប់គម្រោងថ្មី។ មានបណ្ណាល័យកាលបរិច្ឆេទ JavaScript ផ្សេងទៀតដូចជា date-fns ប៉ុន្តែមានអ្នកលេងថ្មីនៅក្នុងទីក្រុង API ដែលត្រូវបានបង្កើតឡើងដោយផ្ទាល់ទៅក្នុង JavaScript: Temporal ។ វាជាស្តង់ដារថ្មីមួយដែលបំពេញក្នុងរន្ធនៃ API កាលបរិច្ឆេទដើម ក៏ដូចជាដោះស្រាយដែនកំណត់មួយចំនួនដែលមាននៅក្នុង Moment និងបណ្ណាល័យផ្សេងទៀត។ តើ Temporal ជាអ្វី? Temporal គឺជា API ពេលវេលា និងកាលបរិច្ឆេទថ្មីដែលត្រូវបានបន្ថែមទៅស្តង់ដារ ECMAScript ដែលកំណត់ JavaScript ទំនើប។ គិតត្រឹមខែមីនា ឆ្នាំ 20266 វាបានឈានដល់ដំណាក់កាលទី 4 នៃដំណើរការ TC39 (គណៈកម្មាធិការដែលត្រួតពិនិត្យសំណើ និងការបន្ថែមទៅលើភាសា JavaScript) ហើយនឹងត្រូវបានបញ្ចូលក្នុងកំណែបន្ទាប់នៃការបញ្ជាក់ ECMAScript ។ វាត្រូវបានអនុវត្តរួចហើយនៅក្នុងកម្មវិធីរុករកជាច្រើន៖ Chrome 144+ និង Firefox 139+ ដោយ Safari រំពឹងថានឹងធ្វើតាមឆាប់ៗនេះ។ polyfill ក៏មានសម្រាប់កម្មវិធីរុករកដែលមិនគាំទ្រ និង Node.js ផងដែរ។ Temporal API បង្កើតវត្ថុដែលជាទូទៅតំណាងឱ្យពេលវេលានៅក្នុងពេលវេលា។ ទាំងនេះអាចជាត្រាពេញម៉ោង និងកាលបរិច្ឆេទនៅក្នុងតំបន់ពេលវេលាដែលបានផ្តល់ឱ្យ ឬពួកវាអាចជាឧទាហរណ៍ទូទៅនៃម៉ោង "នាឡិកាជញ្ជាំង" ដោយមិនមានព័ត៌មានអំពីតំបន់ពេលវេលា ឬកាលបរិច្ឆេទណាមួយឡើយ។ លក្ខណៈសំខាន់ៗមួយចំនួនរបស់ Temporal រួមមាន:
ពេលវេលាដែលមាន ឬគ្មានកាលបរិច្ឆេទ។ វត្ថុបណ្តោះអាសន្នអាចតំណាងឱ្យពេលវេលាជាក់លាក់មួយនៅលើកាលបរិច្ឆេទជាក់លាក់ ឬពេលវេលាដែលគ្មានព័ត៌មានកាលបរិច្ឆេទណាមួយ។ កាលបរិច្ឆេទជាក់លាក់មួយ ដោយគ្មានពេលវេលាក៏អាចតំណាងបាន។ ការគាំទ្រតំបន់ពេលវេលា។ វត្ថុបណ្តោះអាសន្នគឺដឹងពីតំបន់ពេលវេលាយ៉ាងពេញលេញ ហើយអាចបំប្លែងបានតាមតំបន់ពេលវេលាផ្សេងៗគ្នា។ Moment គាំទ្រតំបន់ពេលវេលាផងដែរ ប៉ុន្តែវាទាមទារបណ្ណាល័យតំបន់ពេលវេលាបន្ថែម។ Immutability.នៅពេលដែលវត្ថុបណ្តោះអាសន្នត្រូវបានបង្កើត វាមិនអាចផ្លាស់ប្តូរបានទេ។ ការបំប្លែងនព្វន្ធពេលវេលា ឬតំបន់ពេលវេលាមិនកែប្រែវត្ថុមូលដ្ឋានទេ។ ផ្ទុយទៅវិញ ពួកគេបង្កើត Temporal object ថ្មីមួយ។ 1-based indexing.ប្រភពទូទៅនៃកំហុសជាមួយ Date API (ក៏ដូចជា Moment) គឺថាខែត្រូវបានធ្វើលិបិក្រមសូន្យ។ នេះមានន័យថាខែមករាគឺជាខែ 0 ជាជាងខែ 1 ដូចដែលយើងទាំងអស់គ្នាយល់នៅក្នុងជីវិតពិត។ បណ្តោះអាសន្នជួសជុលវាដោយប្រើ 1-based indexing — ខែមករាគឺជាខែ 1 ។ វាត្រូវបានបង្កើតឡើងនៅក្នុងកម្មវិធីរុករក។ ដោយសារ Temporal គឺជា API នៅក្នុងកម្មវិធីរុករកខ្លួនវា វាមិនបន្ថែមអ្វីទៅទំហំកញ្ចប់កម្មវិធីរបស់អ្នក។
វាក៏សំខាន់ផងដែរក្នុងការកត់សម្គាល់ថា Date API នឹងមិនទៅណាទេ។ ខណៈពេលដែល Temporal ជំនួស API នេះ វាមិនត្រូវបានដកចេញ ឬបដិសេធទេ។ កម្មវិធីជាច្រើននឹងខូច ប្រសិនបើកម្មវិធីរុករកបានដក Date API ចេញភ្លាមៗ។ ទោះជាយ៉ាងណាក៏ដោយ សូមចងចាំផងដែរថា Moment ឥឡូវនេះត្រូវបានគេចាត់ទុកថាជាគម្រោងកេរ្តិ៍ដំណែលនៅក្នុងរបៀបថែទាំ។ នៅក្នុងអត្ថបទដែលនៅសល់ យើងនឹងពិនិត្យមើល "រូបមន្ត" មួយចំនួនសម្រាប់ការផ្ទេរកូដ Moment-based ទៅ Temporal API ថ្មី។ តោះចាប់ផ្តើមកែលម្អ! ការបង្កើតវត្ថុកាលបរិច្ឆេទ និងពេលវេលា មុននឹងយើងអាចរៀបចំកាលបរិច្ឆេទ និងពេលវេលា យើងត្រូវបង្កើតវត្ថុតំណាងឱ្យពួកគេ។ ដើម្បីបង្កើតវត្ថុ Moment ដែលតំណាងឱ្យកាលបរិច្ឆេទ និងពេលវេលាបច្ចុប្បន្ន សូមប្រើមុខងារ moment ។ const now = moment(); console.log(ឥឡូវ); // ពេល<2026-02-18T21:26:29-05:00>
ឥឡូវនេះវត្ថុនេះអាចត្រូវបានធ្វើទ្រង់ទ្រាយ ឬរៀបចំតាមតម្រូវការ។
// បម្លែងទៅជា UTC //ការព្រមាន៖ វាផ្លាស់ប្តូរវត្ថុ Moment ហើយដាក់វានៅក្នុងរបៀប UTC! console.log(now.utc()); // Moment<2026-02-19T02:26:29Z>
// បោះពុម្ពខ្សែអក្សរដែលបានធ្វើទ្រង់ទ្រាយ - ចំណាំថាវាកំពុងប្រើពេលវេលា UTC ឥឡូវនេះ console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // ០២/១៩/២០២៦ ០២:២៧:០៧ ព្រឹក
ចំណុចសំខាន់ដែលត្រូវចងចាំអំពី Moment គឺវត្ថុ Moment តែងតែរួមបញ្ចូលព័ត៌មានអំពីពេលវេលា និងកាលបរិច្ឆេទ។ ប្រសិនបើអ្នកគ្រាន់តែត្រូវការធ្វើការជាមួយព័ត៌មានពេលវេលា ជាធម្មតាវាល្អ ប៉ុន្តែវាអាចបណ្តាលឱ្យមានអាកប្បកិរិយាដែលមិននឹកស្មានដល់ក្នុងស្ថានភាពដូចជាថ្ងៃសន្សំពេលវេលា ឬឆ្នាំបង្គ្រប់ ដែលកាលបរិច្ឆេទអាចមានឥទ្ធិពលលើការគណនាពេលវេលា។ Temporal មានភាពបត់បែនជាង។ អ្នកអាចបង្កើតវត្ថុតំណាងឱ្យកាលបរិច្ឆេទ និងពេលវេលាបច្ចុប្បន្នដោយបង្កើតវត្ថុ Temporal.Instant ។ នេះតំណាងឱ្យចំណុចនៅក្នុងពេលវេលាកំណត់ដោយពេលវេលាចាប់តាំងពី "សម័យ" (ពាក់កណ្តាលអធ្រាត្រ UTC នៅថ្ងៃទី 1 ខែមករាឆ្នាំ 1970) ។ Temporal អាចយោងភ្លាមៗនេះក្នុងពេលវេលាជាមួយនឹងភាពជាក់លាក់កម្រិតណាណូវិនាទី។ const now = Temporal.Now.instant();
// មើល nanoseconds ឆៅចាប់តាំងពីសម័យ console.log(now.epochNanoseconds); // 1771466342612000000n
// ទម្រង់ UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// ទម្រង់សម្រាប់តំបន់ពេលវេលាជាក់លាក់មួយ។ console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
Temporal.Instant objects ក៏អាចត្រូវបានបង្កើតសម្រាប់ពេលវេលា និងកាលបរិច្ឆេទជាក់លាក់មួយផងដែរ ដោយប្រើវិធីពីឋិតិវន្ត។
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// ធ្វើទ្រង់ទ្រាយភ្លាមៗនៅក្នុងតំបន់ពេលវេលាក្នុងស្រុក។ ចំណាំថាវាគ្រប់គ្រងតែប៉ុណ្ណោះ // ការធ្វើទ្រង់ទ្រាយ - វាមិនផ្លាស់ប្តូរវត្ថុដូច moment.utc ទេ។ console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
អ្នកក៏អាចបង្កើតប្រភេទ Temporal objects ផ្សេងទៀតផងដែរ រួមទាំង៖
Temporal.PlainDate៖ កាលបរិច្ឆេទដែលមិនមានព័ត៌មានពេលវេលា។ Temporal.PlainTime៖ ជាពេលវេលាដែលគ្មានព័ត៌មានកាលបរិច្ឆេទ។ Temporal.ZonedDateTime៖ កាលបរិច្ឆេទ និងពេលវេលានៅក្នុងតំបន់ពេលវេលាជាក់លាក់មួយ។
ទាំងនេះនីមួយៗមានវិធីសាស្រ្តពី ដែលអាចហៅជាមួយវត្ថុដែលបញ្ជាក់កាលបរិច្ឆេទ និង/ឬពេលវេលា ឬខ្សែអក្សរកាលបរិច្ឆេទដើម្បីញែក។ // គ្រាន់តែជាកាលបរិច្ឆេទ const today = Temporal.PlainDate.from({ ឆ្នាំ៖ ២០២៦ ខែ: 2 // ចំណាំ យើងកំពុងប្រើ 2 សម្រាប់ខែកុម្ភៈ ថ្ងៃ៖ ១៨ }); console.log(today.toString()); // 2026-02-18
// គ្រាន់តែពេលមួយ។ const lunchTime = Temporal.PlainTime.from({ ម៉ោង៖ ១២ }); console.log(lunchTime.toString()); // 12:00:00
// កាលបរិច្ឆេទ និងពេលវេលានៅក្នុងតំបន់ពេលវេលាភាគខាងកើតសហរដ្ឋអាមេរិក const dueAt = Temporal.ZonedDateTime.from({ តំបន់ពេលវេលា៖ 'អាមេរិក/ញូវ_យ៉ក', ឆ្នាំ៖ ២០២៦ ខែ៖ ៣, ថ្ងៃ៖ ១, ម៉ោង៖ ១២, នាទី៖ ០, ទីពីរ៖ 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[America/New_York]
ការញែក យើងបានគ្របដណ្តប់លើការបង្កើតកម្មវិធីនៃព័ត៌មានកាលបរិច្ឆេទ និងពេលវេលា។ ឥឡូវនេះសូមក្រឡេកមើលការញែក។ ការញែកគឺជាផ្នែកមួយដែល Moment មានភាពបត់បែនជាង Temporal API ដែលមានស្រាប់។ អ្នកអាចញែកខ្សែអក្សរកាលបរិច្ឆេទដោយបញ្ជូនវាទៅមុខងារពេលបច្ចុប្បន្ន។ ជាមួយនឹងអាគុយម៉ង់តែមួយ Moment រំពឹងថានឹងកំណត់កាលបរិច្ឆេទ ISO ប៉ុន្តែអ្នកអាចប្រើទម្រង់ជំនួសបាន ប្រសិនបើអ្នកផ្តល់អាគុយម៉ង់ទីពីរដែលបញ្ជាក់ទម្រង់កាលបរិច្ឆេទដែលកំពុងត្រូវបានប្រើប្រាស់។
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // Moment<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // Moment<2026-02-21T09:00:00-05:00>
នៅក្នុងកំណែចាស់ Moment នឹងធ្វើការទស្សន៍ទាយដ៏ល្អបំផុតដើម្បីញែកខ្សែអក្សរកាលបរិច្ឆេទដែលបានធ្វើទ្រង់ទ្រាយតាមអំពើចិត្ត។ នេះអាចនាំឱ្យមានលទ្ធផលដែលមិនអាចទាយទុកជាមុនបាន។ ឧទាហរណ៍ ០២-០៣-២០២៦ ថ្ងៃទី ២ ខែកុម្ភៈ ឬ ៣ មីនា? សម្រាប់ហេតុផលនេះ កំណែថ្មីនៃ Moment បង្ហាញការព្រមានអំពីការបដិសេធគួរឱ្យកត់សម្គាល់ប្រសិនបើវាត្រូវបានហៅដោយគ្មានខ្សែកាលបរិច្ឆេទដែលបានធ្វើទ្រង់ទ្រាយ ISO (លុះត្រាតែអាគុយម៉ង់ទីពីរជាមួយនឹងទម្រង់ដែលចង់បានត្រូវបានផ្តល់ឱ្យផងដែរ) ។ បណ្ដោះអាសន្ននឹងញែកតែខ្សែអក្សរកាលបរិច្ឆេទដែលបានធ្វើទ្រង់ទ្រាយជាក់លាក់ប៉ុណ្ណោះ។ ខ្សែអក្សរត្រូវតែអនុលោមតាមទម្រង់ ISO 8601 ឬផ្នែកបន្ថែមរបស់វា RFC 9557។ ប្រសិនបើខ្សែអក្សរកាលបរិច្ឆេទដែលមិនអនុលោមតាមច្បាប់ត្រូវបានបញ្ជូនទៅវិធីសាស្ត្រពី នោះ Temporal នឹងបោះចោល RangeError។
// ប្រើខ្សែអក្សរកាលបរិច្ឆេទ 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
// ប្រើខ្សែអក្សរកាលបរិច្ឆេទមិនស្គាល់ const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: Temporal error: invalid character while parsing year value.
តម្រូវការពិតប្រាកដនៃខ្សែអក្សរកាលបរិច្ឆេទអាស្រ័យលើប្រភេទ Temporal object ដែលអ្នកកំពុងបង្កើត។ ក្នុងឧទាហរណ៍ខាងលើ Temporal.Instant ទាមទារ ISO ពេញលេញខ្សែអក្សរកាលបរិច្ឆេទ 8601 ឬ RFC 9557 ដែលបញ្ជាក់កាលបរិច្ឆេទ និងពេលវេលាជាមួយនឹងអុហ្វសិតតំបន់ពេលវេលា ប៉ុន្តែអ្នកក៏អាចបង្កើតវត្ថុ PlainDate ឬ PlainTime ដោយប្រើតែសំណុំរងនៃទម្រង់កាលបរិច្ឆេទប៉ុណ្ណោះ។ 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
ចំណាំថាខ្សែអក្សរទាំងនេះនៅតែត្រូវអនុវត្តតាមទម្រង់ដែលរំពឹងទុក បើមិនដូច្នោះទេ កំហុសមួយនឹងត្រូវបានបោះចោល។
// ការប្រើប្រាស់ខ្សែអក្សរពេលវេលាដែលមិនអនុលោមតាម។ ទាំងអស់នេះនឹងបោះចោល RangeError។ Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00AM');
ព័ត៌មានជំនួយ៖ ការដោះស្រាយខ្សែអក្សរដែលមិនមែនជាអាយអេសអូ ដោយសារបណ្ដោះអាសន្នផ្តល់អាទិភាពដល់ភាពជឿជាក់ វានឹងមិនព្យាយាមទាយទម្រង់ខ្សែអក្សរដូចជា 02-01-2026 ទេ។ ប្រសិនបើប្រភពទិន្នន័យរបស់អ្នកប្រើខ្សែអក្សរបែបនេះ អ្នកនឹងត្រូវរៀបចំខ្សែអក្សរមួយចំនួនដើម្បីរៀបចំតម្លៃឡើងវិញទៅជាខ្សែអក្សរ ISO ដូចជា 2026-02-01 មុនពេលព្យាយាមប្រើវាជាមួយ Temporal ។
ការធ្វើទ្រង់ទ្រាយ ពេលអ្នកមាន Moment ឬ Temporal object អ្នកប្រហែលជាចង់បំប្លែងវាទៅជាខ្សែអក្សរដែលមានទម្រង់នៅចំណុចណាមួយ។ នេះគឺជាឧទាហរណ៍ដែល Moment មានភាពច្របូកច្របល់បន្តិច។ អ្នកហៅវិធីសាស្ត្រទ្រង់ទ្រាយរបស់វត្ថុដោយមានខ្សែអក្សរនៃសញ្ញាសម្ងាត់ដែលពណ៌នាអំពីទម្រង់កាលបរិច្ឆេទដែលចង់បាន។ const date = moment();
console.log(date.format('MM/DD/YYYY')); // ០២/២២/២០២៦
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // ថ្ងៃទី 22 ខែកុម្ភៈ ឆ្នាំ 2026 ម៉ោង 8:18:30 យប់
ម៉្យាងវិញទៀត Temporal តម្រូវឱ្យអ្នកនិយាយច្រើនបន្តិច។ វត្ថុបណ្តោះអាសន្ន ដូចជា Instant មានវិធីសាស្ត្រ toLocaleString ដែលទទួលយកជម្រើសទម្រង់ផ្សេងៗដែលបានបញ្ជាក់ជាលក្ខណសម្បត្តិរបស់វត្ថុមួយ។
const date = Temporal.Now.instant();
// ដោយគ្មានអាគុយម៉ង់ យើងនឹងទទួលបានទម្រង់លំនាំដើមសម្រាប់មូលដ្ឋានបច្ចុប្បន្ន console.log(date.toLocaleString()); // 2/22/2026, 8:23:36 PM (សន្មត់ថាជាតំបន់នៃ en-US)
// ឆ្លងកាត់ជម្រើសធ្វើទ្រង់ទ្រាយដើម្បីបង្កើតខ្សែអក្សរទម្រង់ផ្ទាល់ខ្លួន console.log(date.toLocaleString('en-US', { ខែ៖ 'វែង', ថ្ងៃ៖ 'លេខ', ឆ្នាំ៖ 'លេខ' ម៉ោង៖ '2 ខ្ទង់', នាទី៖ '2 ខ្ទង់' })); // ថ្ងៃទី 22 ខែកុម្ភៈ ឆ្នាំ 2026 ម៉ោង 8:23 យប់
// ឆ្លងតែវាលដែលអ្នកចង់បានក្នុងខ្សែអក្សរទ្រង់ទ្រាយ console.log(date.toLocaleString('en-US', { ខែ៖ 'ខ្លី', ថ្ងៃ៖ 'លេខ' })); // ថ្ងៃទី ២២ ខែកុម្ភៈ
ការធ្វើទ្រង់ទ្រាយកាលបរិច្ឆេទបណ្ដោះអាសន្នពិតជាប្រើ Intl.DateTimeFormat API (ដែលមានស្រាប់ក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិតទំនើប) នៅក្រោមក្រណាត់។ នោះមានន័យថាអ្នកអាចបង្កើតវត្ថុ DateTimeFormat ដែលអាចប្រើឡើងវិញបានជាមួយនឹងជម្រើសទម្រង់ផ្ទាល់ខ្លួនរបស់អ្នក បន្ទាប់មកបញ្ជូនវត្ថុបណ្តោះអាសន្នទៅវិធីសាស្ត្រទម្រង់របស់វា។ ដោយសារតែនេះ វាមិនគាំទ្រទម្រង់កាលបរិច្ឆេទផ្ទាល់ខ្លួនដូច Moment ទេ។ ប្រសិនបើអ្នកត្រូវការអ្វីមួយដូចជា 'Q1 2026' ឬការធ្វើទ្រង់ទ្រាយឯកទេសផ្សេងទៀត អ្នកប្រហែលជាត្រូវការលេខកូដទម្រង់កាលបរិច្ឆេទផ្ទាល់ខ្លួន ឬឈានដល់បណ្ណាល័យភាគីទីបី។ const formatter = ថ្មី Intl.DateTimeFormat('en-US', { ខែ៖ '2 ខ្ទង់', ថ្ងៃ៖ '2 ខ្ទង់', ឆ្នាំ៖ 'លេខ' });
const date = Temporal.Now.instant(); console.log(formatter.format(កាលបរិច្ឆេទ)); // ០២/២២/២០២៦
ថូខឹនការធ្វើទ្រង់ទ្រាយរបស់ Moment គឺងាយស្រួលក្នុងការសរសេរ ប៉ុន្តែវាមិនងាយស្រួលក្នុងមូលដ្ឋានទេ។ ខ្សែអក្សរទម្រង់ "កូដរឹង" ដូចជាលំដាប់ខែ/ថ្ងៃ។ អត្ថប្រយោជន៍នៃការប្រើប្រាស់វត្ថុកំណត់រចនាសម្ព័ន្ធ ដូចដែល Temporal ធ្វើនោះគឺថាវានឹងសម្របខ្លួនដោយស្វ័យប្រវត្តិទៅនឹងមូលដ្ឋានដែលបានផ្តល់ឱ្យណាមួយ ហើយប្រើទម្រង់ត្រឹមត្រូវ។ const date = Temporal.Now.instant();
const formatOptions = { ខែ៖ 'លេខ', ថ្ងៃ៖ 'លេខ', ឆ្នាំ៖ 'លេខ' };
console.log(date.toLocaleString('en-US', formatOptions)); // 2/22/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // ២២/០២/២០២៦
ការគណនាកាលបរិច្ឆេទ នៅក្នុងកម្មវិធីជាច្រើន អ្នកនឹងត្រូវបញ្ចប់ការគណនាមួយចំនួនតាមកាលបរិច្ឆេទ។ អ្នកប្រហែលជាចង់បន្ថែម ឬដកឯកតានៃពេលវេលា (ថ្ងៃ ម៉ោង វិនាទី។ល។)។ ឧទាហរណ៍ ប្រសិនបើអ្នកមានកាលបរិច្ឆេទបច្ចុប្បន្ន អ្នកប្រហែលជាចង់បង្ហាញអ្នកប្រើប្រាស់នូវកាលបរិច្ឆេទ 1 សប្តាហ៍ចាប់ពីពេលនេះ។ វត្ថុពេលមានវិធីសាស្រ្តដូចជា បន្ថែម និងដក ដែលអនុវត្តប្រតិបត្តិការទាំងនេះ។ មុខងារទាំងនេះយកតម្លៃ និងឯកតា ឧទាហរណ៍៖ add(7, 'days')។ ភាពខុសគ្នាដ៏សំខាន់មួយរវាង Moment និង Temporal គឺថា នៅពេលអនុវត្តការគណនាកាលបរិច្ឆេទទាំងនេះ វត្ថុមូលដ្ឋានត្រូវបានកែប្រែ ហើយតម្លៃដើមរបស់វាត្រូវបានបាត់បង់។ const now = moment();
console.log(ឥឡូវ); // Moment<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log(សប្តាហ៍បន្ទាប់); // Moment<2026-03-03T20:08:36-05:00>
// Gotcha - វត្ថុដើមត្រូវបានផ្លាស់ប្តូរ console.log(ឥឡូវ); // Moment<2026-03-03T20:08:36-05:00>
ដើម្បីកុំឱ្យបាត់បង់កាលបរិច្ឆេទដើម អ្នកអាចហៅក្លូននៅលើវត្ថុ Moment ដើម្បីបង្កើតច្បាប់ចម្លង។ const ឥឡូវនេះ= moment(); const nextWeek = now.clone().add(7, 'days');
console.log(ឥឡូវ); // ពេល<2026-02-24T20:12:55-05:00>
console.log(សប្តាហ៍បន្ទាប់); // ពេល<2026-03-03T20:12:55-05:00>
ម្យ៉ាងវិញទៀត វត្ថុបណ្តោះអាសន្នគឺមិនអាចផ្លាស់ប្តូរបាន។ នៅពេលដែលអ្នកបានបង្កើតវត្ថុមួយដូចជា Instant, PlainDate ជាដើម។ តម្លៃនៃវត្ថុនោះនឹងមិនផ្លាស់ប្តូរទេ។ វត្ថុបណ្តោះអាសន្នក៏មានវិធីសាស្ត្របន្ថែម និងដកផងដែរ។ Temporal មានការរើសអើងបន្តិចអំពីឯកតាពេលវេលាដែលអាចបន្ថែមទៅប្រភេទវត្ថុណាមួយ។ ឧទាហរណ៍ អ្នកមិនអាចបន្ថែមថ្ងៃទៅ Instant បានទេ៖
const now = Temporal.Now.instant(); const nextWeek = now.add({ថ្ងៃ៖ 7 }); // RangeError: Temporal error: ឯកតាធំបំផុតមិនអាចជាឯកតាកាលបរិច្ឆេទបានទេ។
នេះគឺដោយសារតែវត្ថុភ្លាមៗតំណាងឱ្យចំណុចជាក់លាក់មួយនៅក្នុងពេលវេលានៅក្នុង UTC និងជាប្រតិទិនដែលមិនយល់ស្រប។ ដោយសារតែរយៈពេលនៃមួយថ្ងៃអាចផ្លាស់ប្តូរដោយផ្អែកលើច្បាប់នៃតំបន់ពេលវេលាដូចជាពេលពន្លឺថ្ងៃ ការគណនានេះមិនមាននៅលើ Instant ទេ។ ទោះយ៉ាងណាក៏ដោយ អ្នកអាចអនុវត្តប្រតិបត្តិការនេះលើប្រភេទវត្ថុផ្សេងទៀត ដូចជា PlainDateTime៖ const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({ថ្ងៃ៖ 7 });
// ចំណាំថា PlainDateTime ដើមនៅតែមិនផ្លាស់ប្តូរ console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
console.log(nextWeek.toLocaleString()); // 3/3/2026, 8:23:59 PM
អ្នកក៏អាចគណនាថាតើពេលវេលាប៉ុន្មានរវាង Moment ឬ Temporal objects ពីរ។ ជាមួយនឹងមុខងារ Moment's diff អ្នកត្រូវផ្តល់ឯកតាសម្រាប់ភាពលម្អិត បើមិនដូច្នេះទេវានឹងត្រឡប់ភាពខុសគ្នាគិតជាមិល្លីវិនាទី។ const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date2.diff(date1)); // 91800000
console.log(date2.diff(date1, 'days')); // ១
ដើម្បីធ្វើវាជាមួយវត្ថុបណ្ដោះអាសន្ន អ្នកអាចបញ្ជូនវត្ថុបណ្ដោះអាសន្នមួយទៀតទៅវារហូតដល់ ឬចាប់តាំងពីវិធីសាស្ត្រ។ វាត្រឡប់វត្ថុ Temporal.Duration ដែលមានព័ត៌មានអំពីភាពខុសគ្នានៃពេលវេលា។ វត្ថុរយៈពេលមានលក្ខណៈសម្បត្តិសម្រាប់សមាសធាតុនីមួយៗនៃភាពខុសគ្នា ហើយក៏អាចបង្កើតខ្សែអក្សររយៈពេល ISO 8601 ដែលតំណាងឱ្យភាពខុសគ្នានៃពេលវេលាផងដែរ។
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// biggestUnit បញ្ជាក់ឯកតាធំបំផុតនៃពេលវេលាដែលត្រូវតំណាង // ក្នុងការគណនារយៈពេល const diff = date2.since(date1, { biggestUnit: 'day' });
console.log(diff.days); // ១
console.log(diff.hours); // ១
console.log(diff.minutes); // ៣០
console.log(diff.toString()); // P1DT1H30M // (ខ្សែអក្សរអាយអេសអូ ៨៦០១ រយៈពេល៖ ១ ថ្ងៃ ១ ម៉ោង ៣០ នាទី)
ការប្រៀបធៀបកាលបរិច្ឆេទនិងពេលវេលា Moment និង Temporal ទាំងពីរអនុញ្ញាតឱ្យអ្នកប្រៀបធៀបកាលបរិច្ឆេទ និងពេលវេលាដើម្បីកំណត់ថាតើមួយណាមកមុនគេ ប៉ុន្តែយកវិធីសាស្រ្តផ្សេងគ្នាជាមួយ API ។ Moment ផ្តល់នូវវិធីសាស្រ្តដូចជា isBefore, isAfter, និង isSame ដើម្បីប្រៀបធៀបវត្ថុ Moment ពីរ។ const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // ពិត
Temporal ប្រើវិធីសាស្ត្រប្រៀបធៀបឋិតិវន្ត ដើម្បីធ្វើការប្រៀបធៀបរវាងវត្ថុពីរដែលមានប្រភេទដូចគ្នា។ វាត្រឡប់ -1 ប្រសិនបើកាលបរិច្ឆេទដំបូងមកមុនទីពីរ 0 ប្រសិនបើពួកគេស្មើគ្នា ឬ 1 ប្រសិនបើកាលបរិច្ឆេទដំបូងមកបន្ទាប់ពីទីពីរ។ ឧទាហរណ៍ខាងក្រោមបង្ហាញពីរបៀបប្រៀបធៀបវត្ថុ PlainDate ពីរ។ អាគុយម៉ង់ទាំងពីរចំពោះ Temporal.PlainDate.compare ត្រូវតែជាវត្ថុ PlainDate ។
const date1 = Temporal.PlainDate.from({ ឆ្នាំ៖ ២០២៦ ខែ៖ ២ ថ្ងៃ៖ ២៤ }); const date2 = Temporal.PlainDate.from({ ឆ្នាំ៖ ២០២៦ ខែ៖ ៣ ថ្ងៃ៖ ២៤ });
// date1 មកមុន date2 ដូច្នេះ -1 console.log(Temporal.PlainDate.compare(date1, date2));
// កំហុសប្រសិនបើយើងព្យាយាមប្រៀបធៀបវត្ថុពីរនៃប្រភេទផ្សេងៗគ្នា console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: Temporal error: Invalid PlainDate fields បានផ្តល់។
ជាពិសេស វាធ្វើឱ្យងាយស្រួលក្នុងការតម្រៀបអារេនៃវត្ថុបណ្តោះអាសន្នតាមកាលប្បវត្តិ។ // អារេនៃវត្ថុ Temporal.PlainDate const dates = [... ];
// ប្រើ Temporal.PlainDate.compare ជាមុខងារប្រៀបធៀប dates.sort(Temporal.PlainDate.compare);
ការបម្លែងតំបន់ពេលវេលា បណ្ណាល័យ Moment ស្នូលមិនគាំទ្រការបំប្លែងតំបន់ពេលវេលាទេ។ ប្រសិនបើអ្នកត្រូវការមុខងារនេះ អ្នកក៏ត្រូវដំឡើងកញ្ចប់ moment-timezone ផងដែរ។ កញ្ចប់នេះមិនអាចរលាស់បានទេ ដូច្នេះហើយអាចបន្ថែមទំហំបាច់របស់អ្នកយ៉ាងខ្លាំង។ នៅពេលដែលអ្នកបានដំឡើង moment-timezone រួចហើយ អ្នកអាចបំប្លែង Moment objects ទៅជា time zones ផ្សេងៗដោយប្រើវិធីសាស្ត្រ tz។ ដូចទៅនឹងប្រតិបត្តិការ Moment ផ្សេងទៀត វាផ្លាស់ប្តូរមូលដ្ឋានវត្ថុ។ // សន្មតថាពេលវេលានៅភាគខាងកើតសហរដ្ឋអាមេរិក const now = moment(); console.log(ឥឡូវ); // Moment<2026-02-28T20:08:20-05:00>
// បំប្លែងទៅម៉ោងប៉ាស៊ីហ្វិក។ // ពេលវេលាដើមបូព៌ាត្រូវបានបាត់បង់។ now.tz('America/Los_Angeles'); console.log(ឥឡូវ); // Moment<2026-02-28T17:08:20-08:00>
មុខងារតំបន់ពេលវេលាត្រូវបានបង្កើតឡើងនៅក្នុង Temporal API នៅពេលប្រើវត្ថុ Temporal.ZonedDateTime ។ វត្ថុទាំងនេះរួមបញ្ចូលវិធីសាស្ត្រ withTimeZone ដែលត្រឡប់ ZonedDateTime ថ្មីដែលតំណាងឱ្យពេលវេលាដូចគ្នានៅក្នុងពេលវេលា ប៉ុន្តែនៅក្នុងតំបន់ពេលវេលាដែលបានបញ្ជាក់។ // ជាថ្មីម្តងទៀត, សន្មត់ថាពេលវេលាភាគខាងកើតរបស់សហរដ្ឋអាមេរិក const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
// បំប្លែងទៅម៉ោងប៉ាស៊ីហ្វិក const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 2/28/2026, 5:12:02 PM PST
// វត្ថុដើមនៅតែមិនផ្លាស់ប្តូរ console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
ចំណាំ៖ តម្លៃដែលបានធ្វើទ្រង់ទ្រាយបានត្រឡប់ដោយLocaleString គឺអាស្រ័យតាមឈ្មោះតាមមូលដ្ឋាន។ កូដគំរូត្រូវបានបង្កើតឡើងនៅក្នុងមូលដ្ឋាន en-US ដូច្នេះទម្រង់គឺដូចនេះ៖ 2/28/2026, 5:12:02 PM PST ។ នៅក្នុងតំបន់មួយផ្សេងទៀត នេះអាចខុសគ្នា។ ជាឧទាហរណ៍ នៅក្នុងតំបន់ en-GB អ្នកនឹងទទួលបានអ្វីមួយដូចជា 28/2/2026, 17:12:02 GMT-8។ ការឆ្លុះបញ្ចាំងពិភពលោកពិត ឧបមាថាយើងកំពុងបង្កើតកម្មវិធីសម្រាប់កំណត់ពេលព្រឹត្តិការណ៍នៅទូទាំងតំបន់ពេលវេលា។ ផ្នែកនៃកម្មវិធីនេះគឺជាមុខងារមួយ getEventTimes ដែលយកខ្សែអក្សរ ISO 8601 តំណាងឱ្យពេលវេលា និងកាលបរិច្ឆេទនៃព្រឹត្តិការណ៍ តំបន់ពេលវេលាក្នុងស្រុក និងតំបន់ពេលវេលាគោលដៅ។ មុខងារបង្កើតខ្សែអក្សរពេលវេលា និងកាលបរិច្ឆេទដែលបានធ្វើទ្រង់ទ្រាយសម្រាប់ព្រឹត្តិការណ៍នៅក្នុងតំបន់ពេលវេលាទាំងពីរ។ ប្រសិនបើមុខងារត្រូវបានផ្តល់ខ្សែអក្សរបញ្ចូលដែលមិនមែនជាខ្សែអក្សរពេលវេលា/កាលបរិច្ឆេទត្រឹមត្រូវ វានឹងបោះកំហុស។ នេះជាការអនុវត្តដើម ដោយប្រើ Moment (ក៏តម្រូវឱ្យប្រើកញ្ចប់តំបន់ពេលវេលា)។
នាំចូលពេលពី 'moment-timezone';
មុខងារ getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. បង្កើតគ្រាដំបូងនៅក្នុងតំបន់ពេលវេលារបស់អ្នកប្រើ const eventTime = moment.tz( ខ្សែអក្សរបញ្ចូល, moment.ISO_8601, // រំពឹងខ្សែអក្សរ ISO 8601 ពិត // ការញែកយ៉ាងតឹងរឹង userTimeZone );
// បោះកំហុសប្រសិនបើ inputString មិនតំណាងឱ្យកាលបរិច្ឆេទត្រឹមត្រូវ។ ប្រសិនបើ (!eventTime.isValid()) { បោះកំហុសថ្មី ('ការបញ្ចូលកាលបរិច្ឆេទ/ពេលវេលាមិនត្រឹមត្រូវ'); }
// 2. គណនាពេលវេលាគោលដៅ // សំខាន់៖ យើងត្រូវតែក្លូន ឬ 'eventTime' ផ្លាស់ប្តូរជារៀងរហូត! const targetTime = eventTime.clone().tz(targetTimeZone);
ត្រឡប់ { ក្នុងស្រុក៖ eventTime.format(timeFormat), គោលដៅ៖ targetTime.format(timeFormat), }; }
កាលវិភាគ const = getEventTimes( '2026-03-05T15:00-05:00', 'អាមេរិក/ញូវ_យ៉ក', 'អឺរ៉ុប/ឡុងដ៍', );
console.log(schedule.local); // ថ្ងៃទី 5 ខែមីនា ឆ្នាំ 2026 ម៉ោង 3:00:00 ល្ងាច EST
console.log(schedule.target); // ថ្ងៃទី 5 ខែមីនា ឆ្នាំ 2026 ម៉ោង 8:00:00 ល្ងាច GMT
ក្នុងឧទាហរណ៍នេះ យើងកំពុងប្រើទម្រង់កាលបរិច្ឆេទដែលរំពឹងទុកនៃ ISO 8601 ដែលត្រូវបានបង្កើតឡើងយ៉ាងមានប្រយោជន៍នៅក្នុង Moment ។ យើងក៏កំពុងប្រើការញែកយ៉ាងតឹងរ៉ឹងផងដែរ ដែលមានន័យថា Moment នឹងមិនព្យាយាមទាយជាមួយខ្សែអក្សរកាលបរិច្ឆេទដែលមិនស៊ីគ្នានឹងទម្រង់នោះទេ។ ប្រសិនបើខ្សែកាលបរិច្ឆេទដែលមិនមែនជា ISO ត្រូវបានឆ្លងកាត់ វានឹងនាំឱ្យវត្ថុកាលបរិច្ឆេទមិនត្រឹមត្រូវ ហើយយើងបោះកំហុស។ ការអនុវត្តបណ្តោះអាសន្នមើលទៅស្រដៀងគ្នា ប៉ុន្តែមានភាពខុសគ្នាសំខាន់ៗមួយចំនួន។
មុខងារ getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. ញែកការបញ្ចូលដោយផ្ទាល់ទៅក្នុង Instant បន្ទាប់មកបង្កើត // a ZonedDateTime នៅក្នុងតំបន់របស់អ្នកប្រើ។ const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. បម្លែងទៅតំបន់គោលដៅ // វាត្រឡប់វត្ថុថ្មីដោយស្វ័យប្រវត្តិ។ 'eventTime' គឺមានសុវត្ថិភាព។ const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. ធ្វើទ្រង់ទ្រាយដោយប្រើ Intl (ភ្ជាប់មកជាមួយ) ជម្រើស const = { ឆ្នាំ៖ 'លេខ' ខែ៖ 'ខ្លី', ថ្ងៃ៖ 'លេខ', ម៉ោង៖ 'លេខ', នាទី៖ '2 ខ្ទង់', ទីពីរ៖ '2 ខ្ទង់', TimeZoneName: 'ខ្លី' };
ត្រឡប់ { មូលដ្ឋាន៖ eventTime.toLocaleString(navigator.language, options), គោលដៅ៖ targetTime.toLocaleString(navigator.language, options) }; }
កាលវិភាគ const = getEventTimes( '2026-03-05T15:00-05:00', 'អាមេរិក/ញូវ_យ៉ក', 'អឺរ៉ុប/ឡុងដ៍', );
console.log(schedule.local); // ថ្ងៃទី 5 ខែមីនា ឆ្នាំ 2026 ម៉ោង 3:00:00 PM EST
console.log(schedule.target); // ថ្ងៃទី 5 ខែមីនា ឆ្នាំ 2026 ម៉ោង 8:00:00 ល្ងាច GMT
ជាមួយនឹង Moment យើងត្រូវបញ្ជាក់យ៉ាងច្បាស់នូវទម្រង់ខ្សែអក្សរសម្រាប់ខ្សែអក្សរកាលបរិច្ឆេទលទ្ធផល។ ដោយមិនគិតពីទីតាំង ឬទីតាំងរបស់អ្នកប្រើប្រាស់ ពេលវេលាព្រឹត្តិការណ៍នឹងតែងតែត្រូវបានធ្វើទ្រង់ទ្រាយជាថ្ងៃទី 5 ខែមីនា ឆ្នាំ 2026 ម៉ោង 3:00:00ល្ងាច EST ម្យ៉ាងទៀត យើងមិនចាំបាច់លើកករណីលើកលែងឱ្យច្បាស់លាស់នោះទេ។ ប្រសិនបើខ្សែអក្សរមិនត្រឹមត្រូវត្រូវបានបញ្ជូនទៅ Temporal.Instant.from នោះ Temporal នឹងបោះការលើកលែងសម្រាប់ពួកយើង។ រឿងមួយដែលគួរកត់សម្គាល់នោះគឺថា ទោះបីជាមានការញែកយ៉ាងតឹងរ៉ឹងក៏ដោយ ក៏កំណែ Moment នៅតែមានភាពធូរស្រាលជាងមុន។ Temporal ទាមទារតំបន់ពេលវេលាអុហ្វសិតនៅចុងបញ្ចប់នៃខ្សែអក្សរ។ អ្នកគួរចំណាំផងដែរថា ដោយសារយើងកំពុងប្រើ navigator.language កូដនេះនឹងដំណើរការតែនៅក្នុងបរិយាកាសកម្មវិធីរុករកប៉ុណ្ណោះ ព្រោះកម្មវិធីរុករកមិនត្រូវបានកំណត់នៅក្នុងបរិស្ថាន Node.js ទេ។ ការអនុវត្តបណ្តោះអាសន្នប្រើមូលដ្ឋានបច្ចុប្បន្នរបស់កម្មវិធីរុករកតាមអ៊ីនធឺណិត (navigator.language) ដូច្នេះអ្នកប្រើប្រាស់នឹងទទួលបានពេលវេលាព្រឹត្តិការណ៍ដែលបានធ្វើទ្រង់ទ្រាយដោយស្វ័យប្រវត្តិក្នុងទម្រង់ម៉ោងក្នុងស្រុករបស់ពួកគេ។ នៅក្នុងតំបន់ en-US នេះគឺនៅថ្ងៃទី 5 ខែមីនា ឆ្នាំ 2026 ម៉ោង 3:00:00 ល្ងាច EST។ ទោះជាយ៉ាងណាក៏ដោយ ប្រសិនបើអ្នកប្រើនៅទីក្រុងឡុងដ៍ ជាឧទាហរណ៍ ពេលវេលាព្រឹត្តិការណ៍នឹងត្រូវបានធ្វើទ្រង់ទ្រាយជាថ្ងៃទី 5 ខែមិនា ឆ្នាំ 2026 ម៉ោង 15:00:00 GMT-5។ សង្ខេប
សកម្មភាព Moment.js បណ្ដោះអាសន្ន ពេលបច្ចុប្បន្ន ពេលវេលា () Temporal.Now.zonedDateTimeISO() ញែក ISO moment(str) Temporal.Instant.from(str) បន្ថែមពេលវេលា .add(7, 'ថ្ងៃ') (ផ្លាស់ប្តូរ) .add({ថ្ងៃ៖ 7 }) (វត្ថុថ្មី) ភាពខុសគ្នា .diff(ផ្សេងទៀត 'ម៉ោង') .ចាប់តាំងពី (ផ្សេងទៀត)ម៉ោង តំបន់ពេលវេលា .tz('តំបន់/ឈ្មោះ') .withTimeZone('តំបន់/ឈ្មោះ')
នៅក្រឡេកមើលដំបូង ភាពខុសគ្នាអាចមានភាពខុសប្លែកគ្នាបន្តិចបន្តួច (ហើយក្នុងករណី Temporal ពេលខ្លះវាក្យសម្ព័ន្ធពាក្យសំដី និងតឹងរ៉ឹងជាង) ប៉ុន្តែមានគុណសម្បត្តិសំខាន់ៗជាច្រើនក្នុងការប្រើ Temporal over Moment.js៖
ភាពច្បាស់លាស់ជាងនេះ មានន័យថាមានការភ្ញាក់ផ្អើលតិចជាងមុន និងកំហុសដែលមិននឹកស្មានដល់។ ពេលវេលាអាចហាក់ដូចជាមានភាពធូរស្រាលជាងមុន ប៉ុន្តែវាពាក់ព័ន្ធនឹង "ការងារស្មាន" ដែលជួនកាលអាចបណ្តាលឱ្យមានកាលបរិច្ឆេទមិនត្រឹមត្រូវ។ ប្រសិនបើអ្នកផ្តល់ឱ្យ Temporal នូវអ្វីដែលមិនត្រឹមត្រូវ នោះវានឹងធ្វើឱ្យមានកំហុស។ ប្រសិនបើលេខកូដដំណើរការ អ្នកដឹងថាអ្នកមានកាលបរិច្ឆេទត្រឹមត្រូវ។ Moment អាចបន្ថែមទំហំសំខាន់ទៅកញ្ចប់កម្មវិធី ជាពិសេសប្រសិនបើអ្នកកំពុងប្រើកញ្ចប់ moment-timezone។ Temporal បន្ថែមអ្វីទាំងអស់ (នៅពេលដែលវាត្រូវបានដឹកជញ្ជូននៅក្នុងកម្មវិធីរុករកគោលដៅរបស់អ្នក)។ ភាពមិនអាចប្រែប្រួលបានផ្តល់ឱ្យអ្នកនូវទំនុកចិត្តថាអ្នកនឹងមិនបាត់បង់ ឬសរសេរជាន់លើទិន្នន័យនៅពេលអនុវត្តការបំប្លែងកាលបរិច្ឆេទ និងប្រតិបត្តិការ។ តំណាងផ្សេងៗគ្នានៃពេលវេលា (Instant, PlainDateTime, ZonedDateTime) អាស្រ័យលើតម្រូវការរបស់អ្នក ដែល Moment តែងតែជាក្រដាសបិទជុំវិញត្រាពេលវេលា UTC ។ Temporal ប្រើ Intl APIs សម្រាប់ការធ្វើទ្រង់ទ្រាយកាលបរិច្ឆេទ ដែលមានន័យថាអ្នកអាចធ្វើទ្រង់ទ្រាយតាមមូលដ្ឋានដោយមិនចាំបាច់បញ្ជាក់សញ្ញាសម្ងាត់ច្បាស់លាស់។
កំណត់ចំណាំលើ Polyfill ដូចដែលបានរៀបរាប់ខាងលើ មាន Temporal polyfill ដែលអាចប្រើបាន ចែកចាយជាកញ្ចប់ npm ដែលមានឈ្មោះថា @js-temporal/polyfill ។ ប្រសិនបើអ្នកចង់ប្រើ Temporal ថ្ងៃនេះ អ្នកនឹងត្រូវការ polyfill នេះ ដើម្បីគាំទ្រកម្មវិធីរុករកតាមអ៊ីនធឺណិតដូចជា Safari ដែលមិនទាន់បានបញ្ជូន API នៅឡើយទេ។ ដំណឹងអាក្រក់ជាមួយនេះគឺថាវានឹងបន្ថែមទំហំកញ្ចប់របស់អ្នក។ ដំណឹងល្អគឺថាវានៅតែបន្ថែមយ៉ាងខ្លាំងតិចជាងតំបន់ពេលវេលាឬតំបន់ពេលវេលា។ នេះជាការប្រៀបធៀបនៃទំហំកញ្ចប់ ដូចដែលបានរាយការណ៍ដោយ Bundlephobia.com ដែលជាគេហទំព័រដែលបង្ហាញព័ត៌មានអំពីទំហំកញ្ចប់ npm (ចុចលើឈ្មោះកញ្ចប់នីមួយៗដើម្បីមើលការវិភាគ Bundlephobia)៖
កញ្ចប់ បង្រួមតូច បង្រួម & gzipped @js-temporal/polyfill 154.1 គីឡូបៃ 44.1 គីឡូបៃ ពេល 294.4 គីឡូបៃ 75.4 គីឡូបៃ តំបន់ពេលវេលា 1 មេកាបៃ 114.2 គីឡូបៃ
Polyfill ក៏មានបញ្ហាដំណើរការមួយចំនួនជាប្រវត្តិសាស្ត្រជុំវិញការប្រើប្រាស់អង្គចងចាំ ហើយនៅពេលសរសេរ វាត្រូវបានចាត់ទុកថាស្ថិតក្នុងស្ថានភាពអាល់ហ្វា។ ដោយសារតែនេះ អ្នកប្រហែលជាមិនចង់ប្រើវានៅក្នុងផលិតកម្មរហូតដល់វាឈានដល់ស្ថានភាពចាស់ទុំជាង។ ដំណឹងល្អមួយទៀតគឺថាសង្ឃឹមថា polyfill នឹងមិនត្រូវការយូរជាងនេះទេ (ប្រាកដណាស់ប្រសិនបើអ្នកត្រូវការដើម្បីគាំទ្រកម្មវិធីរុករកចាស់) ។ នៅពេលសរសេរ Temporal បានដឹកជញ្ជូននៅក្នុង Chrome, Edge និង Firefox ។ វាមិនទាន់រួចរាល់នៅក្នុង Safari នៅឡើយទេ ទោះបីជាវាហាក់ដូចជាមានជាមួយទង់ពេលវេលាដំណើរការនៅលើការមើលបច្ចេកវិទ្យាចុងក្រោយបង្អស់ក៏ដោយ។
