JavaScript Temporal Duration: Vaqt Intervallari Arifmetikasini O'zlashtirish

JavaScript Temporal API sana va vaqt bilan ishlash usullarimizni inqilob qilmoqda. Uning markazida vaqt intervallarini ifodalash va boshqarish uchun kuchli vosita bo'lgan Temporal.Duration obyekti yotadi. Ushbu keng qamrovli qo'llanma Temporal.Durationning nozik jihatlarini chuqur o'rganib chiqadi va sizga murakkab temporal arifmetikani osonlik va aniqlik bilan bajarish uchun bilim beradi.

Temporal.Duration nima?

Temporal.Duration yillar, oylar, kunlar, soatlar, daqiqalar, soniyalar va nanosekundlarda ifodalangan vaqt oralig'ini anglatadi. Muayyan bir vaqt nuqtasini ifodalovchi Datedan farqli o'laroq, Duration nisbiy vaqt miqdorini tavsiflaydi. Bu uni vaqt farqlari, siljishlar va takrorlanuvchi hodisalarni o'z ichiga olgan hisob-kitoblar uchun ideal qiladi.

Buni vaqt uchun bir retsept deb o'ylang. U sizga har bir vaqt birligidan qanchasini berilgan boshlang'ich nuqtadan qo'shish yoki ayirish kerakligini aytadi. Masalan, "1 yil, 2 oy va 3 kun" davomiyligi ma'lum bir sanadan keyin 1 yil, 2 oy va 3 kun o'tgandan keyingi sanani hisoblash uchun ishlatilishi mumkin.

Temporal.Duration Obyektlarini Yaratish

Temporal.Duration obyektini yaratishning bir necha yo'li mavjud:

1. Obyekt Literalidan

Eng oddiy yondashuv - har bir vaqt birligi uchun xususiyatlarga ega bo'lgan obyekt literalidan foydalanish:

            const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7); // 1 yil, 2 oy, 3 kun, 4 soat, 5 daqiqa, 6 soniya, 7 nanosekund
console.log(duration.toString()); // 'P1Y2M3DT4H5M6.000000007S'
            

              
                Copy
              
            
          

Nolga teng bo'lgan xususiyatlarni qoldirib ketishingiz mumkin. Masalan:

            const duration = new Temporal.Duration(0, 0, 7); // 7 kun
console.log(duration.toString()); // 'P7D'
            

              
                Copy
              
            
          

2. ISO 8601 Satridan

Temporal.Duration shuningdek ISO 8601 davomiylik satridan ham yaratilishi mumkin:

            const duration = Temporal.Duration.from('P1Y2M3DT4H5M6S'); // 1 yil, 2 oy, 3 kun, 4 soat, 5 daqiqa, 6 soniya
console.log(duration.toString()); // 'P1Y2M3DT4H5M6S'

const duration2 = Temporal.Duration.from('PT30M'); // 30 daqiqa
console.log(duration2.toString()); // 'PT30M'
            

              
                Copy
              
            
          

Bu usul, ayniqsa, ISO 8601 formatidan foydalanadigan tashqi manbalardan olingan ma'lumotlar bilan ishlaganda foydalidir. Satr formati P[yillar]Y[oylar]M[kunlar]D[T[soatlar]H[daqiqalar]M[soniyalar]S] naqshiga amal qiladi.

3. Boshqa Temporal Turlaridan

Siz until() metodidan foydalanib, ikkita Temporal.Instant, Temporal.ZonedDateTime, Temporal.PlainDate yoki Temporal.PlainTime obyektlari orasidagi davomiylikni hisoblashingiz mumkin. Bu, ayniqsa, ikki hodisa o'rtasida o'tgan vaqtni aniqlash uchun foydalidir.

            const start = Temporal.PlainDate.from('2023-01-01');
const end = Temporal.PlainDate.from('2023-03-15');
const duration = start.until(end);
console.log(duration.toString()); // 'P2M14D'
            

              
                Copy
              
            
          

Duration Xususiyatlariga Kirish

