Գրեթե ցանկացած տեսակի հավելված, որը գրված է JavaScript-ով, որոշ չափով աշխատում է ժամերի կամ ամսաթվերի հետ: Սկզբում սա սահմանափակվում էր ներկառուցված Date API-ով: Այս API-ն ներառում է հիմնական գործառույթները, բայց բավականին սահմանափակ է այն, ինչ կարող է անել: Երրորդ կողմի գրադարանները, ինչպիսիք են Moment.js-ը, և ավելի ուշ ներկառուցված API-ները, ինչպիսիք են Intl API-ները և նոր Temporal API-ն, շատ ավելի մեծ ճկունություն են հաղորդում ժամերի և ամսաթվերի հետ աշխատելուն: The Rise And Fall Of Moment.js Moment.js-ը JavaScript գրադարան է, որն ունի հզոր կոմունալ ծառայություններ՝ ժամերի և ամսաթվերի հետ աշխատելու համար: Այն ներառում է հիմնական Date API-ի բացակայող գործառույթները, ինչպիսիք են ժամային գոտու մանիպուլյացիաները, և շատ սովորական գործողություններ ավելի պարզեցնում: Moment-ը ներառում է նաև ամսաթվերի և ժամերի ձևաչափման գործառույթներ: Այն դարձավ լայնորեն օգտագործվող գրադարան բազմաթիվ տարբեր ծրագրերում: Սակայն «Moment»-ն էլ ուներ իր բաժին խնդիրները։ Դա մեծ գրադարան է և կարող է զգալիորեն ավելացնել հավելվածի փաթեթի չափը: Քանի որ գրադարանը չի աջակցում ծառերի թափահարմանը (ժամանակակից փաթեթների հատկանիշը, որը կարող է հեռացնել գրադարանների չօգտագործված մասերը), ամբողջ Moment գրադարանը ներառված է, նույնիսկ եթե դուք օգտագործում եք դրա գործառույթներից միայն մեկը կամ երկուսը: Moment-ի մեկ այլ խնդիր այն է, որ նրա ստեղծած օբյեկտները փոփոխական են: Moment օբյեկտի վրա որոշակի գործառույթներ կանչելը կողմնակի ազդեցություն է ունենում և փոխում է այդ օբյեկտի արժեքը: Սա կարող է հանգեցնել անսպասելի վարքագծի կամ սխալների: 2020 թվականին Moment-ի սպասարկողները որոշեցին գրադարանը դնել պահպանման ռեժիմի։ Նոր գործառույթների մշակում չի իրականացվում, և սպասարկողները խորհուրդ են տալիս չօգտագործել այն նոր նախագծերի համար: Կան այլ JavaScript ամսաթվերի գրադարաններ, ինչպիսիք են date-fns-ը, բայց քաղաքում կա նոր նվագարկիչ՝ API-ն, որը ներկառուցված է անմիջապես JavaScript-ի մեջ՝ Temporal: Դա նոր ստանդարտ է, որը լրացնում է սկզբնական Date API-ի անցքերը, ինչպես նաև լուծում է Moment-ում և այլ գրադարաններում հայտնաբերված որոշ սահմանափակումներ: Ի՞նչ է ժամանակավորը: Temporal-ը նոր ժամի և ամսաթվի API է, որն ավելացվում է ECMAScript ստանդարտին, որը սահմանում է ժամանակակից JavaScript-ը: 20266 թվականի մարտի դրությամբ այն հասել է TC39 գործընթացի 4-րդ փուլին (կոմիտե, որը վերահսկում է JavaScript լեզվի առաջարկներն ու լրացումները) և կներառվի ECMAScript-ի հստակեցման հաջորդ տարբերակում: Այն արդեն ներդրվել է մի քանի բրաուզերում՝ Chrome 144+ և Firefox 139+, իսկ Safari-ն սպասվում է շուտով: Polyfill-ը հասանելի է նաև չաջակցվող բրաուզերների և Node.js-ի համար: Ժամանակավոր API-ն ստեղծում է օբյեկտներ, որոնք, ընդհանուր առմամբ, ներկայացնում են ժամանակի պահերը: Դրանք կարող են լինել լրիվ դրույքով և ամսաթվի դրոշմանիշներ տվյալ ժամային գոտում, կամ դրանք կարող են լինել «պատի ժամացույցի» ժամանակի ընդհանուր օրինակ՝ առանց որևէ ժամային գոտու կամ ամսաթվի մասին տեղեկությունների: Temporal-ի որոշ հիմնական հատկանիշները ներառում են.
Ժամկետներ՝ ամսաթվերով կամ առանց ամսաթվի: Ժամանակավոր օբյեկտը կարող է ներկայացնել որոշակի ժամանակ որոշակի ամսաթվի վրա կամ ժամանակ առանց որևէ ամսաթվի տեղեկատվության: Կոնկրետ ամսաթիվ՝ առանց ժամանակի, նույնպես կարող է ներկայացվել։ Ժամային գոտիների աջակցություն: Ժամանակավոր օբյեկտները լիովին տեղյակ են ժամային գոտում և կարող են փոխակերպվել տարբեր ժամային գոտիներում: Moment-ն աջակցում է նաև ժամային գոտիներին, սակայն այն պահանջում է լրացուցիչ պահ-ժամային գոտի գրադարան: Անփոփոխելիություն: Ժամանակավոր օբյեկտը ստեղծվելուց հետո այն չի կարող փոխվել: Ժամանակային թվաբանությունը կամ ժամային գոտու փոխարկումները չեն փոփոխում հիմքում ընկած օբյեկտը: Փոխարենը, նրանք ստեղծում են նոր ժամանակավոր օբյեկտ: 1-ի վրա հիմնված ինդեքսավորում: Date API-ի (ինչպես նաև Moment-ի) հետ կապված սխալների ընդհանուր աղբյուրն այն է, որ ամիսները զրոյական ինդեքսավորվում են: Սա նշանակում է, որ հունվար ամիսը 0-ն է, այլ ոչ թե 1-ին, ինչպես մենք բոլորս հասկանում ենք իրական կյանքում: Ժամանակավոր շտկում է դա՝ օգտագործելով 1-ի վրա հիմնված ինդեքսավորումը. հունվարը 1 ամիս է: Այն ներկառուցված է դիտարկիչում: Քանի որ Temporal-ը բրաուզերում API է, այն ոչինչ չի ավելացնում ձեր հավելվածի փաթեթի չափին:
Կարևոր է նաև նշել, որ Date API-ն չի անհետանում: Թեև Temporal-ը փոխարինում է այս API-ին, այն չի հեռացվում կամ հնացած: Շատ հավելվածներ կփչանան, եթե բրաուզերները հանկարծ հեռացնեն Date API-ը: Այնուամենայնիվ, նաև հիշեք, որ Moment-ն այժմ համարվում է ժառանգական նախագիծ պահպանման ռեժիմում: Հոդվածի մնացած մասում մենք կդիտարկենք Moment-ի վրա հիմնված կոդը նոր ժամանակավոր API տեղափոխելու «բաղադրատոմսեր»: Սկսենք վերամշակել։ Օրվա և ժամի օբյեկտների ստեղծում Նախքան մենք կարողանանք շահարկել ամսաթվերը և ժամերը, մենք պետք է ստեղծենք դրանք ներկայացնող առարկաներ: Ընթացիկ ամսաթիվը և ժամը ներկայացնող Moment օբյեկտ ստեղծելու համար օգտագործեք պահ գործառույթը: const now = moment(); console.log (այժմ); // Պահ<2026-02-18T21:26:29-05:00>
Այս օբյեկտն այժմ կարող է ձևաչափվել կամ շահարկվել ըստ անհրաժեշտության:
// փոխարկել UTC //Զգուշացում․ սա մուտացիայի է ենթարկում Moment օբյեկտը և այն դնում UTC ռեժիմում։ console.log(now.utc()); // Պահ<2026-02-19T02:26:29Z>
// տպել ֆորմատավորված տող - նկատի ունեցեք, որ այն այժմ օգտագործում է UTC ժամանակը console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // 02/19/2026 02:27:07 am
Հիմնական բանը, որ պետք է հիշել Moment-ի մասին, այն է, որ Moment օբյեկտը միշտ պարունակում է տեղեկատվություն ժամի և ամսաթվի մասին: Եթե ձեզ հարկավոր է աշխատել միայն ժամանակի տեղեկատվության հետ, դա սովորաբար լավ է, բայց դա կարող է առաջացնել անսպասելի վարք այնպիսի իրավիճակներում, ինչպիսիք են Ամառային ժամանակը կամ նահանջ տարիները, որտեղ ամսաթիվը կարող է ազդել ժամանակի հաշվարկների վրա: Ժամանակավորը ավելի ճկուն է: Դուք կարող եք ստեղծել ընթացիկ ամսաթիվը և ժամը ներկայացնող օբյեկտ՝ ստեղծելով Temporal.Instant օբյեկտ: Սա ներկայացնում է ժամանակի մի կետ, որը սահմանված է «դարաշրջանից» ի վեր (1970 թվականի հունվարի 1-ի կեսգիշեր UTC): Temporal-ը կարող է ժամանակին մատնանշել այս ակնթարթը՝ նանվայրկյանական մակարդակի ճշգրտությամբ: const now = Temporal.Now.instant();
// տես չմշակված նանվայրկյաններ սկսած դարաշրջանից console.log (now.epochNanoseconds); // 1771466342612000000ն
// ձևաչափ 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 օբյեկտները կարող են ստեղծվել նաև որոշակի ժամի և ամսաթվի համար՝ օգտագործելով from static մեթոդը:
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.PlainDate. Ամսաթիվ առանց ժամանակի տեղեկությունների: Temporal.PlainTime. Ժամանակ՝ առանց ամսաթվի տեղեկատվության: Temporal.ZonedDateTime. ամսաթիվ և ժամը որոշակի ժամային գոտում:
Սրանցից յուրաքանչյուրն ունի from մեթոդ, որը կարող է կանչվել օբյեկտով, որը նշում է ամսաթիվը և/կամ ժամը, կամ ամսաթվի տողը վերլուծելու համար: // Պարզապես ժամադրություն const today = Temporal.PlainDate.from({ տարի՝ 2026 թ. ամիս՝ 2, // նշեք, որ մենք օգտագործում ենք 2-ը փետրվարի համար օր: 18 }); console.log (today.toString()); // 2026-02-18
// Ընդամենը մի ժամանակ const lunchTime = Temporal.PlainTime.from({ ժամ: 12 }); console.log (lunchTime.toString ()); // 12:00:00
// Ամսաթիվ և ժամ ԱՄՆ արևելյան ժամային գոտում const dueAt = Temporal.ZonedDateTime.from({ Ժամային Գոտին՝ «Ամերիկա/Նյու_Յորք», տարի՝ 2026 թ. ամիս: 3, օր: 1, ժամ՝ 12, րոպե՝ 0, երկրորդը: 0 }); console.log (dueAt.toString ()); // 2026-03-01T12:00:00-05:00[Ամերիկա/Նյու_Յորք]
Վերլուծություն Մենք լուսաբանել ենք օրվա և ժամի տեղեկատվության ծրագրային ստեղծումը: Հիմա եկեք նայենք վերլուծությանը: Վերլուծումը մի տարածք է, որտեղ 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); // Պահ<2026-02-21T09:00:00-05:00>
console.log (formattedDate); // Պահ<2026-02-21T09:00:00-05:00>
Ավելի հին տարբերակներում Moment-ը լավագույնս կռահում է՝ վերլուծելու կամայականորեն ձևաչափված ամսաթվի տողը: Սա կարող է հանգեցնել անկանխատեսելի արդյունքների: Օրինակ՝ 02-03-2026 փետրվարի 2-ն է, թե՞ մարտի 3-ը։ Այդ իսկ պատճառով, Moment-ի նոր տարբերակները ցուցադրում են անհետացման նշանավոր նախազգուշացում, եթե այն կանչվում է առանց ISO ձևաչափված ամսաթվի տողի (եթե նույնպես տրված է երկրորդ արգումենտը ցանկալի ձևաչափով): Temporal-ը կվերլուծի միայն հատուկ ձևաչափված ամսաթվի տողը: Տողը պետք է համապատասխանի ISO 8601 ձևաչափին կամ դրա ընդլայնմանը` RFC 9557: Եթե չհամապատասխանող ամսաթվի տողը փոխանցվի a from մեթոդին, Temporal-ը կներկայացնի RangeError:
// Օգտագործելով RFC 9557 ամսաթվի տողը const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[Ամերիկա/Նյու_Յորք]'); 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.Instant-ը պահանջում է ամբողջական ISO8601 կամ 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:00 AM');
Պրոֆեսիոնալ հուշում․ կառավարել ոչ ISO տողերը, քանի որ Temporal-ը առաջնահերթություն է տալիս հուսալիությանը, այն չի փորձի գուշակել այնպիսի տողի ձևաչափը, ինչպիսին 02-01-2026-ն է։ Եթե ձեր տվյալների աղբյուրը օգտագործում է նման տողեր, ապա դուք պետք է կատարեք լարային մանիպուլյացիաներ՝ արժեքները վերադասավորելու ISO տողի մեջ, ինչպիսին է 2026-02-01, նախքան փորձեք օգտագործել այն Temporal-ի հետ:
Ֆորմատավորում Երբ դուք ունեք Moment կամ Temporal օբյեկտ, հավանաբար կցանկանաք այն ինչ-որ պահի վերածել ֆորմատավորված տողի: Սա մի դեպք է, երբ Moment-ը մի փոքր ավելի կարճ է: Դուք կանչում եք օբյեկտի ձևաչափի մեթոդը նշանների շարանով, որոնք նկարագրում են ցանկալի ամսաթվի ձևաչափը: const ամսաթիվ = moment();
console.log (date.format ('MM/DD/YYYY')); // 22.02.2026թ
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // Փետրվարի 22, 2026, 20:18:30
Մյուս կողմից, Ժամանակավորը պահանջում է, որ դուք մի փոքր ավելի խոսուն լինեք: Ժամանակավոր օբյեկտները, ինչպիսիք են Instant-ը, ունեն toLocaleString մեթոդ, որն ընդունում է տարբեր ձևաչափման տարբերակներ, որոնք նշված են որպես օբյեկտի հատկություններ:
const ամսաթիվ = Temporal.Now.instant();
// առանց արգումենտների, մենք կստանանք ընթացիկ տեղանքի լռելյայն ձևաչափը console.log (date.toLocaleString()); // 2/22/2026, 20:23:36 (ենթադրելով en-US տեղանք)
// անցեք ձևաչափման ընտրանքներ՝ հատուկ ձևաչափի տող ստեղծելու համար console.log(date.toLocaleString('en-US', { ամիս՝ «երկար», օր՝ «թվային», տարի՝ «թվային», ժամ՝ «2 նիշ», րոպե՝ «2 նիշ» })); // Փետրվարի 22, 2026, ժամը 20:23
// փոխանցեք միայն ձեր ուզած դաշտերը ֆորմատի տողում console.log(date.toLocaleString('en-US', { ամիս՝ «կարճ», օր՝ «թվային» })); // 22 փետրվարի
Ամսաթվերի ժամանակավոր ձևաչափումն իրականում օգտագործում է Intl.DateTimeFormat API-ը (որն արդեն հասանելի է ժամանակակից բրաուզերներում): Դա նշանակում է, որ դուք կարող եք ստեղծել վերօգտագործվող DateTimeFormat օբյեկտ ձեր հատուկ ձևաչափման ընտրանքներով, այնուհետև ժամանակավոր օբյեկտները փոխանցել իր ձևաչափի մեթոդին: Դրա պատճառով այն չի աջակցում հատուկ ամսաթվերի ձևաչափերին, ինչպես Moment-ը: Եթե Ձեզ անհրաժեշտ է «Q1 2026» կամ այլ մասնագիտացված ձևաչափում, ձեզ կարող է անհրաժեշտ լինել ամսաթվի ձևաչափման հատուկ կոդ կամ դիմել երրորդ կողմի գրադարանին: const formatter = new Intl.DateTimeFormat('en-US', { ամիս՝ «2 նիշ», օր՝ «2 նիշ», տարի՝ «թվային» });
const ամսաթիվ = Temporal.Now.instant(); console.log (formatter.format (ամսաթիվ)); // 22.02.2026թ
Moment-ի ձևաչափման նշաններն ավելի պարզ են գրելու համար, բայց դրանք հարմար չեն տեղային տարածքների համար: Ձևաչափը պարունակում է «կոշտ կոդ» այնպիսի բաներ, ինչպիսիք են ամիս/օր պատվերը: Կազմաձևման օբյեկտ օգտագործելու առավելությունը, ինչպես անում է Temporal-ը, կայանում է նրանում, որ այն ավտոմատ կերպով կհարմարվի ցանկացած տեղանքին և կօգտագործի ճիշտ ձևաչափը: const ամսաթիվ = Temporal.Now.instant();
const formatOptions = { ամիս՝ «թվային», օր՝ «թվային», տարի՝ «թվային» };
console.log (date.toLocaleString ('en-US', formatOptions)); // 2/22/2026
console.log (date.toLocaleString ('en-GB', formatOptions)); // 22/02/2026
Ամսաթվերի հաշվարկներ Շատ ծրագրերում դուք պետք է որոշ հաշվարկներ կատարեք ամսաթվին: Դուք կարող եք ավելացնել կամ հանել ժամանակի միավորները (օր, ժամ, վայրկյան և այլն): Օրինակ, եթե դուք ունեք ընթացիկ ամսաթիվը, կարող եք օգտատիրոջը ցույց տալ ամսաթիվը 1 շաբաթ անց: Պոմենտային օբյեկտներն ունեն մեթոդներ, ինչպիսիք են գումարումը և հանումը, որոնք կատարում են այս գործողությունները: Այս ֆունկցիաները վերցնում են արժեք և միավոր, օրինակ՝ add(7, «օրեր»): Այնուամենայնիվ, Moment-ի և Temporal-ի միջև շատ կարևոր տարբերությունն այն է, որ այս ամսաթվի հաշվարկները կատարելիս հիմքում ընկած օբյեկտը փոփոխվում է և դրա սկզբնական արժեքը կորչում է: const now = moment();
console.log (այժմ); // Պահ<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'օրեր'); console.log (nextWeek); // Պահ<2026-03-03T20:08:36-05:00>
// Gotcha - սկզբնական օբյեկտը մուտացիայի է ենթարկվել console.log (այժմ); // Պահ<2026-03-03T20:08:36-05:00>
Բնօրինակի ամսաթիվը չկորցնելու համար կարող եք զանգահարել Moment օբյեկտի կլոնին՝ պատճեն ստեղծելու համար: const հիմա= պահ (); const nextWeek = now.clone().add(7, 'օրեր');
console.log (այժմ); // Պահ<2026-02-24T20:12:55-05:00>
console.log (nextWeek); // Պահ<2026-03-03T20:12:55-05:00>
Մյուս կողմից, ժամանակավոր օբյեկտները անփոփոխ են: Երբ դուք ստեղծեք այնպիսի օբյեկտ, ինչպիսին է Instant, PlainDate և այլն, այդ օբյեկտի արժեքը երբեք չի փոխվի: Ժամանակավոր օբյեկտներն ունեն նաև գումարման և հանման մեթոդներ: Ժամանակավորը մի փոքր ընտրող է, թե որ ժամանակի միավորները կարող են ավելացվել օբյեկտների տեսակներին: Օրինակ, դուք չեք կարող օրեր ավելացնել Instant-ին.
const now = Temporal.Now.instant(); const nextWeek = now.add({օր՝ 7 }); // RangeError. Ժամանակավոր սխալ. ամենամեծ միավորը չի կարող լինել ամսաթվի միավոր
Դա պայմանավորված է նրանով, որ ակնթարթային օբյեկտները ներկայացնում են ժամանակի որոշակի կետ UTC-ում և օրացուցային-ագնոստիկ են: Քանի որ օրվա տևողությունը կարող է փոխվել՝ ելնելով ժամային գոտու կանոններից, օրինակ՝ Ամառային ժամանակից, այս հաշվարկը հասանելի չէ ակնթարթում: Այնուամենայնիվ, դուք կարող եք կատարել այս գործողությունը այլ տեսակի օբյեկտների վրա, օրինակ՝ PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log (now.toLocaleString()); // 24.2.2026, 20:23:59
const nextWeek = now.add({օր՝ 7 });
// Նկատի ունեցեք, որ սկզբնական PlainDateTime-ը մնում է անփոփոխ console.log (now.toLocaleString()); // 24.2.2026, 20:23:59
console.log (nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
Կարող եք նաև հաշվարկել, թե որքան ժամանակ է գտնվում երկու Moment կամ Temporal օբյեկտների միջև: 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, 'օրեր')); // 1
Դա անելու համար ժամանակավոր օբյեկտի հետ, դուք կարող եք փոխանցել մեկ այլ ժամանակավոր օբյեկտ իր մինչև կամ հետո մեթոդներին: Սա վերադարձնում է Temporal.Duration օբյեկտ, որը պարունակում է տեղեկատվություն ժամանակի տարբերության մասին: Տևողություն օբյեկտն ունի հատկություններ տարբերության յուրաքանչյուր բաղադրիչի համար, ինչպես նաև կարող է առաջացնել ISO 8601 տևողության տող, որը ներկայացնում է ժամանակի տարբերությունը:
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// largeUnit-ը սահմանում է ներկայացնելու ժամանակի ամենամեծ միավորը // տևողության հաշվարկում const diff = date2.since(date1, { largeUnit: 'օր' });
console.log (diff.days); // 1
console.log (diff.hours); // 1
console.log (diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (ISO 8601 տևողության տող. 1 օր, 1 ժամ, 30 րոպե)
Ամսաթվերի և ժամերի համեմատություն 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({ տարի՝ 2026, ամիս՝ 2, օր՝ 24 }); const date2 = Temporal.PlainDate.from({ տարի՝ 2026, ամիս՝ 3, օր՝ 24 });
// date1-ը գալիս է date2-ից առաջ, ուստի -1 console.log (Temporal.PlainDate.compare(date1, date2));
// Սխալ, եթե փորձենք համեմատել տարբեր տեսակի երկու օբյեկտներ console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError. Ժամանակավոր սխալ. Անվավեր PlainDate դաշտեր են տրամադրված:
Մասնավորապես, դա հեշտացնում է ժամանակագրական օբյեկտների զանգվածի տեսակավորումը: // Temporal.PlainDate օբյեկտների զանգված const ամսաթվերը = [ ... ];
// օգտագործել Temporal.PlainDate.compare որպես համեմատիչ ֆունկցիա dates.sort (Temporal.PlainDate.compare);
Ժամային գոտիների փոխարկումներ Հիմնական Moment գրադարանը չի աջակցում ժամային գոտիների փոխարկումները: Եթե Ձեզ անհրաժեշտ է այս ֆունկցիոնալությունը, դուք նույնպես պետք է տեղադրեք moment-timezone փաթեթը: Այս փաթեթը չի կարող թափահարվել ծառերից, և, հետևաբար, կարող է զգալիորեն ավելացնել ձեր փաթեթի չափը: Moment-timezone-ը տեղադրելուց հետո կարող եք Moment օբյեկտները փոխարկել տարբեր ժամային գոտիների tz մեթոդով: Ինչպես Moment-ի մյուս գործողությունների դեպքում, սա փոխում է հիմքում ընկածըօբյեկտ. // Ենթադրելով ԱՄՆ արևելյան ժամանակ const now = moment(); console.log (այժմ); // Պահ<2026-02-28T20:08:20-05:00>
// Փոխարկել Խաղաղօվկիանոսյան ժամանակին: // Արևելյան սկզբնական ժամանակը կորել է: now.tz ('America/Los_Angeles'); console.log (այժմ); // Պահ<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, 17:12:02 PST
// Բնօրինակ օբյեկտը մնում է անփոփոխ console.log (now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
Նշում. ToLocaleString-ի կողմից վերադարձված ձևաչափված արժեքները, ինչպես անունն է ենթադրում, կախված են տեղայնությունից: Նմուշի կոդը մշակվել է en-US տեղանքում, ուստի ձևաչափն այսպիսին է՝ 2/28/2026, 17:12:02 PST: Մեկ այլ տեղանքում սա կարող է տարբեր լինել: Օրինակ, en-GB տեղայնացման դեպքում դուք կստանաք նման բան 28/2/2026, 17:12:02 GMT-8: Իրական աշխարհի վերամշակում Ենթադրենք, որ մենք ծրագիր ենք կառուցում ժամանակային գոտիներում իրադարձությունների պլանավորման համար: Այս հավելվածի մի մասը գործառույթ է՝ getEventTimes, որը վերցնում է ISO 8601 տող, որը ներկայացնում է իրադարձության ժամը և ամսաթիվը, տեղական ժամային գոտին և նպատակային ժամային գոտին: Ֆունկցիան ստեղծում է ֆորմատավորված ժամի և ամսաթվի տողեր իրադարձության համար երկու ժամային գոտիներում: Եթե ֆունկցիային տրվի մուտքային տող, որը վավեր ժամանակի/ամսաթվի տող չէ, այն սխալ կառաջացնի: Ահա սկզբնական իրականացումը, օգտագործելով Moment-ը (նաև պահանջում է օգտագործել պահ-ժամային գոտու փաթեթը):
ներմուծման պահը «moment-time zone»-ից;
ֆունկցիա getEventTimes (inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. Ստեղծեք սկզբնական պահը օգտագործողի ժամային գոտում const eventTime = moment.tz( inputString, moment.ISO_8601, // Ակնկալեք ISO 8601 տող ճշմարիտ, // Խիստ վերլուծություն userTimeZone );
// Սխալ նետեք, եթե inputString-ը վավեր ամսաթիվ չէր ներկայացնում if (!eventTime.isValid()) { նետել նոր Սխալ ('Անվավեր ամսաթիվ/ժամ մուտքագրում'); }
// 2. Հաշվել նպատակային ժամանակը // ԿՐԻՏԻԿԱԿԱՆ. Մենք պետք է կլոնավորենք, կամ «իրադարձության ժամանակը» ընդմիշտ փոխվի: 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 pm EST
console.log (schedule.target); // Մարտ 5, 2026, 20: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. Փոխակերպել թիրախային գոտուն // Սա ավտոմատ կերպով վերադարձնում է ՆՈՐ օբյեկտ; «իրադարձության ժամանակը» անվտանգ է: const targetTime = eventTime.withTimeZone (targetTimeZone);
// 3. Ձևաչափ՝ օգտագործելով Intl (ներկառուցված) const ընտրանքներ = { տարի՝ «թվային», ամիս՝ «կարճ», օր՝ «թվային», ժամ՝ «թվային», րոպե՝ «2 նիշ», երկրորդը՝ «2 նիշ», timeZoneName՝ «կարճ» };
վերադարձ { տեղական՝ eventTime.toLocaleString (navigator.language, ընտրանքներ), թիրախ՝ targetTime.toLocaleString (navigator.language, ընտրանքներ) }; }
const ժամանակացույց = getEventTimes ( «2026-03-05T15:00-05:00», «Ամերիկա/Նյու Յորք», «Եվրոպա/Լոնդոն», );
console.log (schedule.local); // Մարտ 5, 2026, 15:00:00 EST
console.log (schedule.target); // Մարտ 5, 2026, 20:00:00 GMT
Moment-ի միջոցով մենք պետք է հստակորեն նշենք ձևաչափի տողը ստացված ամսաթվի տողերի համար: Անկախ օգտատիրոջ գտնվելու վայրից կամ տեղանքից, միջոցառման ժամերը միշտ ձևաչափված կլինեն որպես 2026 թվականի մարտի 5, 3:00:00:pm EST. Բացի այդ, մենք չպետք է բացահայտ բացառություն անենք: Եթե անվավեր տող փոխանցվի Temporal.Instant.from-ին, Temporal-ը մեզ համար բացառություն կանի: Պետք է նշել մի բան, որ նույնիսկ խիստ վերլուծության դեպքում Moment տարբերակը դեռ ավելի մեղմ է: Ժամանակավորը պահանջում է ժամանակային գոտու շեղում տողի վերջում: Պետք է նաև նկատի ունենալ, որ քանի որ մենք օգտագործում ենք navigator.language, այս կոդը կաշխատի միայն դիտարկիչի միջավայրում, քանի որ նավիգատորը սահմանված չէ Node.js միջավայրում: Ժամանակավոր իրականացումն օգտագործում է զննարկչի ընթացիկ տեղայնությունը (navigator.language), այնպես որ օգտատերը ավտոմատ կերպով կստանա իրադարձությունների ժամերը՝ ձևաչափված իրենց տեղական ժամանակի ձևաչափով: ԱՄՆ-ի տարածքում սա 2026 թվականի մարտի 5-ին է, ժամը 15:00:00-ին EST: Այնուամենայնիվ, եթե օգտատերը, օրինակ, Լոնդոնում է, միջոցառման ժամերը կձևավորվեն որպես 2026 թվականի մարտի 5, 15:00:00 GMT-5: Ամփոփում
Գործողություն Moment.js Ժամանակավոր Ընթացիկ ժամանակը պահ () Temporal.Now.zonedDateTimeISO() ISO-ի վերլուծություն պահ (փող) Temporal.Instant.from(str) Ժամանակ ավելացրեք .add(7, «օրեր») (mutates) .add ({ օր՝ 7 }) (նոր օբյեկտ) Տարբերություն .diff (այլ, «ժամեր») .ince(other).hours Ժամային գոտի .tz («Գոտի/Անուն») .withTimeZone («Գոտի/Անուն»)
Առաջին հայացքից տարբերությունը կարող է փոքր-ինչ տարբեր լինել (իսկ ժամանակային, երբեմն ավելի բովանդակալից և ավելի խիստ) շարահյուսության դեպքում, սակայն կան մի քանի հիմնական առավելություններ Moment.js-ի նկատմամբ Temporal-ի օգտագործման համար.
Ավելի հստակ լինելը նշանակում է ավելի քիչ անակնկալներ և չնախատեսված սխալներ: Պահը կարող է թվալ ավելի մեղմ, բայց այն ներառում է «գուշակություն», որը երբեմն կարող է հանգեցնել սխալ ամսաթվերի: Եթե դուք տալիս եք Temporal-ին անվավեր որևէ բան, այն սխալ է թույլ տալիս: Եթե կոդը գործարկվի, դուք գիտեք, որ վավեր ամսաթիվ ունեք: Moment-ը կարող է զգալի չափեր ավելացնել հավելվածի փաթեթին, հատկապես, եթե դուք օգտագործում եք պահի ժամային գոտու փաթեթը: Temporal-ը ոչինչ չի ավելացնում (երբ այն առաքվի ձեր թիրախային բրաուզերներում): Անփոփոխելիությունը ձեզ վստահություն է տալիս, որ դուք երբեք չեք կորցնի կամ վերագրեք տվյալները ամսաթվերի փոխարկումներ և գործողություններ կատարելիս: Ժամանակի տարբեր ներկայացումներ (Instant, PlainDateTime, ZonedDateTime)՝ կախված ձեր պահանջներից, որտեղ Moment-ը միշտ փաթաթված է UTC ժամադրոշմի շուրջ: Temporal-ը օգտագործում է Intl API-ները ամսաթվերի ձևաչափման համար, ինչը նշանակում է, որ դուք կարող եք ունենալ տեղայնացված ձևաչափում՝ առանց հստակ նշելու նշաններ:
Նշումներ 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-ում, չնայած թվում է, որ այն հասանելի է նորագույն տեխնոլոգիայի նախադիտման ժամանակ գործող դրոշով:
