JavaScript Temporal Duration: Vaqt oralig'ini hisoblashni o'zlashtirish

JavaScript'ning Temporal API'si sanalar, vaqtlar va vaqt oralig'ini boshqarishning zamonaviy va kuchli usulini taqdim etadi. Temporal.Duration ob'ekti vaqtning uzunligini ifodalaydi, vaqt oralig'i bilan hisoblashlarni bajarish uchun aniq va intuitiv yondashuvni ta'minlaydi. Ushbu maqola Temporal.Duration ning tafsilotlariga kiradi, turli xil foydalanish holatlarida davomiyliklarni yaratish, boshqarish va formatlash usullarini ko'rsatadi.

Temporal.Duration nima?

Temporal.Duration vaqt oralig'ini ifodalaydi, uni yillar, oylar, kunlar, soatlar, daqiqalar, soniyalar va soniyaning fraktsiyalari (millisekundlar, mikrosaniyalar, nanosaniyalar) bilan ifodalaydi. Muqobil ravishda ma'lum bir vaqt nuqtasini ifodalovchi Date ob'ektlaridan farqli o'laroq, Temporal.Duration vaqt miqdorini ifodalaydi. U ISO 8601 davomiylik formatiga (masalan, P1Y2M10DT2H30M 1 yil, 2 oy, 10 kun, 2 soat va 30 daqiqani bildiradi) rioya qiladi. Temporal API eski Date ob'ektiga qaraganda intuitivroq va kamroq xatoga yo'l qo'yish uchun mo'ljallangan.

Temporal.Duration ob'ektlarini yaratish

Temporal.Duration ob'ektlarini yaratishning bir necha usullari mavjud:

1. Oddiy ob'ektdan

Kerakli xususiyatlarga ega ob'ektni o'tkazish orqali davomiylikni yaratishingiz mumkin:

const duration = new Temporal.Duration(1, 2, 10, 2, 30, 0, 0, 0);
console.log(duration.toString()); // Output: P1Y2M10DT2H30M

Bu 1 yil, 2 oy, 10 kun, 2 soat va 30 daqiqalik davomiylik yaratadi. E'tibor bering, argumentlar quyidagi tartibga mos keladi: yillar, oylar, haftalar, kunlar, soatlar, daqiqalar, soniyalar, millisekundlar, mikrosaniyalar, nanosaniyalar.

2. ISO 8601 qatoridan

Siz Temporal.Duration.from() yordamida ISO 8601 davomiylik satridan davomiylikni yaratishingiz mumkin:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.toString()); // Output: P1Y2M10DT2H30M

Bu, ayniqsa, satr formatida saqlangan yoki tashqi manbadan olingan davomiylik bilan ishlashda foydalidir.

3. add() va subtract() usullarini Temporal.Instant, Temporal.ZonedDateTime va boshqalar bilan ishlatish

Boshqa Temporal turlaridan (masalan, Temporal.Instant yoki Temporal.ZonedDateTime) Temporal.Duration qo'shganingizda yoki olib tashlaganingizda, agar siz ularni keyin olib tashlasangiz, ikki vaqt nuqtasi orasidagi farqni ifodalovchi Temporal.Duration qaytariladi. Masalan:

const now = Temporal.Now.zonedDateTimeISO();
const later = now.add({ hours: 5 });
const duration = later.since(now);
console.log(duration.toString()); // Output: PT5H

Davomiylik komponentlariga kirish

Siz Temporal.Duration ob'ektining individual komponentlariga uning xususiyatlaridan foydalanib kirishingiz mumkin:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.years);      // Output: 1
console.log(duration.months);     // Output: 2
console.log(duration.days);       // Output: 10
console.log(duration.hours);      // Output: 2
console.log(duration.minutes);     // Output: 30
console.log(duration.seconds);     // Output: 0
console.log(duration.milliseconds); // Output: 0
console.log(duration.microseconds); // Output: 0
console.log(duration.nanoseconds);  // Output: 0

Davomiylik bilan arifmetikani bajarish

Temporal.Duration ob'ektlari add() va subtract() usullari yordamida qo'shish va ayirishni qo'llab-quvvatlaydi. Ushbu usullar operatsiya natijasini ifodalovchi yangi Temporal.Duration ob'ektini qaytaradi.

const duration1 = Temporal.Duration.from("P1Y2M");
const duration2 = Temporal.Duration.from("P3M4D");

const addedDuration = duration1.add(duration2);
console.log(addedDuration.toString()); // Output: P1Y5M4D

const subtractedDuration = duration1.subtract(duration2);
console.log(subtractedDuration.toString()); // Output: P10M26D

Siz yanada murakkab hisob-kitoblar uchun ushbu usullarni zanjir qilishingiz mumkin:

const duration = Temporal.Duration.from("P1D").add({ hours: 12 }).subtract({ minutes: 30 });
console.log(duration.toString()); // Output: P1DT11H30M

negated() usuli barcha komponentlari inkor qilingan yangi Temporal.Duration ob'ektini qaytaradi:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Output: -P1Y2M10DT2H30M

abs() usuli barcha komponentlari ijobiy qiymatlarga (mutlaq qiymatlarga) ega bo'lgan yangi Temporal.Duration ob'ektini qaytaradi:

const duration = Temporal.Duration.from("-P1Y2M10DT2H30M");
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Output: P1Y2M10DT2H30M

with() usuli sizga ba'zi yoki barcha xususiyatlari yangi qiymatlarga o'zgartirilgan yangi Temporal.Duration nusxasini yaratishga imkon beradi. Agar qiymat argument ob'ektida ko'rsatilmagan bo'lsa, davomiylikning asl qiymati ishlatiladi. Misol uchun:

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const newDuration = duration.with({ years: 2, days: 5 });
console.log(newDuration.toString()); // Output: P2Y2M5DT2H30M

Davomiyliklarni normallashtirish

Davomiylik ba'zan normallashtirilmagan shaklda ifodalanishi mumkin (masalan, P1Y12M, u P2Y ga soddalashtirilishi mumkin). normalized() usuli davomiylikni uning eng ixcham shakliga soddalashtirishga urinadi. Biroq, oy uzunligining o'zgarishining murakkabligini hal qilish uchun ma'lumot sanasi talab qilinadi. To'g'ri normallashtirish uchun sizga Temporal.PlainDate, Temporal.ZonedDateTime yoki Temporal.Instant nusxasi kerak bo'ladi.

Masalan, oylar va kunlarni o'z ichiga olgan davomiylikni normallashtirish ma'lumot sanasini talab qiladi:

const duration = Temporal.Duration.from("P1M32D");
const referenceDate = Temporal.PlainDate.from("2024-01-01");
const normalizedDuration = duration.normalized({ relativeTo: referenceDate });
console.log(normalizedDuration.toString()); // Output: P2M1D

Ushbu misolda, P1M32D davomiyligi 2024 yil 1 yanvarga nisbatan normallashtirilgan, natijada P2M1D ga olib keladi, chunki yanvar 31 kunga ega.

Agar siz faqat vaqt komponentlari (soatlar, daqiqalar, soniyalar va boshqalar) bilan ishlayotgan bo'lsangiz, ma'lumot sanasisiz normallashtirishingiz mumkin:

const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //or omit relativeTo argument
console.log(normalizedDuration.toString()); // Output: P1DT2H1M

Davomiylikni taqqoslash

Siz compare() usuli yordamida davomiylikni taqqoslashingiz mumkin. Ushbu usul quyidagilarni qaytaradi:

• -1 agar birinchi davomiylik ikkinchi davomiylikdan qisqaroq bo'lsa.
• 0 agar davomiyliklar teng bo'lsa.
• 1 agar birinchi davomiylik ikkinchi davomiylikdan uzunroq bo'lsa.

const duration1 = Temporal.Duration.from("P1Y");
const duration2 = Temporal.Duration.from("P6M");

const comparisonResult = Temporal.Duration.compare(duration1, duration2);
console.log(comparisonResult); // Output: 1

Amaliy misollar

1. Tadbirga qadar vaqtni hisoblash

Faraz qiling, siz ma'lum bir voqeagacha qolgan vaqtni hisoblashni xohlaysiz. Joriy vaqtni olish uchun Temporal.Now.zonedDateTimeISO() dan foydalanish va tadbir sanasini ayirish. Agar tadbirning sanasi o'tib ketgan bo'lsa, natija salbiy bo'ladi.

const eventDate = Temporal.ZonedDateTime.from({ timeZone: 'America/Los_Angeles', year: 2024, month: 12, day: 25, hour: 9, minute: 0, second: 0 });
const now = Temporal.Now.zonedDateTimeISO('America/Los_Angeles');

const durationUntilEvent = eventDate.since(now);

console.log(durationUntilEvent.toString()); // Output: e.g., P262DT14H30M (depending on the current date and time)

2. Loyiha vazifasining davomiyligini kuzatish

Loyihalarni boshqarishda siz Temporal.Duration dan vazifalarning taxminiy yoki haqiqiy davomiyligini kuzatish uchun foydalanishingiz mumkin.

const task1EstimatedDuration = Temporal.Duration.from("PT8H"); // 8 hours
const task2EstimatedDuration = Temporal.Duration.from("PT16H"); // 16 hours

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`Umumiy taxminiy davomiylik: ${totalEstimatedDuration.toString()}`); // Output: Total estimated duration: P1DT

