JavaScript Temporal Instant: Yuqori aniqlikdagi vaqt hisob-kitoblari

JavaScript uzoq vaqtdan beri sana va vaqt bilan ishlashning unchalik mukammal bo'lmagan imkoniyatlari bilan mashhur edi. Garchi keng qo'llanilsa-da, eski Date obyekti o'zgaruvchanligi, API'ning nomuvofiq ishlashi va vaqt zonalarini yomon qo'llab-quvvatlashi bilan ajralib turadi. Bu kamchiliklarni bartaraf etish uchun mo'ljallangan sana va vaqtni boshqarishning zamonaviy yondashuvi bo'lgan Temporal API maydonga chiqdi. Temporalning markazida nanosoniya aniqligidagi ma'lum bir vaqt nuqtasini ifodalovchi Instant obyekti yotadi. Ushbu blog posti turli ehtiyojlarga ega global auditoriyaga mo'ljallangan JavaScript ilovalaringizda yuqori aniqlikdagi vaqt hisob-kitoblari uchun Temporal.Instant'dan foydalanish bo'yicha to'liq qo'llanmani taqdim etadi.

Temporal.Instant nima?

Temporal.Instant Unix epoxasidan (1970-yil 1-yanvar, 00:00:00 Umumjahon Muvofiqlashtirilgan Vaqti (UTC)) boshlab nanosoniya aniqligida o'lchanadigan vaqt nuqtasini ifodalaydi. Eski Date obyektidan farqli o'laroq, Temporal.Instant o'zgarmasdir, ya'ni uning qiymatini yaratilgandan keyin o'zgartirib bo'lmaydi. Bu o'zgarmaslik, ayniqsa murakkab ilovalarda, kutilmagan nojo'ya ta'sirlarning oldini olish va ma'lumotlar yaxlitligini ta'minlash uchun juda muhimdir.

Temporal.Instant obyektlarini yaratish

Temporal.Instant obyektlarini yaratishning bir necha yo'li mavjud:

