JavaScript Temporal API: Sana va Vaqtni Boshqarishning Zamonaviy Usuli

JavaScript'dagi Date obyekti uzoq vaqtdan beri dasturchilar uchun noqulaylik manbai bo'lib kelgan. Uning o'zgaruvchanligi, vaqt mintaqalarini ichki qo'llab-quvvatlamasligi va noqulay API'si son-sanoqsiz kutubxonalar va muqobil yechimlarning paydo bo'lishiga olib keldi. Yaxshiyamki, Temporal API bu kamchiliklarni bartaraf etishga qaratilgan bo'lib, JavaScript'da sana va vaqtni boshqarish uchun zamonaviy, tushunarli va vaqt mintaqalarini hisobga oladigan yechimni taqdim etadi.

Temporal API nima?

Temporal API — bu JavaScript'da sana va vaqtlar bilan ishlashning zamonaviy va standartlashtirilgan usulini ta'minlovchi yangi global obyekt, Temporal'dir. U eskirgan Date obyektini almashtirish uchun mo'ljallangan bo'lib, API dizayni, o'zgarmaslik, vaqt mintaqalarini qo'llab-quvvatlash va umumiy foydalanish qulayligi jihatidan sezilarli yaxshilanishlarni taklif etadi. Bu ECMAScript taklifining bir qismi bo'lib, asosiy JavaScript dvigatellarida joriy etilmoqda.

Temporal API'ning asosiy afzalliklari:

• O'zgarmaslik (Immutability): Temporal obyektlari o'zgarmasdir, ya'ni ular ustida bajarilgan amallar asl obyektni o'zgartirish o'rniga yangi obyektlarni qaytaradi. Bu kutilmagan nojo'ya ta'sirlarning oldini olishga yordam beradi va kodni tushunishni osonlashtiradi.
• Tushunarli API: API eskirgan Date obyektiga qaraganda ancha tushunarli va izchil qilib ishlab chiqilgan.
• Vaqt Mintaqalarini Qo'llab-quvvatlash: Temporal vaqt mintaqalarini ishonchli qo'llab-quvvatlaydi, bu sizga dunyoning turli joylaridagi sana va vaqtlar bilan ishlash imkonini beradi.
• Taqvimlarni Qo'llab-quvvatlash: Grigorian taqvimidan tashqari, API boshqa taqvim tizimlaridan foydalanishga imkon beradi, bu esa global ilovalarni yaratishni osonlashtiradi.
• Kabisa soniyalarini hisobga olish: Temporal API kabisa soniyalarni hisobga oladi, bu esa vaqtni yanada aniqroq hisoblash imkonini beradi.

Temporal bilan ishlashni boshlash

Temporal API hali ishlab chiqilayotgan va barcha brauzerlar hamda Node.js muhitlarida to'liq qo'llab-quvvatlanmagan bo'lsa-da, bugunoq u bilan tajriba qilishni boshlash uchun polyfill'dan foydalanishingiz mumkin. Polyfill'ni npm orqali o'rnatishingiz mumkin:

            npm install @js-temporal/polyfill
            

              
                Copy
              
            
          

Keyin, polyfill'ni JavaScript kodingizga import qiling:

            import { Temporal } from '@js-temporal/polyfill';
            

              
                Copy
              
            
          

Polyfill o'rnatilgandan so'ng, siz Temporal obyekti va uning turli sinflaridan foydalanishni boshlashingiz mumkin.

Asosiy Temporal sinflari

Temporal API sana va vaqtlar bilan ishlash uchun bir nechta asosiy sinflarni taqdim etadi:

• Temporal.PlainDate: Hech qanday vaqt mintaqasi yoki kun vaqti ma'lumotisiz taqvim sanasini (yil, oy va kun) ifodalaydi.
• Temporal.PlainTime: Hech qanday sana yoki vaqt mintaqasi ma'lumotisiz kun vaqtini (soat, daqiqa, soniya va soniyaning ulushlari) ifodalaydi.
• Temporal.PlainDateTime: Hech qanday vaqt mintaqasi ma'lumotisiz sana va vaqtni ifodalaydi.
• Temporal.ZonedDateTime: Muayyan vaqt mintaqasiga ega bo'lgan sana va vaqtni ifodalaydi.
• Temporal.Instant: Unix epoxasidan (1970-yil 1-yanvar, 00:00:00 UTC) boshlab nanosekundlarda o'lchanadigan aniq bir vaqt nuqtasini ifodalaydi.
• Temporal.TimeZone: Vaqt mintaqasini ifodalaydi.
• Temporal.Duration: Soatlar, daqiqalar yoki soniyalar kabi vaqt davomiyligini ifodalaydi.
• Temporal.Now: Joriy sana va vaqtga kirishni ta'minlaydi.