3. Yoshni hisoblash

Yoshni aniq hisoblash sakrash yillarini va vaqt zonalarni hisobga olishni talab qilsa-da, Temporal.Duration o'rtacha bahoni taqdim etishi mumkin:

const birthDate = Temporal.PlainDate.from("1990-05-15");
const currentDate = Temporal.PlainDate.from("2024-01-20");

const ageDuration = currentDate.since(birthDate, { smallestUnit: 'years' });
console.log(`Taxminiy yosh: ${ageDuration.years} yil`); // Output: Estimated age: 33 years

4. Odam o'qiydigan davomiyliklarni ko'rsatish

Ko'pincha, siz davomiyliklarni odam o'qiydigan formatda ko'rsatishingiz kerak. Temporal.Duration o'rnatilgan formatlash funktsiyalariga ega bo'lmasa-da, siz maxsus formatlash mantiqini yaratishingiz mumkin:

function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} yil${duration.years > 1 ? 's' : ''}`);
  if (duration.months) parts.push(`${duration.months} oy${duration.months > 1 ? 's' : ''}`);
  if (duration.days) parts.push(`${duration.days} kun${duration.days > 1 ? 's' : ''}`);
  if (duration.hours) parts.push(`${duration.hours} soat${duration.hours > 1 ? 's' : ''}`);
  if (duration.minutes) parts.push(`${duration.minutes} daqiqa${duration.minutes > 1 ? 's' : ''}`);
  if (duration.seconds) parts.push(`${duration.seconds} soniya${duration.seconds > 1 ? 's' : ''}`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // Output: 1 yil, 2 oy, 10 kun, 2 soat, 30 daqiqa

Ilg'or foydalanish va e'tiborga olinishi kerak bo'lgan jihatlar

1. Vaqt zonalari bilan ishlash

Vaqt zonasi chegaralarini kesib o'tadigan yoki kunduzgi vaqt o'tishini o'z ichiga olgan vaqt oralig'i bilan ishlashda aniq hisob-kitoblarni ta'minlash uchun Temporal.ZonedDateTime dan foydalanish juda muhimdir. Temporal.PlainDate va Temporal.PlainTime dan foydalanish vaqt zonasi konvertatsiyasining oldini oladi.

2. Eng kichik birlik va yaxlitlash

since() va until() usullari ko'pincha natijada olingan davomiylik uchun eng kichik birlikni aniqlash uchun parametrlarni qabul qiladi. Misol uchun, tadbirga *qadar* vaqtni hisoblash va natijalarni kunlargacha cheklash.

const eventDate = Temporal.PlainDate.from("2024-12-25");
const now = Temporal.PlainDate.from("2024-01-20");

const durationUntilEvent = now.until(eventDate, { smallestUnit: 'days' });

console.log(durationUntilEvent.toString()); //example output PT340D

3. Sakrash soniyalar

Temporal sakrash soniyalarni mahalliy ravishda hisobga olmaydi. Agar siz haddan tashqari aniqlikni talab qilsangiz, siz sakrash soniyalarni alohida boshqarishingiz kerak bo'ladi.

4. IANA vaqt zonalari

Temporal API IANA (Internet Assigned Numbers Authority) vaqt zonasi ma'lumotlar bazasiga tayanadi. Vaqt zonasi konvertatsiyasini aniq boshqarish uchun sizning muhitingiz IANA ma'lumotlar bazasining yangilangan versiyasiga ega ekanligiga ishonch hosil qiling.

Eng yaxshi amaliyotlar

• Davomiylik satrlari uchun ISO 8601 formatidan foydalaning: Bu izchillik va o'zaro ishlashni ta'minlaydi.
• Tegishli Temporal turini tanlang: Vaqt zonasi qo'llab-quvvatlashi kerak yoki yo'qligiga qarab, Temporal.PlainDate, Temporal.PlainTime, Temporal.ZonedDateTime yoki Temporal.Instant dan foydalaning.
• Zarur bo'lganda davomiyliklarni normallashtiring: Normallashtirish davomiylikni soddalashtiradi va ularni taqqoslashni osonlashtiradi.
• Vaqt zonalarni ehtiyotkorlik bilan boshqaring: Vaqt zonasi konvertatsiyasi murakkab bo'lishi mumkin, shuning uchun Temporal.ZonedDateTime dan foydalaning va kunduzgi vaqt o'tishini biling.
• Eng kichik birlikni hisobga oling: Davomiylikni hisoblaganda, kerakli aniqlik darajasini olish uchun eng kichik birlikni ko'rsating.
• Birlik testlarini yozing: Davomiylikni hisoblash aniq bo'lishini ta'minlash uchun kodni sinchkovlik bilan sinab ko'ring.

Umumiy kamchiliklar

• Vaqt zonalarni e'tibordan chetda qoldirish: Vaqt zonalarni hisobga olmaslik, ayniqsa, turli joylardagi tadbirlar bilan ishlashda noto'g'ri davomiylik hisob-kitoblariga olib kelishi mumkin.
• Eski Date ob'ektidan foydalanish: Eski Date ob'ekti o'zining g'alati va mos kelmasligi bilan tanilgan. Ishonchliroq sana va vaqtni boshqarish uchun Temporal API'siga afzallik bering.
• Davomiyliklarni normallashtirmaslik: Davomiyliklarni normallashtirmaslik taqqoslash va hisob-kitoblarni murakkablashtirishi mumkin.
• Noto'g'ri ISO 8601 formati: Yaroqsiz ISO 8601 davomiylik satridan foydalanish xatolarga olib kelishi mumkin.

Turli madaniyatlar bo'ylab real dunyo misollari

Temporal API, vaqt zonasi farqlari va madaniy nuance'lar muhim bo'lgan global ilovalarda ayniqsa foydali bo'lishi mumkin. Mana bir nechta misollar:

• Global tadbirlarni rejalashtirish: Kunduzgi vaqt o'tishini hisobga olgan holda, bir nechta vaqt zonalari bo'ylab tadbirlarni aniq rejalashtirish. Misol uchun, PSTda ertalab soat 9:00 da boshlanadigan vebinarni rejalashtirish va CET, JST va AEDT kabi turli vaqt zonalarida tegishli boshlanish vaqtini ko'rsatish.
• Xalqaro sayohatlarni rejalashtirish: Ulanishlar va vaqt zonasi o'zgarishlarini o'z ichiga olgan sayohat davomiyligini hisoblash. Bu marshrutlarni yaratish va parvoz jadvallarini boshqarish uchun foydalidir. Misol uchun, Nyu-Yorkdan Tokioga sayohatning umumiy vaqtini hisoblash, Londonda ulanish va vaqt zonasi farqlarini hisobga olish.
• Global E-tijorat: Foydalanuvchining mahalliy vaqt zonasida taxminiy yetkazib berish vaqtlarini ko'rsatish. Bu kelib chiqish vaqt zonasi, yuk tashish muddati va maqsadli vaqt zonasini hisobga olishni talab qiladi. Misol uchun, Germaniyadagi omborxonadan Avstraliyadagi mijozga jo'natilgan mahsulot, taxminiy yetkazib berish muddati 7 kun, mijozning mahalliy vaqtida ko'rsatilgan.
• Chegaralararo moliyaviy operatsiyalar: Turli mintaqalarda foizlar hisoblanishi yoki to'lov muddatlarini aniq hisoblash. Bu ko'pincha har bir mamlakatdagi turli ish kunlari va bayramlarni hisobga olishni o'z ichiga oladi. Misol uchun, Singapurda olingan kredit bo'yicha Singapur davlat bayramlarini hisobga olgan holda hisoblangan foizni hisoblash.
• Multikultural taqvim ilovalari: Islom yoki Ibroniy taqvimi kabi turli xil kalendar tizimlarini qo'llab-quvvatlash va ushbu kalendarlarga asoslangan holda tadbirlarning davomiyligi va eslatmalarini aniq hisoblash.
• Global loyihalarni boshqarish: Turli ish jadvallari va vaqt zonalarini hisobga olgan holda, tarqatilgan jamoalar bo'ylab loyiha vazifalarining davomiyligi va muddatlarini kuzatish.

Xulosa

Temporal.Duration JavaScript-da vaqt oralig'i bilan ishlashning mustahkam va intuitiv usulini taqdim etadi. Uning xususiyatlari va eng yaxshi amaliyotlarini tushunish orqali siz o'z ilovalaringizda aniq va ishonchli davomiylik hisob-kitoblarini ishonch bilan bajarishingiz mumkin. Temporal API-ni qabul qilish toza, ko'proq saqlanib qoladigan kodga olib keladi va eski sana va vaqtni boshqarish bilan bog'liq xatarlarini kamaytiradi.

Temporal API-ga chuqurroq kirganingizda, rasmiy hujjatlarga murojaat qilishni va uning imkoniyatlarini to'liq tushunish uchun turli xil stsenariylar bilan tajriba qilishni unutmang. Zamonaviy dizayni va keng qamrovli xususiyatlari bilan Temporal JavaScript-da sanalar, vaqtlar va davomiyliklarni boshqarish usulini inqilob qilishga tayyor.