JavaScript-ში დაწერილი თითქმის ნებისმიერი სახის აპლიკაცია მუშაობს დროებით ან თარიღებით გარკვეული ტევადობით. თავიდან ეს შემოიფარგლებოდა ჩაშენებული Date API-ით. ეს API მოიცავს ძირითად ფუნქციონირებას, მაგრამ საკმაოდ შეზღუდულია რისი გაკეთებაც შეუძლია. მესამე მხარის ბიბლიოთეკები, როგორიცაა Moment.js, და მოგვიანებით ჩაშენებული API, როგორიცაა Intl API და ახალი დროებითი API, გაცილებით მეტ მოქნილობას მატებს დროსა და თარიღებთან მუშაობას. The Rise And Fall Of Moment.js Moment.js არის JavaScript ბიბლიოთეკა მძლავრი კომუნალური საშუალებებით დროისა და თარიღების მუშაობისთვის. ის მოიცავს თარიღის API-ს გამოტოვებულ ფუნქციებს, როგორიცაა დროის ზონის მანიპულირება და ბევრ ჩვეულებრივ ოპერაციას ამარტივებს. მომენტი ასევე შეიცავს თარიღებისა და დროის ფორმატირების ფუნქციებს. იგი გახდა ფართოდ გამოყენებული ბიბლიოთეკა სხვადასხვა აპლიკაციებში. თუმცა, მომენტსაც ჰქონდა თავისი წილი საკითხები. ეს არის დიდი ბიბლიოთეკა და შეუძლია მნიშვნელოვნად დაამატოს აპლიკაციის პაკეტის ზომა. იმის გამო, რომ ბიბლიოთეკას არ აქვს ხის შერყევის მხარდაჭერა (თანამედროვე ბანდლერების ფუნქცია, რომელსაც შეუძლია ბიბლიოთეკების გამოუყენებელი ნაწილების ამოღება), მთელი Moment ბიბლიოთეკა შედის მაშინაც კი, თუ თქვენ იყენებთ მის მხოლოდ ერთ ან ორ ფუნქციას. Moment-ის კიდევ ერთი პრობლემა არის ის ფაქტი, რომ მის მიერ შექმნილი ობიექტები ცვალებადია. Moment ობიექტზე გარკვეული ფუნქციების გამოძახებას აქვს გვერდითი მოვლენები და ცვლის ამ ობიექტის მნიშვნელობას. ამან შეიძლება გამოიწვიოს მოულოდნელი ქცევა ან შეცდომები. 2020 წელს Moment-ის შემსრულებლებმა გადაწყვიტეს ბიბლიოთეკის მოვლა-პატრონობის რეჟიმში გადაყვანა. ახალი ფუნქციების განვითარება არ კეთდება და შემსრულებლები გვირჩევენ არ გამოიყენონ იგი ახალი პროექტებისთვის. არსებობს სხვა JavaScript თარიღის ბიბლიოთეკები, როგორიცაა date-fns, მაგრამ ქალაქში არის ახალი მოთამაშე, API პირდაპირ JavaScript-ში ჩაშენებული: დროებითი. ეს არის ახალი სტანდარტი, რომელიც ავსებს ორიგინალური Date API-ის ხვრელებს, ასევე ხსნის Moment-ში და სხვა ბიბლიოთეკებში არსებულ ზოგიერთ შეზღუდვას. რა არის დროებითი? Temporal არის ახალი დროისა და თარიღის API, რომელიც ემატება ECMAScript სტანდარტს, რომელიც განსაზღვრავს თანამედროვე JavaScript-ს. 20266 წლის მარტის მდგომარეობით, მან მიაღწია TC39 პროცესის მე-4 სტადიას (კომიტეტი, რომელიც ზედამხედველობს წინადადებებსა და დამატებებს JavaScript ენაზე) და ჩართული იქნება ECMAScript-ის სპეციფიკაციის შემდეგ ვერსიაში. ის უკვე დანერგილია რამდენიმე ბრაუზერში: Chrome 144+ და Firefox 139+, სავარაუდოდ, Safari მალე მოჰყვება. პოლიფილი ასევე ხელმისაწვდომია მხარდაუჭერელი ბრაუზერებისთვის და Node.js. დროებითი API ქმნის ობიექტებს, რომლებიც, ზოგადად, წარმოადგენენ დროის მომენტებს. ეს შეიძლება იყოს სრულ განაკვეთზე და თარიღის მარკები მოცემულ დროის სარტყელში, ან შეიძლება იყოს „კედლის საათის“ დროის ზოგადი მაგალითი დროის ზონის ან თარიღის ინფორმაციის გარეშე. დროებითი ზოგიერთი ძირითადი მახასიათებელი მოიცავს:
დრო თარიღებით ან თარიღების გარეშე. დროებით ობიექტს შეუძლია წარმოადგინოს კონკრეტული დრო კონკრეტულ თარიღზე, ან დრო ყოველგვარი თარიღის ინფორმაციის გარეშე. კონკრეტული თარიღი, დროის გარეშე, ასევე შეიძლება იყოს წარმოდგენილი. დროის ზონის მხარდაჭერა. დროებითი ობიექტები სრულად იცნობენ დროის ზონას და მათი გარდაქმნა შესაძლებელია სხვადასხვა დროის ზონაში. Moment ასევე მხარს უჭერს დროის ზონებს, მაგრამ ის მოითხოვს დამატებით მომენტ-დროის ბიბლიოთეკას. Immutability. როგორც კი შეიქმნება დროებითი ობიექტი, მისი შეცვლა შეუძლებელია. დროის არითმეტიკული ან დროის სარტყელის კონვერტაცია არ ცვლის ძირეულ ობიექტს. ამის ნაცვლად, ისინი ქმნიან ახალ დროებით ობიექტს. 1-ზე დაფუძნებული ინდექსირება. შეცდომების საერთო წყარო Date API-სთან (ისევე როგორც Moment-თან) არის ის, რომ თვეები ნულოვანი ინდექსირებულია. ეს ნიშნავს, რომ იანვარი არის თვე 0 და არა 1 თვე, როგორც ჩვენ ყველამ გვესმის რეალურ ცხოვრებაში. დროებითი ასწორებს ამას 1-ზე დაფუძნებული ინდექსირების გამოყენებით - იანვარი არის 1 თვე. ის ჩაშენებულია ბრაუზერში. ვინაიდან Temporal არის API თავად ბრაუზერში, ის არაფერს მატებს თქვენი აპლიკაციის პაკეტის ზომას.
ასევე მნიშვნელოვანია აღინიშნოს, რომ Date API არ ქრება. მიუხედავად იმისა, რომ Temporal ანაცვლებს ამ API-ს, ის არ არის წაშლილი ან მოძველებული. ბევრი აპლიკაცია გაფუჭდება, თუ ბრაუზერებმა მოულოდნელად ამოიღეს Date API. თუმცა, ასევე გახსოვდეთ, რომ 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 სთ:mm:ss a')); // 02/19/2026 02:27:07 სთ
მთავარი, რაც უნდა გვახსოვდეს Moment-ის შესახებ არის ის, რომ Moment ობიექტი ყოველთვის შეიცავს ინფორმაციას დროისა და თარიღის შესახებ. თუ საჭიროა მხოლოდ დროის ინფორმაციასთან მუშაობა, ეს ჩვეულებრივ კარგია, მაგრამ შეიძლება გამოიწვიოს მოულოდნელი ქცევა ისეთ სიტუაციებში, როგორიცაა დღის განათების დრო ან ნახტომი წლები, სადაც თარიღს შეუძლია გავლენა მოახდინოს დროის გამოთვლებზე. დროებითი უფრო მოქნილია. თქვენ შეგიძლიათ შექმნათ ობიექტი, რომელიც წარმოადგენს მიმდინარე თარიღსა და დროს Temporal.Instant ობიექტის შექმნით. ეს წარმოადგენს დროის წერტილს, რომელიც განსაზღვრულია „ეპოქის“ დროით (1970 წლის 1 იანვრის შუაღამე UTC). ტემპორალს შეუძლია დროულად მიმართოს ამ მომენტს ნანოწამის დონის სიზუსტით. 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
დროებითი.მყისიერი ობიექტები ასევე შეიძლება შეიქმნას კონკრეტული დროისა და თარიღისთვის 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 უფრო მოქნილია, ვიდრე ჩაშენებული დროებითი 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 ფორმატირებული თარიღის სტრიქონის გარეშე (თუ არ არის მითითებული მეორე არგუმენტი სასურველი ფორმატით). დროებითი აანალიზებს მხოლოდ სპეციალურად ფორმატირებული თარიღის სტრიქონს. სტრიქონი უნდა შეესაბამებოდეს ISO 8601 ფორმატს ან მის გაფართოებას, RFC 9557. თუ შეუსაბამო თარიღის სტრიქონი გადაეცემა 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 მოითხოვს სრულ 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:00 AM');
პროფესიონალური რჩევა: არა ISO სტრიქონების მართვა, რადგან დროებითი პრიორიტეტს ანიჭებს საიმედოობას, ის არ შეეცდება გამოიცნოს სტრიქონის ფორმატი, როგორიცაა 02-01-2026. თუ თქვენი მონაცემთა წყარო იყენებს ასეთ სტრიქონებს, თქვენ მოგიწევთ სტრიქონების მანიპულირება, რათა გადაანაწილოთ მნიშვნელობები ISO სტრიქონში, როგორიცაა 2026-02-01, სანამ ცდილობთ მის გამოყენებას Temporal-თან.
ფორმატირება როგორც კი გექნებათ Moment ან Temporal ობიექტი, თქვენ ალბათ მოგინდებათ მისი გადაყვანა ფორმატირებულ სტრიქონად რაღაც მომენტში. ეს არის შემთხვევა, როდესაც Moment ოდნავ უფრო მოკლეა. თქვენ უწოდებთ ობიექტის ფორმატის მეთოდს სიმბოლოების სტრიქონით, რომლებიც აღწერს თარიღის სასურველ ფორმატს. const თარიღი = moment();
console.log(date.format('MM/DD/YYYY')); // 02/22/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 2026 წლის 22 თებერვალი, 20:18:30 საათი
მეორეს მხრივ, დროებითი მოითხოვს, რომ იყოთ ცოტა მეტი სიტყვიერი. დროებით ობიექტებს, როგორიცაა 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-ნიშნა" })); // 2026 წლის 22 თებერვალი, 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 date = Temporal.Now.instant(); console.log(formatter.format(თარიღი)); // 02/22/2026
მომენტის ფორმატირების ჟეტონები უფრო მარტივი დასაწერია, მაგრამ ისინი არ არიან ლოკალიზებული. ფორმატში მითითებულია „მყარი კოდი“, როგორიცაა თვის/დღის შეკვეთა. კონფიგურაციის ობიექტის გამოყენების უპირატესობა, როგორც ამას აკეთებს 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)); // 22/02/2026
თარიღის გამოთვლები ბევრ აპლიკაციაში, თქვენ უნდა დაასრულოთ გარკვეული გამოთვლები თარიღზე. შეიძლება დაგჭირდეთ დროის ერთეულების დამატება ან გამოკლება (დღეები, საათები, წამები და ა.შ.). მაგალითად, თუ თქვენ გაქვთ მიმდინარე თარიღი, შეგიძლიათ აჩვენოთ მომხმარებელს თარიღი 1 კვირის შემდეგ. მომენტურ ობიექტებს აქვთ მეთოდები, როგორიცაა დამატება და გამოკლება, რომლებიც ასრულებენ ამ ოპერაციებს. ეს ფუნქციები იღებენ მნიშვნელობას და ერთეულს, მაგალითად: add(7, 'days'). თუმცა, ერთი ძალიან მნიშვნელოვანი განსხვავება Moment-სა და Temporal-ს შორის არის ის, რომ ამ თარიღის გამოთვლების შესრულებისას, ძირითადი ობიექტი იცვლება და მისი ორიგინალური მნიშვნელობა იკარგება. const now = moment();
console.log(ახლა); // მომენტი<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log (nextWeek); // მომენტი<2026-03-03T20:08:36-05:00>
//გოჩა - თავდაპირველი ობიექტის მუტაცია მოხდა console.log(ახლა); // მომენტი<2026-03-03T20:08:36-05:00>
ორიგინალური თარიღის დაკარგვის თავიდან ასაცილებლად, შეგიძლიათ დარეკოთ კლონი Moment ობიექტზე ასლის შესაქმნელად. const ახლა= მომენტი(); const nextWeek = now.clone().add(7, 'days');
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'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')); // 1
დროებითი ობიექტით ამის გასაკეთებლად, შეგიძლიათ სხვა დროებითი ობიექტი გადასცეთ მის მეთოდებს სანამ ან შემდეგ. ეს აბრუნებს Temporal.Duration ობიექტს, რომელიც შეიცავს ინფორმაციას დროის სხვაობის შესახებ. 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, { greatestUnit: 'day' });
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 მოდის თარიღამდე2-მდე, ამიტომ -1 console.log(Temporal.PlainDate.compare(თარიღი1, თარიღი2));
// შეცდომა, თუ ვცდილობთ შევადაროთ სხვადასხვა ტიპის ორი ობიექტი console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: დროებითი შეცდომა: მოწოდებულია არასწორი PlainDate ველები.
კერძოდ, ეს აადვილებს დროებითი ობიექტების მასივის ქრონოლოგიურად დახარისხებას. // Temporal.PlainDate ობიექტების მასივი const თარიღები = [ ... ];
// გამოიყენეთ Temporal.PlainDate.compare როგორც შედარების ფუნქცია dates.sort(Temporal.PlainDate.compare);
დროის ზონის კონვერტაციები ძირითადი Moment ბიბლიოთეკა არ უჭერს მხარს დროის ზონის კონვერტაციას. თუ გჭირდებათ ეს ფუნქციონირება, თქვენ ასევე უნდა დააინსტალიროთ მომენტ-დროის ზონის პაკეტი. ეს პაკეტი არ არის შერყევული ხეებით და, შესაბამისად, შეუძლია მნიშვნელოვნად დაამატოთ თქვენი შეკვრის ზომა. მომენტ-დროის ზონის დაყენების შემდეგ, შეგიძლიათ გადაიყვანოთ Moment ობიექტები სხვადასხვა დროის ზონებში tz მეთოდით. როგორც სხვა მომენტის ოპერაციების შემთხვევაში, ეს მუტაციას ახდენს საფუძველსობიექტი. // აშშ-ის აღმოსავლეთის დროით 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>
დროის ზონის ფუნქციონირება ჩაშენებულია დროებით 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
შენიშვნა: toLocaleString-ის მიერ დაბრუნებული ფორმატირებული მნიშვნელობები, როგორც სახელი გულისხმობს, დამოკიდებულია ლოკალზე. კოდის ნიმუში შემუშავებულია en-US ლოკალში, ამიტომ ფორმატი ასეთია: 2/28/2026, 5:12:02 PM PST. სხვა ლოკალში, ეს შეიძლება იყოს განსხვავებული. მაგალითად, en-GB ლოკალში, თქვენ მიიღებთ დაახლოებით 28/2/2026, 17:12:02 GMT-8. რეალური სამყაროს რეფაქტორინგი დავუშვათ, რომ ჩვენ ვაშენებთ აპს დროის ზონებში მოვლენების დაგეგმვისთვის. ამ აპლიკაციის ნაწილი არის ფუნქცია, getEventTimes, რომელიც იღებს ISO 8601 სტრიქონს, რომელიც წარმოადგენს მოვლენის დროსა და თარიღს, ლოკალურ სასაათო სარტყელს და სამიზნე დროის სარტყელს. ფუნქცია ქმნის დროისა და თარიღის ფორმატირებულ სტრიქონებს მოვლენისთვის ორივე დროის სარტყელში. თუ ფუნქციას ეძლევა შეყვანის სტრიქონი, რომელიც არ არის მოქმედი დროის/თარიღის სტრიქონი, ის გამოიწვევს შეცდომას. აქ არის ორიგინალური იმპლემენტაცია, მომენტის გამოყენებით (ასევე მოითხოვს მომენტ-დროის ზონის პაკეტის გამოყენებას).
იმპორტის მომენტი 'moment-timezone'-დან;
ფუნქცია 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 სტრიქონს true, // მკაცრი გარჩევა userTimeZone );
// დაუშვით შეცდომა, თუ inputString არ წარმოადგენდა მოქმედ თარიღს if (!eventTime.isValid()) { ჩააგდოს ახალი შეცდომა ('არასწორი თარიღი/დრო შეყვანა'); }
// 2. სამიზნე დროის გამოთვლა // კრიტიკული: ჩვენ უნდა კლონირება, ან 'eventTime' სამუდამოდ შეიცვლება! const targetTime = eventTime.clone().tz(targetTimeZone);
დაბრუნება { ლოკალური: eventTime.format(timeFormat), target: targetTime.format(timeFormat), }; }
const გრაფიკი = getEventTimes( '2026-03-05T15:00-05:00', 'ამერიკა/ნიუ_იორკი', "ევროპა/ლონდონი", );
console.log(schedule.local); // 2026 წლის 5 მარტი, 3:00:00 pm EST
console.log (schedule.target); // 2026 წლის 5 მარტი, 8:00:00 pm GMT
ამ მაგალითში, ჩვენ ვიყენებთ ISO 8601-ის მოსალოდნელ თარიღის ფორმატს, რომელიც სასარგებლოდ არის ჩაშენებული Moment-ში. ჩვენ ასევე ვიყენებთ მკაცრ ანალიზს, რაც ნიშნავს, რომ Moment არ შეეცდება გამოიცნოს თარიღის სტრიქონი, რომელიც არ ემთხვევა ფორმატს. თუ არა ISO თარიღის სტრიქონი გადაეცემა, ეს გამოიწვევს არასწორი თარიღის ობიექტს და ჩვენ ვუშვებთ შეცდომას. დროებითი განხორციელება ჰგავს, მაგრამ აქვს რამდენიმე ძირითადი განსხვავება.
ფუნქცია getEventTimes (inputString, userTimeZone, targetTimeZone) { // 1. შეყვანის გაანალიზება პირდაპირ Instant-ში, შემდეგ შექმენით // 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: 'მოკლე' };
დაბრუნება { local: eventTime.toLocaleString (navigator.language, პარამეტრები), target: targetTime.toLocaleString (navigator.language, პარამეტრები) }; }
const გრაფიკი = getEventTimes( '2026-03-05T15:00-05:00', 'ამერიკა/ნიუ_იორკი', "ევროპა/ლონდონი", );
console.log(schedule.local); // 2026 წლის 5 მარტი, 3:00:00 PM EST
console.log (schedule.target); // 2026 წლის 5 მარტი, 8:00:00 PM GMT
Moment-ით, ჩვენ მკაფიოდ უნდა მივუთითოთ ფორმატის სტრიქონი მიღებული თარიღის სტრიქონებისთვის. მომხმარებლის მდებარეობისა და ლოკალის მიუხედავად, ღონისძიების დრო ყოველთვის იქნება ფორმატირებული, როგორც 2026 წლის 5 მარტი, 3:00:00pm EST. გარდა ამისა, ჩვენ არ გვჭირდება გამონაკლისის გამონაკლისი. თუ არასწორი სტრიქონი გადაეცემა Temporal.Instant.from-ს, Temporal ჩააგდებს გამონაკლისს ჩვენთვის. ერთი რამ უნდა აღინიშნოს, რომ მკაცრი გაანალიზების შემთხვევაშიც კი, Moment ვერსია მაინც უფრო რბილია. დროებითი მოითხოვს დროის სარტყელის ოფსეტს სტრიქონის ბოლოს. თქვენ ასევე უნდა გაითვალისწინოთ, რომ რადგან ჩვენ ვიყენებთ navigator.language, ეს კოდი მხოლოდ ბრაუზერის გარემოში იმუშავებს, რადგან ნავიგატორი არ არის განსაზღვრული Node.js გარემოში. დროებითი განხორციელება იყენებს ბრაუზერის ამჟამინდელ ლოკალს (navigator.language), ასე რომ მომხმარებელი ავტომატურად მიიღებს მოვლენის დროების ფორმატირებას ადგილობრივი დროის ფორმატში. en-US ლოკალში, ეს არის 2026 წლის 5 მარტი, 3:00:00 pm EST. თუმცა, თუ მომხმარებელი, მაგალითად, ლონდონშია, ღონისძიების დრო ფორმატირდება, როგორც 2026 წლის 5 მარტი, 15:00:00 GMT-5. რეზიუმე
მოქმედება მომენტი.js დროებითი მიმდინარე დრო მომენტი () Temporal.Now.zonedDateTimeISO() ISO-ს გარჩევა მომენტი (str) Temporal.Instant.from(str) დაამატეთ დრო .add(7, 'days') (mutates) .add({ დღე: 7 }) (ახალი ობიექტი) განსხვავება .diff (სხვა, "საათები") .რადგან(სხვა).საათები დროის ზონა .tz ("ზონა/სახელი") .withTimeZone ('ზონა/სახელი')
ერთი შეხედვით, განსხვავება შეიძლება ოდნავ განსხვავებული იყოს (და დროებითი, ზოგჯერ უფრო ვრცელი და მკაცრი) სინტაქსის შემთხვევაში, მაგრამ არსებობს რამდენიმე ძირითადი უპირატესობა Temporal-ის გამოყენებისას Moment.js-თან შედარებით:
უფრო მკაფიო ნიშნავს ნაკლებ სიურპრიზს და გაუთვალისწინებელ შეცდომებს. მომენტი შეიძლება უფრო ლმობიერი ჩანდეს, მაგრამ ის მოიცავს „გამოცნობას“, რამაც ზოგჯერ შეიძლება გამოიწვიოს არასწორი თარიღები. თუ დროებით რამეს აძლევთ არასწორი, ის აგდებს შეცდომას. თუ კოდი მუშაობს, თქვენ იცით, რომ გაქვთ სწორი თარიღი. Moment-ს შეუძლია მნიშვნელოვანი ზომის დამატება აპლიკაციის პაკეტს, განსაკუთრებით თუ იყენებთ მომენტ-საათი სარტყლის პაკეტს. დროებითი არაფერს ამატებს (როდესაც ის გაიგზავნება თქვენს სამიზნე ბრაუზერებში). უცვლელობა გაძლევთ დარწმუნებას, რომ არასოდეს დაკარგავთ ან გადაწერთ მონაცემებს თარიღის კონვერტაციისა და ოპერაციების შესრულებისას. დროის სხვადასხვა წარმოდგენა (Instant, PlainDateTime, ZonedDateTime) თქვენი მოთხოვნებიდან გამომდინარე, სადაც Moment ყოველთვის არის შეფუთვა UTC დროის ანაბეჭდის გარშემო. Temporal იყენებს Intl API-ებს თარიღის ფორმატირებისთვის, რაც ნიშნავს, რომ თქვენ შეგიძლიათ გქონდეთ ლოკალური ცოდნის ფორმატირება ტოკენების მკაფიოდ მითითების გარეშე.
შენიშვნები პოლიფილის შესახებ როგორც უკვე აღვნიშნეთ, ხელმისაწვდომია დროებითი პოლიფილი, რომელიც ნაწილდება npm პაკეტის სახით, სახელად @js-temporal/polyfill. თუ გსურთ გამოიყენოთ Temporal დღეს, დაგჭირდებათ ეს პოლიფილი ისეთი ბრაუზერების მხარდასაჭერად, როგორიცაა Safari, რომლებსაც ჯერ არ გამოუგზავნიათ API. ამის ცუდი ამბავი ის არის, რომ ის დაამატებს თქვენი პაკეტის ზომას. კარგი ამბავი ის არის, რომ ის მაინც ამატებს მნიშვნელოვნად ნაკლებ მომენტს ან მომენტ-დროის ზონას. აქ მოცემულია პაკეტის ზომების შედარება, როგორც იტყობინება Bundlephobia.com, ვებსაიტი, რომელიც წარმოადგენს ინფორმაციას npm პაკეტის ზომებზე (დააწკაპუნეთ თითოეული პაკეტის სახელზე Bundlephobia ანალიზის სანახავად):
პაკეტი მინიფიცირებული მინიფიცირებული და გზიფირებული @js-temporal/polyfill 154.1 კბ 44.1 კბ მომენტი 294.4 კბ 75.4 კბ მომენტ-დროის ზონა 1 მბ 114.2 კბ
პოლიფილს ასევე ისტორიულად ჰქონდა გარკვეული შესრულების პრობლემები მეხსიერების გამოყენებასთან დაკავშირებით და დაწერის დროს იგი ითვლება ალფა მდგომარეობაში. ამის გამო, თქვენ შეიძლება არ გინდოდეთ მისი გამოყენება წარმოებაში, სანამ არ მიაღწევს უფრო მომწიფებულ მდგომარეობას. კიდევ ერთი კარგი ამბავი ის არის, რომ იმედია პოლიფილი აღარ დაგჭირდებათ (თუ არ დაგჭირდებათ ძველი ბრაუზერების მხარდაჭერა, რა თქმა უნდა). წერის დროს, Temporal გაიგზავნა Chrome-ში, Edge-სა და Firefox-ში. ის ჯერ კიდევ არ არის მზად Safari-ში, თუმცა, როგორც ჩანს, ის ხელმისაწვდომია გაშვების დროშით უახლეს ტექნოლოგიების გადახედვაზე.