Temporal.Duration obyektiga ega bo'lganingizdan so'ng, uning xususiyatlariga kirish orqali alohida vaqt komponentlarini olishingiz mumkin:

            const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7);

console.log(duration.years); // 1
console.log(duration.months); // 2
console.log(duration.days); // 3
console.log(duration.hours); // 4
console.log(duration.minutes); // 5
console.log(duration.seconds); // 6
console.log(duration.nanoseconds); // 7
            

              
                Copy
              
            
          

Bu xususiyatlar faqat o'qish uchun mo'ljallangan bo'lib, Duration obyektining o'zgarmasligini ta'minlaydi.

Temporal.Duration Arifmetikasi

Temporal.Durationning asosiy kuchli tomonlaridan biri bu arifmetik amallarni bajara olish qobiliyatidir. Siz davomiyliklarni qo'shishingiz, ayirishingiz, ko'paytirishingiz va bo'lishingiz mumkin, bu esa murakkab vaqt hisob-kitoblarini ancha osonlashtiradi.

1. Davomiyliklarni Qo'shish

Ikki davomiylikni bir-biriga qo'shish uchun add() metodidan foydalaning:

            const duration1 = new Temporal.Duration(1, 2, 3);
const duration2 = new Temporal.Duration(0, 0, 7);
const sum = duration1.add(duration2);
console.log(sum.toString()); // 'P1Y2M10D'
            

              
                Copy
              
            
          

2. Davomiyliklarni Ayirish

Bir davomiylikdan boshqasini ayirish uchun subtract() metodidan foydalaning:

            const duration1 = new Temporal.Duration(1, 2, 3);
const duration2 = new Temporal.Duration(0, 0, 7);
const difference = duration1.subtract(duration2);
console.log(difference.toString()); // 'P1Y2M-4D'
            

              
                Copy
              
            
          

E'tibor bering, kichikroq davomiylikdan kattaroq davomiylikni ayirish ba'zi xususiyatlar uchun manfiy qiymatlarga olib kelishi mumkin.

3. Davomiyliklarni Ko'paytirish

Davomiylikni skalyar qiymatga ko'paytirish uchun multiply() metodidan foydalaning:

            const duration = new Temporal.Duration(1, 0, 0);
const doubled = duration.multiply(2);
console.log(doubled.toString()); // 'P2Y'
            

              
                Copy
              
            
          

Bu ma'lum bir hodisaning, masalan, ikki baravar uzunligini ifodalash uchun davomiyliklarni masshtablashda foydalidir.

4. Davomiylikni O'zgartirish

Davomiylikni o'zgartirish uchun negated() yoki abs() metodidan foydalaning:

            const duration = new Temporal.Duration(1, 0, 0);
const negated = duration.negated();
console.log(negated.toString()); // 'P-1Y'

const durationNegative = new Temporal.Duration(-1, 0, 0);
const absoluteValue = durationNegative.abs();
console.log(absoluteValue.toString()); // 'P1Y'

            

              
                Copy
              
            
          

Davomiyliklarni Normallashtirish

Davomiyliklar ba'zan normallashtirilmagan holatda bo'lishi mumkin, ya'ni ular kattaroq birliklar bilan ifodalanishi mumkin bo'lgan komponentlarni o'z ichiga oladi. Masalan, "1 yil va 12 oy" davomiyligi "2 yil" ga normallashtirilishi mumkin.

Davomiylikni normallashtirish uchun siz Temporal.PlainDate kabi boshqa Temporal turi bilan birgalikda toPlainDays(), toPlainHours(), toPlainMinutes(), toPlainSeconds() yoki toPlainNanoseconds() metodlaridan foydalanishingiz mumkin. Normallashtirish o'zgaruvchan uzunlikdagi oylar va kabisa yillarini to'g'ri hisobga olish uchun kontekst talab qiladi.

            const plainDate = Temporal.PlainDate.from('2024-01-01'); // Misol uchun boshlang'ich sana
const duration = new Temporal.Duration(0, 13, 0); // 13 oy

// Sana kontekstiga normallashtirish
const normalizedDate = plainDate.add(duration);