1. Sondan (Epoxadan beri o'tgan millisoniyalar)

Unix epoxasidan beri o'tgan millisoniyalar sonidan Instant yaratishingiz mumkin. Bu eski Date obyektining ishlashiga o'xshaydi, ammo Temporal.Instant yuqori aniqlikni taqdim etadi.

            
const instant = Temporal.Instant.fromEpochMilliseconds(1678886400000); // 15-mart, 2023-yil, 00:00:00 UTC
console.log(instant.toString()); // Natija: 2023-03-15T00:00:00Z

            

              
                Copy
              
            
          

2. Sondan (Epoxadan beri o'tgan nanosoniyalar)

Yanada yuqori aniqlik uchun Unix epoxasidan beri o'tgan nanosoniyalar sonidan Instant yaratishingiz mumkin. Bu Temporal.Instant yordamida vaqt nuqtasini ifodalashning eng aniq usulidir.

            
const instant = Temporal.Instant.fromEpochNanoseconds(1678886400000000000n); // 15-mart, 2023-yil, 00:00:00 UTC
console.log(instant.toString()); // Natija: 2023-03-15T00:00:00Z

            

              
                Copy
              
            
          

BigInt literalini bildirish uchun n qo'shimchasidan foydalanilganiga e'tibor bering. Nanosoniya qiymatlari ko'pincha JavaScript sonlari uchun maksimal xavfsiz butun son qiymatidan oshib ketadi, shuning uchun aniqlikni saqlab qolish uchun BigInt'dan foydalanish zarur.

3. ISO 8601 qatoridan

Temporal.Instant shuningdek, UTC sana va vaqtini ifodalovchi ISO 8601 qatoridan ham yaratilishi mumkin.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
console.log(instant.toString()); // Natija: 2023-03-15T00:00:00Z

const instantWithFractionalSeconds = Temporal.Instant.from('2023-03-15T00:00:00.123456789Z');
console.log(instantWithFractionalSeconds.toString()); // Natija: 2023-03-15T00:00:00.123456789Z

            

              
                Copy
              
            
          

ISO 8601 qatori UTC'ni bildirish uchun Z harfi bilan tugashi kerak. Qator ixtiyoriy ravishda to'qqiz raqamgacha aniqlikdagi kasr soniyalarni o'z ichiga olishi mumkin.

4. Temporal.Now'dan (Tizim soati)

Joriy vaqt momentini Temporal.Now.instant() yordamida olishingiz mumkin:

            
const now = Temporal.Now.instant();
console.log(now.toString()); // Natija: Joriy vaqtga qarab o'zgaradi

            

              
                Copy
              
            
          

Temporal.Instant obyektlari bilan ishlash

Temporal.Instant obyektini olganingizdan so'ng, uning ustida turli amallarni bajarishingiz mumkin. Esda tutingki, Temporal.Instant obyektlari o'zgarmasdir, shuning uchun bu amallar asl nusxani o'zgartirmasdan, yangi Temporal.Instant obyektlarini qaytaradi.

1. Vaqtni qo'shish va ayirish

Instant'ga vaqtni add() va subtract() metodlari yordamida qo'shishingiz yoki ayirishingiz mumkin. Bu metodlar vaqt oralig'ini ifodalovchi Temporal.Duration obyektini qabul qiladi.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const duration = Temporal.Duration.from({ hours: 2, minutes: 30 });

const futureInstant = instant.add(duration);
console.log(futureInstant.toString()); // Natija: 2023-03-15T02:30:00Z

const pastInstant = instant.subtract(duration);
console.log(pastInstant.toString()); // Natija: 2023-03-14T21:30:00Z

            

              
                Copy
              
            
          

Davomiylik uchun qator ko'rinishidan ham foydalanishingiz mumkin:

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const futureInstant = instant.add('PT2H30M'); // ISO 8601 davomiylik qatori
console.log(futureInstant.toString()); // Natija: 2023-03-15T02:30:00Z

            

              
                Copy
              
            
          

2. Instant'larni taqqoslash

Ikki Temporal.Instant obyektini compare() metodi yordamida taqqoslashingiz mumkin. Bu metod quyidagilarni qaytaradi:

• -1, agar birinchi instant ikkinchisidan oldin bo'lsa.
• 0, agar ikkita instant teng bo'lsa.
• 1, agar birinchi instant ikkinchisidan keyin bo'lsa.

            
const instant1 = Temporal.Instant.from('2023-03-15T00:00:00Z');
const instant2 = Temporal.Instant.from('2023-03-15T01:00:00Z');

console.log(Temporal.Instant.compare(instant1, instant2)); // Natija: -1
console.log(Temporal.Instant.compare(instant2, instant1)); // Natija: 1
console.log(Temporal.Instant.compare(instant1, instant1)); // Natija: 0

            

              
                Copy
              
            
          

3. Boshqa Temporal turlariga o'tkazish

Temporal.Instant'ni boshqa Temporal turlariga, masalan, Temporal.ZonedDateTime, Temporal.PlainDateTime va Temporal.PlainDate'ga o'tkazish mumkin. Bu vaqt zonalari va mahalliylashtirilgan sana va vaqt ko'rinishlari bilan ishlash uchun juda muhimdir.

a. Temporal.ZonedDateTime'ga

Temporal.ZonedDateTime ma'lum bir vaqt zonasiga ega sana va vaqtni ifodalaydi. Instant'ni ZonedDateTime'ga o'tkazish uchun vaqt zonasini ko'rsatishingiz kerak.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
console.log(zonedDateTime.toString()); // Natija: 2023-03-14T17:00:00-07:00[America/Los_Angeles]

            

              
                Copy
              
            
          

toZonedDateTimeISO() metodi ISO 8601 taqvimidan foydalanib ZonedDateTime yaratadi. Boshqa taqvimni belgilash uchun toZonedDateTime() metodidan ham foydalanishingiz mumkin.

b. Temporal.PlainDateTime'ga

Temporal.PlainDateTime vaqt zonasiz sana va vaqtni ifodalaydi. Instant'ni PlainDateTime'ga o'tkazish uchun avval uni ZonedDateTime'ga o'tkazishingiz, so'ngra undan PlainDateTime'ni olishingiz kerak.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
const plainDateTime = zonedDateTime.toPlainDateTime();
console.log(plainDateTime.toString()); // Natija: 2023-03-14T17:00:00

            

              
                Copy
              
            
          

c. To Temporal.PlainDate'ga

Temporal.PlainDate vaqt yoki vaqt zonasiz sanani ifodalaydi. PlainDateTime'ga o'xshab, avval ZonedDateTime'ga o'tkazasiz.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
const plainDate = zonedDateTime.toPlainDate();
console.log(plainDate.toString()); // Natija: 2023-03-14

            

              
                Copy
              
            
          

4. Epoxadan beri o'tgan millisoniya va nanosoniyalarni olish

Unix epoxasidan beri o'tgan millisoniyalar yoki nanosoniyalar sonini mos ravishda epochMilliseconds va epochNanoseconds xususiyatlari yordamida olishingiz mumkin.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00.123456789Z');
console.log(instant.epochMilliseconds); // Natija: 1678886400123
console.log(instant.epochNanoseconds); // Natija: 1678886400123456789n

            

              
                Copy
              
            
          

Temporal.Instant'dan foydalanish holatlari

Temporal.Instant ayniqsa yuqori aniqlikdagi vaqt hisob-kitoblari talab qilinadigan holatlarda foydalidir. Mana bir nechta misollar:

1. Hodisalarni qayd etish va audit

Hodisalarni qayd etishda yoki tizim faoliyatini audit qilishda hodisaning aniq vaqtini qayd etish juda muhim. Temporal.Instant vaqt belgilarini aniq yozib olish uchun zarur aniqlikni ta'minlaydi.

            
function logEvent(eventDescription) {
  const timestamp = Temporal.Now.instant().toString();
  console.log(`[${timestamp}] ${eventDescription}`);
}

logEvent('Foydalanuvchi tizimga kirdi');
logEvent('Fayl saqlandi');

            

              
                Copy
              
            
          

2. Ishlash samaradorligini o'lchash

Kodning ishlash samaradorligini o'lchash aniq vaqtni talab qiladi. Temporal.Instant kod bloklarining bajarilish vaqtini nanosoniya aniqligida o'lchash uchun ishlatilishi mumkin.

            
const start = Temporal.Now.instant();
// O'lchanadigan kod
for (let i = 0; i < 1000000; i++) {
  // Qandaydir operatsiya
}
const end = Temporal.Now.instant();

const duration = end.since(start);
console.log(`Bajarilish vaqti: ${duration.total('milliseconds')} millisoniya`);

            

              
                Copy
              
            
          

3. Taqsimlangan tizimlar va ma'lumotlarni sinxronlashtirish

Taqsimlangan tizimlarda bir nechta tugunlar bo'ylab ma'lumotlar izchilligini saqlash ko'pincha aniq vaqt sinxronizatsiyasini talab qiladi. Temporal.Instant ma'lumotlar yangilanishlari uchun vaqt belgilarini ifodalash va vaqtga asoslangan ziddiyatlarni hal qilish uchun ishlatilishi mumkin.

Masalan, ma'lumotlar turli geografik joylashuvlardagi bir nechta serverlar bo'ylab takrorlanadigan stsenariyni ko'rib chiqing (masalan, kontent yetkazib berish tarmog'i yoki taqsimlangan ma'lumotlar bazasi). Agar foydalanuvchi yozuvni yangilasa, tizim eng so'nggi yangilanish barcha serverlarda izchil tarqatilishini ta'minlashi kerak. Har bir yangilanishni vaqt belgisi bilan belgilash uchun Temporal.Instant'dan foydalanish, hatto tarmoq kechikishlari va serverlar o'rtasidagi soatning potensial siljishlari bilan ham, aniq tartibni ta'minlaydi.

4. Moliyaviy operatsiyalar

Moliyaviy operatsiyalar ko'pincha me'yoriy talablarga rioya qilish va aniq hisob-kitob yuritish uchun yuqori aniqlikdagi vaqt belgilarini talab qiladi. Bahslarga yo'l qo'ymaslik va hisobdorlikni ta'minlash uchun savdo, to'lov yoki o'tkazmaning aniq vaqti aniq qayd etilishi kerak.

Masalan, yuqori chastotali savdo tizimlari buyurtma bajarilgan aniq lahzani qayd etish uchun mikrosekund yoki nanosoniya aniqligini talab qiladi. Vaqtdagi hatto kichik nomuvofiqliklar ham jiddiy moliyaviy oqibatlarga olib kelishi mumkin. Temporal.Instant ushbu muhim ilovalar uchun zarur bo'lgan aniqlikni ta'minlaydi.

5. Ilmiy ilovalar

Astronomiya, fizik simulyatsiyalar va tajribalardan olingan ma'lumotlarni qayd etish kabi ko'plab ilmiy ilovalar juda aniq vaqt o'lchovlarini talab qiladi. Bu o'lchovlar ko'pincha ma'lumotlarni tahlil qilish va aniq xulosalar chiqarish uchun juda muhimdir.

Uzoqdagi yulduzdan ma'lumot olayotgan teleskopni tasavvur qiling. Har bir kuzatuvning aniq vaqti yulduzning holatini, harakatini va boshqa xususiyatlarini aniqlash uchun muhimdir. Temporal.Instant olimlarga ushbu vaqt belgilarini kerakli aniqlik bilan qayd etishga imkon beradi.

Internatsionallashtirish va Vaqt zonalari

Garchi Temporal.Instant UTC'dagi vaqt nuqtasini ifodalasa-da, global auditoriya uchun sana va vaqt bilan ishlashda vaqt zonalarini hisobga olish muhimdir. Yuqorida ko'rsatilganidek, bir xil vaqt nuqtasini ma'lum bir vaqt zonasida ifodalash uchun Instant'ni Temporal.ZonedDateTime'ga o'tkazishingiz mumkin.

Foydalanuvchilarga sana va vaqtni ko'rsatishda chalkashliklarga yo'l qo'ymaslik uchun har doim ularning mahalliy vaqt zonasidan foydalaning. Foydalanuvchining vaqt zonasini ularning brauzeri yoki operatsion tizimidan olishingiz mumkin. Masalan, sana va vaqtni foydalanuvchining lokali va vaqt zonasiga muvofiq formatlash uchun Intl.DateTimeFormat API'sidan foydalanishingiz mumkin.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO(Temporal.Now.timeZone());

const formatter = new Intl.DateTimeFormat(undefined, {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  hour: 'numeric',
  minute: 'numeric',
  timeZoneName: 'short',
});

console.log(formatter.format(zonedDateTime)); // Natija: Foydalanuvchining lokali va vaqt zonasiga qarab o'zgaradi

            

              
                Copy
              
            
          

Bu misol foydalanuvchining tizim vaqt zonasidan foydalanadi. Agar kerak bo'lsa, Temporal.Now.timeZone()'ni ma'lum bir vaqt zonasi identifikatori bilan (masalan, 'America/Los_Angeles') almashtirishingiz mumkin.

Eslatma: Vaqt zonalari bilan ishlashda har doim yozgi vaqtga (DST) e'tibor bering. Vaqt zonasi qoidalari o'zgarishi mumkin, shuning uchun aniq hisob-kitoblarni ta'minlash uchun yangilangan vaqt zonasi ma'lumotlar bazasidan foydalanish muhim. Temporal API vaqt zonalari o'rtasida konvertatsiya qilishda DST o'tishlarini avtomatik ravishda boshqaradi.

Brauzer va muhitni qo'llab-quvvatlash

2023-yil oxiriga kelib, Temporal API hali ham nisbatan yangi va barcha brauzerlar va JavaScript muhitlarida to'liq qo'llab-quvvatlanmaydi. Eski brauzerlarni qo'llab-quvvatlash uchun polifildan foydalanishingiz kerak bo'lishi mumkin.

@js-temporal/polyfill paketi Temporal API uchun polifilni taqdim etadi. Uni npm yoki yarn yordamida o'rnatishingiz mumkin:

            
npm install @js-temporal/polyfill

            

              
                Copy
              
            
          

Keyin, JavaScript kodingizga polifilni import qiling:

            
import '@js-temporal/polyfill';

            

              
                Copy
              
            
          

Bu Temporal API'ni global maydonga qo'shadi, bu sizga muhit uni tabiiy ravishda qo'llab-quvvatlamasa ham kodingizda undan foydalanishga imkon beradi.

Eng yaxshi amaliyotlar va mulohazalar

• Ichki saqlash va hisob-kitoblar uchun UTC'dan foydalaning: Vaqt zonasi bilan bog'liq muammolarni oldini olish uchun barcha vaqt belgilarini UTC'da saqlang. Faqat foydalanuvchilarga sana va vaqtni ko'rsatishda mahalliy vaqt zonalariga o'tkazing.
• Vaqt zonasi konvertatsiyalarini ehtiyotkorlik bilan bajaring: DST va vaqt zonasi qoidalarining o'zgarishidan xabardor bo'ling. Aniq konvertatsiyalarni ta'minlash uchun yangilangan vaqt zonasi ma'lumotlar bazasidan foydalaning.
• Nanosoniya qiymatlari uchun BigInt'dan foydalaning: Nanosoniya qiymatlari ko'pincha JavaScript sonlari uchun maksimal xavfsiz butun son qiymatidan oshib ketadi. Aniqlikni saqlash uchun BigInt'dan foydalaning.
• Polifildan foydalanishni o'ylab ko'ring: Agar eski brauzerlar yoki muhitlarni qo'llab-quvvatlashingiz kerak bo'lsa, @js-temporal/polyfill paketidan foydalaning.
• Kodingizni sinchkovlik bilan sinab ko'ring: Barcha foydalanuvchilar uchun to'g'ri ishlashini ta'minlash uchun kodingizni turli vaqt zonalari va lokallar bilan sinab ko'ring.
• Taxminlaringizni hujjatlashtiring: Vaqt zonalari, lokallar yoki sana va vaqt formatlari haqida qilgan har qanday taxminlaringizni aniq hujjatlashtiring.

Xulosa

Temporal.Instant JavaScript'da vaqt nuqtalarini ifodalashning ishonchli va aniq usulini taqdim etadi. Uning o'zgarmasligi, nanosoniya aniqligi va boshqa Temporal turlari bilan integratsiyasi uni turli ilovalarda murakkab vaqt hisob-kitoblarini boshqarish uchun kuchli vositaga aylantiradi. Instant obyektlarini qanday yaratish, boshqarish va taqqoslashni tushunib, internatsionallashtirish va vaqt zonalarini boshqarish bo'yicha eng yaxshi amaliyotlarga rioya qilish orqali siz global auditoriya uchun ishonchli va aniq sana va vaqt funksionalligini yarata olasiz. Instant obyektini o'z ichiga olgan Temporal API'ni o'zlashtirish dasturchilarga eski Date obyektining cheklovlaridan xalos bo'lishga va turli madaniyatlar va mintaqalardagi vaqtning murakkabliklarini aniq aks ettiruvchi yanada mustahkam va qo'llab-quvvatlanadigan ilovalarni yaratishga imkon beradi.

Temporal API kengroq qo'llanila boshlagan sari, u JavaScript'da sana va vaqtni boshqarish standarti bo'lishga tayyor. Uning xususiyatlari va eng yaxshi amaliyotlari bilan tanishgan dasturchilar vaqtga sezgir ilovalarning keyingi avlodini yaratish uchun yaxshi tayyorlangan bo'ladilar.