PlainDate bilan ishlash

Temporal.PlainDate sinfi hech qanday vaqt mintaqasi yoki kun vaqti ma'lumotisiz sanani ifodalaydi. U tug'ilgan kunlar, yubileylar yoki boshqa sanaga asoslangan tadbirlarni ifodalash uchun foydalidir.

PlainDate yaratish:

            const plainDate = Temporal.PlainDate.from({ year: 2024, month: 10, day: 26 });
console.log(plainDate.toString()); // Natija: 2024-10-26
            

              
                Copy
              
            
          

Siz shuningdek, ISO 8601 formatidagi matndan PlainDate yaratishingiz mumkin:

            const plainDateFromString = Temporal.PlainDate.from('2024-12-25');
console.log(plainDateFromString.toString()); // Natija: 2024-12-25
            

              
                Copy
              
            
          

Sana komponentlariga murojaat qilish:

            const year = plainDate.year; // 2024
const month = plainDate.month; // 10
const day = plainDate.day;   // 26
const dayOfWeek = plainDate.dayOfWeek; // Hafta kuni (1-7, Dushanba-Yakshanba)
const dayOfYear = plainDate.dayOfYear; // Yilning kuni (1-366)
const daysInMonth = plainDate.daysInMonth; // Oydagi kunlar soni
const isLeapYear = plainDate.isLeapYear;   // Yilning kabisa yili ekanligini ko'rsatuvchi mantiqiy qiymat
            

              
                Copy
              
            
          

Kunlarni qo'shish va ayirish:

            const nextDay = plainDate.add({ days: 1 });
console.log(nextDay.toString()); // Natija: 2024-10-27

const previousWeek = plainDate.subtract({ weeks: 1 });
console.log(previousWeek.toString()); // Natija: 2024-10-19
            

              
                Copy
              
            
          

Sanalarni taqqoslash:

            const anotherDate = Temporal.PlainDate.from({ year: 2024, month: 11, day: 15 });

if (plainDate.equals(anotherDate)) {
  console.log('Sanalar teng');
} else if (plainDate.lessThan(anotherDate)) {
  console.log('plainDate anotherDate dan oldinroq');
} else {
  console.log('plainDate anotherDate dan keyinroq');
}
// Natija: plainDate anotherDate dan oldinroq
            

              
                Copy
              
            
          

PlainTime bilan ishlash

Temporal.PlainTime sinfi hech qanday sana yoki vaqt mintaqasi ma'lumotisiz kun vaqtini ifodalaydi. U ish vaqtlari, uchrashuv vaqtlari yoki boshqa vaqtga asoslangan tadbirlarni ifodalash uchun foydalidir.

PlainTime yaratish:

            const plainTime = Temporal.PlainTime.from({ hour: 14, minute: 30, second: 0 });
console.log(plainTime.toString()); // Natija: 14:30:00
            

              
                Copy
              
            
          

Siz shuningdek, ISO 8601 formatidagi matndan PlainTime yaratishingiz mumkin:

            const plainTimeFromString = Temporal.PlainTime.from('09:00:00');
console.log(plainTimeFromString.toString()); // Natija: 09:00:00
            

              
                Copy
              
            
          

Vaqt komponentlariga murojaat qilish:

            const hour = plainTime.hour;   // 14
const minute = plainTime.minute; // 30
const second = plainTime.second; // 0
const millisecond = plainTime.millisecond; // 0
const microsecond = plainTime.microsecond; // 0
const nanosecond = plainTime.nanosecond;   // 0
            

              
                Copy
              
            
          

Vaqtni qo'shish va ayirish:

            const laterTime = plainTime.add({ minutes: 15 });
console.log(laterTime.toString()); // Natija: 14:45:00

const earlierTime = plainTime.subtract({ hours: 1 });
console.log(earlierTime.toString()); // Natija: 13:30:00
            

              
                Copy
              
            
          