// Boshlang'ich sanadan normallashtirilgan sanagacha bo'lgan davomiylikni hisoblash
const normalizedDuration = plainDate.until(normalizedDate);
console.log(normalizedDuration.toString()); // Chiqish: 'P1Y1M'
            

              
                Copy
              
            
          

Ushbu misolda, 2024-yil 1-yanvarga 13 oylik davomiylikni qo'shish 2025-yil 1-fevralga olib keladi. Keyin until() metodi boshlang'ich sana va natijaviy sana o'rtasidagi davomiylikni hisoblab, bizga 1 yil va 1 oylik normallashtirilgan davomiylikni beradi.

Har Xil Temporal Turlari Bilan Ishlash

Temporal.Duration boshqa Temporal turlari, masalan, Temporal.Instant, Temporal.ZonedDateTime, Temporal.PlainDate va Temporal.PlainTime bilan uzluksiz ishlash uchun mo'ljallangan. Bu sizga vaqtning ma'lum nuqtalari va sanalarini o'z ichiga olgan murakkab temporal hisob-kitoblarni bajarishga imkon beradi.

1. Temporal.PlainDate'ga Davomiyliklarni Qo'shish

Kelajakdagi sanani hisoblash uchun Temporal.PlainDatega Duration qo'shishingiz mumkin:

            const startDate = Temporal.PlainDate.from('2023-01-01');
const duration = new Temporal.Duration(1, 0, 0); // 1 yil
const futureDate = startDate.add(duration);
console.log(futureDate.toString()); // '2024-01-01'
            

              
                Copy
              
            
          

2. Temporal.ZonedDateTime'dan Davomiyliklarni Ayirish

Xuddi shunday, o'tgan sana va vaqtni hisoblash uchun Temporal.ZonedDateTimedan Durationni ayirishingiz mumkin:

            const startDateTime = Temporal.ZonedDateTime.from('2023-01-01T12:00:00+00:00[UTC]');
const duration = new Temporal.Duration(0, 0, 0, 6); // 6 soat
const pastDateTime = startDateTime.subtract(duration);
console.log(pastDateTime.toString()); // '2023-01-01T06:00:00+00:00[UTC]'
            

              
                Copy
              
            
          

Amaliy Misollar va Qo'llash Holatlari

Temporal.Duration ko'plab amaliy qo'llanmalarga ega ko'p qirrali vositadir. Mana bir nechta misollar:

1. Yoshni Hisoblash

Siz Temporal.Duration yordamida odamning tug'ilgan sanasiga qarab yoshini hisoblashingiz mumkin:

            const birthDate = Temporal.PlainDate.from('1990-05-15');
const today = Temporal.Now.plainDateISO();
const ageDuration = birthDate.until(today);

console.log(`Yosh: ${ageDuration.years} yil, ${ageDuration.months} oy, ${ageDuration.days} kun`);
            

              
                Copy
              
            
          

2. Takrorlanuvchi Hodisalarni Rejalashtirish

Temporal.Duration haftalik yig'ilishlar yoki oylik hisobotlar kabi takrorlanuvchi hodisalarni rejalashtirish uchun idealdir. Siz undan hodisaning takrorlanish oralig'iga qarab keyingi sodir bo'lish vaqtini hisoblash uchun foydalanishingiz mumkin.

3. Sayohatni Rejalashtirish uchun Vaqt Farqlarini Hisoblash

Xalqaro sayohatni rejalashtirayotganda, siz ikki joy o'rtasidagi vaqt farqini hisoblash uchun Temporal.Durationdan foydalanishingiz mumkin:

            const departureTime = Temporal.ZonedDateTime.from('2023-03-01T10:00:00+01:00[Europe/Paris]');
const arrivalTime = Temporal.ZonedDateTime.from('2023-03-01T14:00:00-08:00[America/Los_Angeles]');
const flightDuration = departureTime.until(arrivalTime);

console.log(`Parvoz Davomiyligi: ${flightDuration.hours} soat, ${flightDuration.minutes} daqiqa`);
            

              
                Copy
              
            
          

4. Ortga Sanash Taymerlarini Amalga Oshirish