Vaqtlarni taqqoslash:

            const anotherTime = Temporal.PlainTime.from({ hour: 15, minute: 0, second: 0 });

if (plainTime.equals(anotherTime)) {
  console.log('Vaqtlar teng');
} else if (plainTime.lessThan(anotherTime)) {
  console.log('plainTime anotherTime dan oldinroq');
} else {
  console.log('plainTime anotherTime dan keyinroq');
}
// Natija: plainTime anotherTime dan oldinroq
            

              
                Copy
              
            
          

PlainDateTime bilan ishlash

Temporal.PlainDateTime sinfi hech qanday vaqt mintaqasi ma'lumotisiz sana va vaqtni ifodalaydi. U PlainDate va PlainTime funksionalliklarini birlashtiradi.

PlainDateTime yaratish:

            const plainDateTime = Temporal.PlainDateTime.from({ year: 2024, month: 10, day: 26, hour: 14, minute: 30, second: 0 });
console.log(plainDateTime.toString()); // Natija: 2024-10-26T14:30:00
            

              
                Copy
              
            
          

Siz shuningdek, ISO 8601 formatidagi matndan PlainDateTime yaratishingiz mumkin:

            const plainDateTimeFromString = Temporal.PlainDateTime.from('2024-12-25T09:00:00');
console.log(plainDateTimeFromString.toString()); // Natija: 2024-12-25T09:00:00
            

              
                Copy
              
            
          

Sana va Vaqt komponentlariga murojaat qilish:

            const year = plainDateTime.year;   // 2024
const month = plainDateTime.month; // 10
const day = plainDateTime.day;     // 26
const hour = plainDateTime.hour;   // 14
const minute = plainDateTime.minute; // 30
const second = plainDateTime.second; // 0
            

              
                Copy
              
            
          

Sana va Vaqtlarni qo'shish va ayirish:

            const nextDayAndTime = plainDateTime.add({ days: 1, hours: 2 });
console.log(nextDayAndTime.toString()); // Natija: 2024-10-27T16:30:00

const previousWeekAndTime = plainDateTime.subtract({ weeks: 1, minutes: 30 });
console.log(previousWeekAndTime.toString()); // Natija: 2024-10-19T14:00:00
            

              
                Copy
              
            
          

PlainDate va PlainTime'ga o'tkazish:

            const plainDateFromDateTime = plainDateTime.toPlainDate();
console.log(plainDateFromDateTime.toString()); // Natija: 2024-10-26

const plainTimeFromDateTime = plainDateTime.toPlainTime();
console.log(plainTimeFromDateTime.toString()); // Natija: 14:30:00
            

              
                Copy
              
            
          

ZonedDateTime bilan ishlash

Temporal.ZonedDateTime sinfi muayyan vaqt mintaqasiga ega bo'lgan sana va vaqtni ifodalaydi. Bu dunyoning turli joylarida sana va vaqtlarni boshqarishi kerak bo'lgan ilovalar uchun juda muhim. Eskirgan Date obyektidan farqli o'laroq, Temporal vaqt mintaqalarini ichki qo'llab-quvvatlaydi.

ZonedDateTime yaratish:

            const zonedDateTime = Temporal.ZonedDateTime.from({ year: 2024, month: 10, day: 26, hour: 14, minute: 30, second: 0, timeZone: 'America/Los_Angeles' });
console.log(zonedDateTime.toString()); // Natija: 2024-10-26T14:30:00-07:00[America/Los_Angeles]
            

              
                Copy
              
            
          

Siz shuningdek, Instant va vaqt mintaqasidan ZonedDateTime yaratishingiz mumkin:

            const instant = Temporal.Instant.fromEpochSeconds(1666785000); // Misol uchun timestamp
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO('Europe/London');
console.log(zonedDateTimeFromInstant.toString()); // Natija haqiqiy instantga qarab o'zgaradi, lekin Europe/London'dagi sana/vaqtni aks ettiradi
            

              
                Copy
              
            
          

Sana va Vaqt komponentlariga murojaat qilish:

            const year = zonedDateTime.year;   // 2024
const month = zonedDateTime.month; // 10
const day = zonedDateTime.day;     // 26
const hour = zonedDateTime.hour;   // 14
const minute = zonedDateTime.minute; // 30
const second = zonedDateTime.second; // 0
const timeZone = zonedDateTime.timeZone; // Temporal.TimeZone obyekti
            

              
                Copy
              
            
          

Vaqt Mintaqalari o'rtasida o'zgartirish:

            const newYorkDateTime = zonedDateTime.withTimeZone('America/New_York');
console.log(newYorkDateTime.toString()); // Natija: 2024-10-26T17:30:00-04:00[America/New_York]
            

              
                Copy
              
            
          

Yozgi Vaqtga O'tishni (DST) Boshqarish:

Temporal DST o'tishlarini avtomatik ravishda boshqaradi. Vaqtni qo'shish yoki ayirishda u DST'ni hisobga oladi va aniq natijalarni ta'minlaydi. Masalan, Germaniyada DST o'tishi vaqtiga rejalashtirilgan uchrashuvni ko'rib chiqing:

            const meetingStart = Temporal.ZonedDateTime.from({ year: 2024, month: 3, day: 31, hour: 2, minute: 30, timeZone: 'Europe/Berlin' });
const meetingEnd = meetingStart.add({ hours: 1 }); // 1 soat qo'shish
console.log(meetingEnd.toString()); // Natija: 2024-03-31T03:30:00+02:00[Europe/Berlin]. E'tibor bering, DST tufayli vaqt farqi (offset) o'zgaradi
            

              
                Copy
              
            
          

Instant bilan ishlash

Temporal.Instant sinfi Unix epoxasidan boshlab nanosekundlarda o'lchanadigan aniq bir vaqt nuqtasini ifodalaydi. U vaqtning aniq lahzalarini saqlash va taqqoslash uchun foydalidir.

Instant yaratish:

            const instant = Temporal.Instant.fromEpochSeconds(1666785000); // Soniyalarda misol uchun Unix timestampi
console.log(instant.toString()); // Natija o'sha lahzaning ISO matn ko'rinishi bo'ladi
            

              
                Copy
              
            
          

ZonedDateTime'ga o'tkazish:

            const zonedDateTimeFromInstant = instant.toZonedDateTimeISO('America/Los_Angeles');
console.log(zonedDateTimeFromInstant.toString()); // Natija: instantga mos keladigan America/Los_Angeles'dagi sana va vaqt
            

              
                Copy
              
            
          

Instantlarni taqqoslash:

            const anotherInstant = Temporal.Instant.fromEpochSeconds(1666790000);

if (instant.equals(anotherInstant)) {
  console.log('Instantlar teng');
} else if (instant.lessThan(anotherInstant)) {
  console.log('instant anotherInstant dan oldinroq');
} else {
  console.log('instant anotherInstant dan keyinroq');
}
// Natija: instant anotherInstant dan oldinroq
            

              
                Copy
              
            
          

Duration bilan ishlash

Temporal.Duration sinfi soatlar, daqiqalar yoki soniyalar kabi vaqt davomiyligini ifodalaydi. U ikki sana yoki vaqt o'rtasidagi farqni hisoblash uchun foydalidir.

Duration yaratish:

            const duration = Temporal.Duration.from({ hours: 2, minutes: 30 });
console.log(duration.toString()); // Natija: PT2H30M
            

              
                Copy
              
            
          

Sana/Vaqtlar o'rtasidagi farqni hisoblash:

            const startDate = Temporal.PlainDateTime.from({ year: 2024, month: 1, day: 1, hour: 0, minute: 0, second: 0 });
const endDate = Temporal.PlainDateTime.from({ year: 2024, month: 1, day: 3, hour: 12, minute: 30, second: 0 });
const difference = endDate.since(startDate);
console.log(difference.toString()); // Natija: P2DT12H30M

// Davomiylik komponentlariga murojaat qilish
console.log(difference.days);    // 2
console.log(difference.hours);   // 12
console.log(difference.minutes); // 30
            

              
                Copy
              
            
          

Sana/Vaqtlarga davomiylikni qo'shish:

            const newDate = startDate.add(duration);
console.log(newDate.toString()); // Natija: 2024-01-03T02:30:00
            

              
                Copy
              
            
          

Taqvimlar bilan ishlash