Maxsus tadbirlar, mahsulot taqdimotlari yoki muddatlar uchun ortga sanash taymerlarini yarating va qolgan vaqtni dinamik ravishda ko'rsating.

5. Ishlash Ko'rsatkichlarini O'lchash

Ishlashdagi zaif nuqtalarni aniqlash va kodni optimallashtirish uchun muhim kod bajarilish qismlarining davomiyligini yozib oling.

Internatsionalizatsiya Masalalari

Global miqyosda sana va vaqt bilan ishlaganda, internatsionalizatsiyani hisobga olish juda muhim. Temporal API sizga turli vaqt mintaqalari, taqvimlar va lokallarni boshqarishga yordam beradigan bir qancha xususiyatlarni taqdim etadi.

1. Vaqt Mintaqalari

Muayyan vaqt mintaqalaridagi sana va vaqt bilan ishlash uchun Temporal.ZonedDateTimedan foydalaning. Bu foydalanuvchining joylashuvidan qat'i nazar, hisob-kitoblaringizning aniqligini ta'minlaydi.

2. Taqvimlar

Temporal API Grigorian, Islomiy va Yapon taqvimlari kabi turli taqvimlarni qo'llab-quvvatlaydi. Siz Temporal.PlainDate yoki Temporal.ZonedDateTime obyektini yaratishda taqvimni belgilashingiz mumkin.

3. Lokallar

Sana va vaqtni foydalanuvchi lokaliga muvofiq formatlash uchun toLocaleString() metodidan foydalaning. Bu sana va vaqtning madaniy jihatdan mos ravishda ko'rsatilishini ta'minlaydi.

            const date = Temporal.PlainDate.from('2023-03-15');

console.log(date.toLocaleString('en-US')); // '3/15/2023'
console.log(date.toLocaleString('fr-FR')); // '15/03/2023'
console.log(date.toLocaleString('ja-JP')); // '2023/03/15'
            

              
                Copy
              
            
          

Temporal.Duration Bilan Ishlashning Eng Yaxshi Amaliyotlari

Kodingiz mustahkam va qo'llab-quvvatlanadigan bo'lishini ta'minlash uchun Temporal.Duration bilan ishlaganda quyidagi eng yaxshi amaliyotlarga rioya qiling:

• Temporal APIdan doimiy foydalaning: Temporal APIni eski Date obyekti bilan aralashtirishdan saqlaning, chunki bu nomuvofiqliklar va xatolarga olib kelishi mumkin.
• Vaqt mintaqalarini ehtiyotkorlik bilan boshqaring: Muayyan joylashuvga tegishli sana va vaqt bilan ishlaganda har doim vaqt mintaqasini belgilang.
• Foydalanuvchi kiritgan ma'lumotlarni tekshiring: Foydalanuvchi kiritgan ma'lumotlarning to'g'ri formatda va kutilgan diapazonda ekanligini tekshiring.
• Kodingizni sinchkovlik bilan sinab ko'ring: Kodingiz barcha stsenariylarda to'g'ri ishlashini ta'minlash uchun uni turli vaqt mintaqalari, taqvimlar va lokallar bilan sinab ko'ring.
• Kodingizni hujjatlashtiring: Har bir funksiyaning maqsadi va u qiladigan taxminlarni tushuntirib, kodingizni aniq va qisqa hujjatlashtiring.

Umumiy Xatolar va Ulardan Qochish Yo'llari

Temporal API sana va vaqt bilan ishlashni soddalashtirsa-da, ba'zi xatolar kutilmagan natijalarga olib kelishi mumkin. Ishonchli kod yozish uchun ushbu umumiy muammolardan xabardor bo'lish va ulardan qanday qochishni bilish juda muhimdir.

1. Noto'g'ri Davomiylik Satri Formati

Davomiylik satri ISO 8601 formatiga qat'iy mos kelishiga ishonch hosil qiling. Hatto kichik bir og'ish ham tahlil qilishda xatolarga yoki noto'g'ri hisob-kitoblarga olib kelishi mumkin.

            // Noto'g'ri: Vaqt komponentlari uchun 'T' yo'q