Temporal API Grigorian taqvimidan tashqari boshqa taqvim tizimlarini ham qo'llab-quvvatlaydi. Hali barcha polyfill va dvigatellarda to'liq joriy etilmagan bo'lsa-da, maqsad ilovalarga turli madaniyatlarga xos bo'lgan taqvimlardagi sanalarni boshqarish imkonini berishdir. Masalan, yapon taqvimidan foydalanish uchun (gipotetik tarzda, chunki joriy etish hali rivojlanmoqda):

            // Bu konseptual misol, chunki taqvimni qo'llab-quvvatlash hali ishlab chiqilmoqda
// const japaneseDate = Temporal.PlainDate.from({ year: 2024, month: 10, day: 26, calendar: 'japanese' });
// console.log(japaneseDate.toString()); // Kutilgan natija: Yapon taqvimiga muvofiq formatlangan natija

            

              
                Copy
              
            
          

Eslatma: Taqvimni qo'llab-quvvatlash Temporal API'ning rivojlanayotgan xususiyati bo'lib, to'liq funksionallik hali hamma joyda mavjud emas.

Amaliy misollar va qo'llash holatlari

Temporal API JavaScript'da sana va vaqtlarni boshqarish uchun keng imkoniyatlarni taklif etadi. Quyida ba'zi amaliy misollar va qo'llash holatlari keltirilgan:

• Uchrashuvlarni rejalashtirish: Foydalanuvchilarga o'zlarining mahalliy vaqt mintaqasida uchrashuvlarni bron qilish imkonini beradigan rejalashtirish ilovasini yarating. Temporal.ZonedDateTime vaqt mintaqalari o'rtasida o'zgartirishni va DST o'tishlarini boshqarishni osonlashtiradi. Berlindagi klinika uchun global miqyosda uchrashuvlarni rejalashtirish:

            const appointmentTimeBerlin = Temporal.ZonedDateTime.from({ year: 2024, month: 11, day: 5, hour: 10, minute: 0, timeZone: 'Europe/Berlin' });
const appointmentTimeLA = appointmentTimeBerlin.withTimeZone('America/Los_Angeles');
console.log(`Berlindagi uchrashuv vaqti: ${appointmentTimeBerlin.toString()}`);
console.log(`Los-Anjelesdagi uchrashuv vaqti: ${appointmentTimeLA.toString()}`);
            

              
                Copy
              
            
          

• Yoshni hisoblash: Foydalanuvchining tug'ilgan sanasi asosida uning yoshini aniqlang. PlainDate sizga tug'ilgan kunni hech qanday vaqt mintaqasi ma'lumotisiz ifodalash imkonini beradi.

            const birthDate = Temporal.PlainDate.from({ year: 1990, month: 5, day: 15 });
const today = Temporal.Now.plainDateISO();
const age = today.year - birthDate.year - (today.month < birthDate.month || (today.month === birthDate.month && today.day < birthDate.day) ? 1 : 0);
console.log(`Yosh: ${age}`);
            

              
                Copy
              
            
          

• Sana va Vaqtlarni turli formatlarda ko'rsatish: Sana va vaqtlarni foydalanuvchining mahalliy sozlamalariga muvofiq formatlang. Garchi internatsionallashtirish (Intl) xususiyatlari alohida bo'lsa-da, Temporal obyektlarini Intl API xususiyatlari bilan birlashtirilganda toLocaleString() yoki shunga o'xshash usullar yordamida osongina formatlash mumkin.

            const zonedDateTimeNow = Temporal.Now.zonedDateTimeISO('en-GB');
console.log(zonedDateTimeNow.toLocaleString('en-GB'));
console.log(zonedDateTimeNow.toLocaleString('de-DE'));
            

              
                Copy
              
            
          

• Tadbir davomiyligini kuzatish: Tadbirning davomiyligini hisoblang va uni odam o'qiy oladigan formatda ko'rsating. Duration sizga ikki sana yoki vaqt o'rtasidagi vaqt farqini ifodalash imkonini beradi.

            const eventStart = Temporal.Instant.fromEpochSeconds(1700000000); // Misol uchun boshlanish timestampi
const eventEnd = Temporal.Instant.fromEpochSeconds(1700005000);   // Misol uchun tugash timestampi
const durationOfEvent = eventEnd.since(eventStart);
console.log(`Tadbir davomiyligi: ${durationOfEvent.minutes} daqiqa`);
            

              
                Copy
              
            
          

Temporal API'dan foydalanish bo'yicha eng yaxshi amaliyotlar

Temporal API'dan foydalanishda yodda tutish kerak bo'lgan ba'zi eng yaxshi amaliyotlar:

• O'zgarmaslikdan foydalaning: Temporal obyektlarining o'zgarmasligini qabul qiling. Obyektlarni to'g'ridan-to'g'ri o'zgartirishdan saqlaning. Buning o'rniga, add, subtract va with kabi usullar yordamida yangi obyektlar yarating.
• Vaqt Mintaqalarini Ehtiyotkorlik bilan Boshqaring: Sana va vaqtlar bilan ishlashda vaqt mintaqalariga e'tiborli bo'ling. Muayyan vaqt mintaqasidagi sana va vaqtlarni ifodalash kerak bo'lganda ZonedDateTime'dan foydalaning.
• Aniq O'zgaruvchi Nomlaridan Foydalaning: Foydalanilayotgan Temporal obyektining turini aniq ko'rsatadigan tavsiflovchi o'zgaruvchi nomlaridan foydalaning (masalan, plainDate, zonedDateTime, duration).
• Polyfill'larni ko'rib chiqing: Temporal hali nisbatan yangi bo'lgani uchun, kerakli joylarda polyfill kutubxonasidan foydalanib, yetarli darajada qo'llab-quvvatlanishini ta'minlang.
• Kiritilgan ma'lumotlarni tekshiring: Sana va vaqtlarning to'g'ri formatda ekanligiga ishonch hosil qilish uchun har doim foydalanuvchi kiritgan ma'lumotlarni tekshiring.

Eskirgan Date'dan migratsiya

Eskirgan Date obyektidan migratsiya qilish bosqichma-bosqich jarayon bo'lishi mumkin. Quyidagi strategiyalarni ko'rib chiqing:

• Bosqichma-bosqich qabul qilish: Yangi kodda Temporal'dan foydalanishni boshlang, shu bilan birga ilovangizning mavjud qismlarida Date'ni saqlab qoling.
• O'rovchi funksiyalar (Wrapper Functions): Migratsiya davomida o'zaro ishlashni osonlashtirish uchun Date va Temporal obyektlari o'rtasida konvertatsiya qiluvchi o'rovchi funksiyalarni yarating.
• Puxta sinovdan o'tkazish: Barcha sana va vaqt hisob-kitoblarining to'g'riligiga ishonch hosil qilish uchun migratsiyani keng qamrovli sinovdan o'tkazing.

Temporal API va Moment.js

Moment.js JavaScript'da sana va vaqtni boshqarish uchun mashhur kutubxona bo'lgan, ammo hozirda u eskirgan loyiha hisoblanadi va texnik xizmat ko'rsatish rejimida. Temporal API Moment.js'ning ko'plab kamchiliklarini bartaraf etadigan zamonaviyroq va standartlashtirilgan yechimni taqdim etadi. Moment.js o'zgaruvchandir va vaqt mintaqalarini tabiiy qo'llab-quvvatlamaydi. Temporal API esa o'zgarmasdir va vaqt mintaqalarini tabiiy qo'llab-quvvatlaydi.

Xulosa

JavaScript Temporal API eskirgan Date obyektiga nisbatan sezilarli yaxshilanishni anglatadi. Uning o'zgarmasligi, tushunarli API'si, vaqt mintaqalarini va taqvimlarni qo'llab-quvvatlashi uni zamonaviy JavaScript ilovalarida sana va vaqtlar bilan ishlash uchun kuchli vositaga aylantiradi. Garchi qabul qilinishi hali o'sib borayotgan bo'lsa-da, polyfill'dan foydalanish bugunoq uning afzalliklaridan foydalanishni boshlash imkonini beradi. API kengroq qo'llab-quvvatlanar ekan, u JavaScript'da sana va vaqtlar bilan ishlashning standart usuliga aylanishi kutilmoqda.

Temporal API'ni qabul qiling va loyihalaringizda sana va vaqtlarni boshqarishning samaraliroq va ishonchli usulini oching, bu esa ilovangizning global vaqt mintaqalari va hisob-kitoblarini aniq boshqarishini ta'minlaydi.