// Temporal.Duration.from('P1D2H3M'); // Bu xato berishi yoki kutilmagan natijalar keltirib chiqarishi mumkin

// To'g'ri: To'g'ri ISO 8601 formati
const duration = Temporal.Duration.from('P1DT2H3M');
console.log(duration.toString()); // Chiqish: 'P1DT2H3M'
            

              
                Copy
              
            
          

2. Kabisa Yillari va Yozgi Vaqtga O'tishni E'tiborsiz Qoldirish

Kabisa yillari va yozgi vaqtga o'tish (DST) davomiylikni hisoblashga, ayniqsa uzoq vaqt intervallari bilan ishlaganda, sezilarli ta'sir ko'rsatishi mumkin. Ushbu anomaliyalarni hisobga olish uchun har doim tegishli Temporal turlari va metodlaridan foydalaning.

            // Yozgi Vaqtga O'tish bilan misol
const plainDateTime = Temporal.PlainDate.from('2023-03-12'); // AQShda yozgi vaqtga o'tish kuni
const duration1Day = Temporal.Duration.from('P1D');
const nextDay = plainDateTime.add(duration1Day);

console.log(nextDay.toString()); // Sana DST tufayli vaqt o'zgarishini hisobga olgan holda to'g'ri o'zgaradi
            

              
                Copy
              
            
          

3. Temporal Turlarini Noto'g'ri Aralashtirish

Hisob-kitoblaringiz uchun to'g'ri Temporal turlaridan foydalanayotganingizga ishonch hosil qiling. Masalan, vaqt mintaqasini bilishni talab qiladigan amallar uchun Temporal.PlainDatedan foydalanishdan saqlaning.

4. Noto'g'ri Normallashtirish Taxminlari

Oylar yoki yillar kabi noaniq birliklarni to'g'ri boshqarish uchun har doim davomiyliklarni ma'lum bir kontekstda (masalan, Temporal.PlainDatega nisbatan) normallashtiring.

            // Noto'g'ri: Bir oy har doim 30 kun deb taxmin qilish
const duration = new Temporal.Duration(0, 1, 0); // 1 oy
// const daysInMonth = duration.months * 30; // Bu aniq emas

// To'g'ri: Muayyan oydagi kunlarni aniqlash uchun Temporal.PlainDate'dan foydalanish
const startDate = Temporal.PlainDate.from('2023-02-01');
const endDate = startDate.add({ months: 1 });
const daysInMonth = startDate.until(endDate, { unit: 'days' }).days;
console.log(daysInMonth); // Chiqish: 28 (2023-yil fevral uchun)
            

              
                Copy
              
            
          

Xulosa

Temporal.Duration JavaScriptda vaqt intervallari bilan ishlash uchun kuchli vositadir. Uning xususiyatlari, metodlari va eng yaxshi amaliyotlarini tushunish orqali siz murakkab temporal arifmetikani osonlik va aniqlik bilan bajara olasiz. Temporal API kengroq qo'llanila boshlagan sari, Temporal.Durationni o'zlashtirish har bir JavaScript dasturchisi uchun muhim mahoratga aylanadi. Yoshni hisoblayapsizmi, tadbirlarni rejalashtiryapsizmi yoki xalqaro sayohatni rejalashtiryapsizmi, Temporal.Duration vaqt bilan bog'liq barcha ehtiyojlaringiz uchun mustahkam va ishonchli yechim taqdim etadi. Temporal APIni qabul qiling va JavaScript kodingizda yangi darajadagi aniqlik va tiniqlikni oching.

Ushbu qo'llanma Temporal.Durationning asosiy jihatlarini qamrab oldi. Temporal APIga chuqurroq kirib borganingiz sari, o'zingizning temporal dasturlash mahoratingizni yanada oshirish uchun maxsus taqvimlar va vaqt mintaqalarini boshqarish kabi uning ilg'or xususiyatlarini o'rganing. Eng so'nggi ma'lumotlar va spetsifikatsiyalar uchun rasmiy ECMAScript Temporal hujjatlariga murojaat qilishni unutmang.

Omadli kodlash!