JavaScript Async Iterator Patterni: Oqimlar Dizayni uchun To'liq Qo'llanma

Zamonaviy JavaScript dasturlashda, ayniqsa ko'p ma'lumot talab qiladigan ilovalar yoki real vaqtdagi ma'lumotlar oqimlari bilan ishlaganda, samarali va asinxron ma'lumotlarni qayta ishlashga ehtiyoj juda muhim. ECMAScript 2018 bilan taqdim etilgan Async Iterator patterni ma'lumotlar oqimlarini asinxron tarzda boshqarish uchun kuchli va nafis yechimni taklif etadi. Ushbu blog posti Async Iterator patternining mohiyatiga chuqur kirib, uning tushunchalari, amalga oshirilishi, qo'llanilish holatlari va turli stsenariylardagi afzalliklarini o'rganadi. Bu global miqyosdagi zamonaviy veb-ilovalar uchun muhim bo'lgan ma'lumotlar oqimlarini samarali va asinxron tarzda boshqarishda inqilobiy yechimdir.

Iteratorlar va Generatorlarni Tushunish

Async Iteratorlarga sho'ng'ishdan oldin, keling, JavaScript'dagi iteratorlar va generatorlarning asosiy tushunchalarini qisqacha takrorlab o'taylik. Ular Async Iteratorlar qurilgan poydevorni tashkil qiladi.

Iteratorlar

Iterator - bu ketma-ketlikni belgilaydigan va tugagach, ehtimol, qaytariladigan qiymatga ega bo'lgan ob'ekt. Aniqroq aytganda, iterator ikki xususiyatga ega ob'ektni qaytaradigan next() usulini amalga oshiradi:

• value: Ketma-ketlikdagi keyingi qiymat.
• done: Iterator ketma-ketlik bo'ylab iteratsiyani yakunlaganligini ko'rsatuvchi mantiqiy (boolean) qiymat. done true bo'lganda, value odatda iteratorning qaytariladigan qiymati bo'ladi (agar mavjud bo'lsa).

Mana sinxron iteratorning oddiy misoli:

            
const myIterator = {
  data: [1, 2, 3],
  index: 0,
  next() {
    if (this.index < this.data.length) {
      return { value: this.data[this.index++], done: false };
    } else {
      return { value: undefined, done: true };
    }
  },
};

console.log(myIterator.next()); // Output: { value: 1, done: false }
console.log(myIterator.next()); // Output: { value: 2, done: false }
console.log(myIterator.next()); // Output: { value: 3, done: false }
console.log(myIterator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

Generatorlar

Generatorlar iteratorlarni aniqlashning yanada ixcham usulini taqdim etadi. Ular to'xtatib turilishi va qayta ishga tushirilishi mumkin bo'lgan funksiyalar bo'lib, yield kalit so'zi yordamida iterativ algoritmni tabiiyroq belgilashga imkon beradi.

Mana yuqoridagi misolning generator funksiyasi yordamida amalga oshirilishi:

            
function* myGenerator(data) {
  for (let i = 0; i < data.length; i++) {
    yield data[i];
  }
}

const iterator = myGenerator([1, 2, 3]);

console.log(iterator.next()); // Output: { value: 1, done: false }
console.log(iterator.next()); // Output: { value: 2, done: false }
console.log(iterator.next()); // Output: { value: 3, done: false }
console.log(iterator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

yield kalit so'zi generator funksiyasini to'xtatib turadi va ko'rsatilgan qiymatni qaytaradi. Generator keyinchalik qolgan joyidan davom ettirilishi mumkin.

Async Iteratorlar bilan Tanishtiruv

Async Iteratorlar iterator tushunchasini asinxron operatsiyalarni boshqarish uchun kengaytiradi. Ular har bir element asinxron tarzda olinadigan yoki qayta ishlanadigan ma'lumotlar oqimlari, masalan, API'dan ma'lumotlarni olish yoki fayldan o'qish kabi holatlar bilan ishlash uchun mo'ljallangan. Bu, ayniqsa, Node.js muhitlarida yoki brauzerda asinxron ma'lumotlar bilan ishlaganda foydalidir. Bu yaxshiroq foydalanuvchi tajribasi uchun javob berish qobiliyatini oshiradi va global miqyosda dolzarbdir.

Async Iterator sinxron iteratorlarga o'xshash value va done xususiyatlariga ega ob'ektga hal bo'ladigan Promise'ni qaytaradigan next() usulini amalga oshiradi. Asosiy farq shundaki, next() usuli endi asinxron operatsiyalarga imkon beruvchi Promise'ni qaytaradi.

Async Iteratorni Aniqlash

Mana oddiy Async Iterator misoli:

            
const myAsyncIterator = {
  data: [1, 2, 3],
  index: 0,
  async next() {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate async operation
    if (this.index < this.data.length) {
      return { value: this.data[this.index++], done: false };
    } else {
      return { value: undefined, done: true };
    }
  },
};

async function consumeIterator() {
  console.log(await myAsyncIterator.next()); // Output: { value: 1, done: false }
  console.log(await myAsyncIterator.next()); // Output: { value: 2, done: false }
  console.log(await myAsyncIterator.next()); // Output: { value: 3, done: false }
  console.log(await myAsyncIterator.next()); // Output: { value: undefined, done: true }
}

consumeIterator();

            

              
                Copy
              
            
          

Ushbu misolda, next() usuli setTimeout yordamida asinxron operatsiyani simulyatsiya qiladi. Keyin consumeIterator funksiyasi natijani log qilishdan oldin next() tomonidan qaytarilgan Promise'ning hal bo'lishini kutish uchun await dan foydalanadi.

Async Generatorlar

Sinxron generatorlarga o'xshab, Async Generatorlar ham Async Iteratorlarni yaratishning qulayroq usulini taqdim etadi. Ular to'xtatib turilishi va qayta ishga tushirilishi mumkin bo'lgan funksiyalar bo'lib, yield kalit so'zidan Promise'larni qaytarish uchun foydalanadi.

Async Generatorni aniqlash uchun async function* sintaksisidan foydalaning. Generator ichida siz asinxron operatsiyalarni bajarish uchun await kalit so'zidan foydalanishingiz mumkin.

Mana yuqoridagi misolning Async Generator yordamida amalga oshirilishi:

            
async function* myAsyncGenerator(data) {
  for (let i = 0; i < data.length; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate async operation
    yield data[i];
  }
}

async function consumeGenerator() {
  const iterator = myAsyncGenerator([1, 2, 3]);

  console.log(await iterator.next()); // Output: { value: 1, done: false }
  console.log(await iterator.next()); // Output: { value: 2, done: false }
  console.log(await iterator.next()); // Output: { value: 3, done: false }
  console.log(await iterator.next()); // Output: { value: undefined, done: true }
}

consumeGenerator();

            

              
                Copy
              
            
          

for await...of yordamida Async Iteratorlarni Iste'mol Qilish

for await...of tsikli Async Iteratorlarni iste'mol qilish uchun toza va o'qilishi oson sintaksisni taqdim etadi. U avtomatik ravishda iterator tomonidan berilgan qiymatlar bo'ylab iteratsiya qiladi va tsikl tanasini bajarishdan oldin har bir Promise'ning hal bo'lishini kutadi. Bu asinxron kodni soddalashtiradi, uni o'qish va qo'llab-quvvatlashni osonlashtiradi. Bu xususiyat global miqyosda toza, o'qilishi osonroq asinxron ish jarayonlarini rag'batlantiradi.

Mana oldingi misoldagi Async Generator bilan for await...of dan foydalanish misoli:

            
async function* myAsyncGenerator(data) {
  for (let i = 0; i < data.length; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate async operation
    yield data[i];
  }
}

async function consumeGenerator() {
  for await (const value of myAsyncGenerator([1, 2, 3])) {
    console.log(value); // Output: 1, 2, 3 (har biri orasida 500ms kechikish bilan)
  }
}

consumeGenerator();

            

              
                Copy
              
            
          

for await...of tsikli asinxron iteratsiya jarayonini ancha sodda va tushunarli qiladi.

Async Iteratorlar uchun Qo'llanilish Holatlari

Async Iteratorlar juda ko'p qirrali bo'lib, asinxron ma'lumotlarni qayta ishlash talab qilinadigan turli stsenariylarda qo'llanilishi mumkin. Mana bir nechta umumiy qo'llanilish holatlari:

1. Katta Fayllarni O'qish

Katta fayllar bilan ishlaganda, butun faylni bir vaqtning o'zida xotiraga o'qish samarasiz va resurs talab qiladigan bo'lishi mumkin. Async Iteratorlar faylni asinxron ravishda qismlarga bo'lib o'qish usulini taqdim etadi, har bir qismni mavjud bo'lishi bilan qayta ishlaydi. Bu, ayniqsa, server tomonidagi ilovalar va Node.js muhitlari uchun juda muhimdir.

            
const fs = require('fs');
const readline = require('readline');

async function* readLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function processFile(filePath) {
  for await (const line of readLines(filePath)) {
    console.log(`Line: ${line}`);
    // Har bir qatorni asinxron qayta ishlash
  }
}

// Misol tariqasida foydalanish
// processFile('path/to/large/file.txt');

            

              
                Copy
              
            
          

Ushbu misolda, readLines funksiyasi faylni asinxron ravishda qatorma-qator o'qiydi va har bir qatorni chaqiruvchiga uzatadi. Keyin processFile funksiyasi qatorlarni iste'mol qiladi va ularni asinxron ravishda qayta ishlaydi.

2. API'lardan Ma'lumotlarni Olish

API'lardan ma'lumotlarni olayotganda, ayniqsa paginatsiya yoki katta ma'lumotlar to'plamlari bilan ishlaganda, Async Iteratorlardan ma'lumotlarni qismlarga bo'lib olish va qayta ishlash uchun foydalanish mumkin. Bu butun ma'lumotlar to'plamini bir vaqtning o'zida xotiraga yuklashdan saqlanishga va uni bosqichma-bosqich qayta ishlashga imkon beradi. Bu katta ma'lumotlar to'plamlari bilan ham javob berish qobiliyatini ta'minlaydi, turli internet tezligi va mintaqalardagi foydalanuvchi tajribasini yaxshilaydi.

            
async function* fetchPaginatedData(url) {
  let nextUrl = url;

  while (nextUrl) {
    const response = await fetch(nextUrl);
    const data = await response.json();

    for (const item of data.results) {
      yield item;
    }

    nextUrl = data.next;
  }
}

async function processData() {
  for await (const item of fetchPaginatedData('https://api.example.com/data')) {
    console.log(item);
    // Har bir elementni asinxron qayta ishlash
  }
}

// Misol tariqasida foydalanish
// processData();

            

              
                Copy
              
            
          

Ushbu misolda, fetchPaginatedData funksiyasi paginatsiyalangan API nuqtasidan ma'lumotlarni oladi va har bir elementni chaqiruvchiga uzatadi. Keyin processData funksiyasi elementlarni iste'mol qiladi va ularni asinxron ravishda qayta ishlaydi.

3. Real Vaqtdagi Ma'lumotlar Oqimlarini Boshqarish

Async Iteratorlar shuningdek, WebSockets yoki server tomonidan yuborilgan hodisalar kabi real vaqtdagi ma'lumotlar oqimlarini boshqarish uchun ham juda mos keladi. Ular kiruvchi ma'lumotlarni kelishi bilan, asosiy ish oqimini bloklamasdan qayta ishlashga imkon beradi. Bu javob beruvchi va kengaytiriladigan real vaqtdagi ilovalarni yaratish uchun juda muhim bo'lib, soniya sayin yangilanishlarni talab qiladigan xizmatlar uchun hayotiy ahamiyatga ega.

            
async function* processWebSocketStream(socket) {
  while (true) {
    const message = await new Promise((resolve, reject) => {
      socket.onmessage = (event) => {
        resolve(event.data);
      };
      socket.onerror = (error) => {
        reject(error);
      };
    });

    yield message;
  }
}

async function consumeWebSocketStream(socket) {
  for await (const message of processWebSocketStream(socket)) {
    console.log(`Received message: ${message}`);
    // Har bir xabarni asinxron qayta ishlash
  }
}

// Misol tariqasida foydalanish
// const socket = new WebSocket('ws://example.com/socket');
// consumeWebSocketStream(socket);

            

              
                Copy
              
            
          

Ushbu misolda, processWebSocketStream funksiyasi WebSocket ulanishidan xabarlarni tinglaydi va har bir xabarni chaqiruvchiga uzatadi. Keyin consumeWebSocketStream funksiyasi xabarlarni iste'mol qiladi va ularni asinxron ravishda qayta ishlaydi.

4. Hodisalarga Asoslangan Arxitekturalar

Async Iteratorlar hodisalarni asinxron tarzda qayta ishlash uchun hodisalarga asoslangan arxitekturalarga integratsiya qilinishi mumkin. Bu sizga hodisalarga real vaqtda, asosiy ish oqimini bloklamasdan javob beradigan tizimlarni yaratishga imkon beradi. Hodisalarga asoslangan arxitekturalar foydalanuvchi harakatlari yoki tizim hodisalariga tezkor javob berishi kerak bo'lgan zamonaviy, kengaytiriladigan ilovalar uchun juda muhimdir.

            
const EventEmitter = require('events');

async function* eventStream(emitter, eventName) {
  while (true) {
    const value = await new Promise(resolve => {
      emitter.once(eventName, resolve);
    });
    yield value;
  }
}

async function consumeEventStream(emitter, eventName) {
  for await (const event of eventStream(emitter, eventName)) {
    console.log(`Received event: ${event}`);
    // Har bir hodisani asinxron qayta ishlash
  }
}

// Misol tariqasida foydalanish
// const myEmitter = new EventEmitter();
// consumeEventStream(myEmitter, 'data');

// myEmitter.emit('data', 'Event data 1');
// myEmitter.emit('data', 'Event data 2');

            

              
                Copy
              
            
          

Ushbu misol EventEmitter tomonidan chiqarilgan hodisalarni tinglaydigan asinxron iterator yaratadi. Har bir hodisa iste'molchiga uzatiladi, bu esa hodisalarni asinxron qayta ishlashga imkon beradi. Hodisalarga asoslangan arxitekturalar bilan integratsiya qilish modulli va reaktiv tizimlarni yaratishga imkon beradi.

Async Iteratorlardan Foydalanishning Afzalliklari

Async Iteratorlar an'anaviy asinxron dasturlash usullariga nisbatan bir qancha afzalliklarni taklif etadi, bu ularni zamonaviy JavaScript dasturlash uchun qimmatli vositaga aylantiradi. Bu afzalliklar yanada samarali, javob beruvchi va kengaytiriladigan ilovalarni yaratishga bevosita hissa qo'shadi.

1. Yaxshilangan Ishlash Samaradorligi

Ma'lumotlarni asinxron ravishda qismlarga bo'lib qayta ishlash orqali, Async Iteratorlar ko'p ma'lumot talab qiladigan ilovalarning ishlash samaradorligini oshirishi mumkin. Ular butun ma'lumotlar to'plamini bir vaqtning o'zida xotiraga yuklashdan saqlanadi, bu esa xotira sarfini kamaytiradi va javob berish qobiliyatini yaxshilaydi. Bu, ayniqsa, katta ma'lumotlar to'plamlari yoki real vaqtdagi ma'lumotlar oqimlari bilan ishlaydigan ilovalar uchun juda muhim bo'lib, ularning yuklama ostida ham samarali ishlashini ta'minlaydi.

2. Oshirilgan Javob Berish Qobiliyati

Async Iteratorlar ma'lumotlarni asosiy ish oqimini bloklamasdan qayta ishlashga imkon beradi, bu esa ilovangizning foydalanuvchi o'zaro ta'sirlariga javob beruvchi bo'lib qolishini ta'minlaydi. Bu, ayniqsa, javob beruvchi foydalanuvchi interfeysi yaxshi foydalanuvchi tajribasi uchun hal qiluvchi ahamiyatga ega bo'lgan veb-ilovalar uchun muhimdir. Turli internet tezligiga ega global foydalanuvchilar ilovaning javob berish qobiliyatini qadrlashadi.

3. Soddalashtirilgan Asinxron Kod

Async Iteratorlar, for await...of tsikli bilan birgalikda, asinxron ma'lumotlar oqimlari bilan ishlash uchun toza va o'qilishi oson sintaksisni taqdim etadi. Bu asinxron kodni tushunish va qo'llab-quvvatlashni osonlashtiradi, xatoliklar ehtimolini kamaytiradi. Soddalashtirilgan sintaksis dasturchilarga asinxron dasturlashning murakkabliklaridan ko'ra o'z ilovalarining mantig'iga e'tibor qaratishga imkon beradi.

4. Backpressure'ni Boshqarish

Async Iteratorlar ma'lumotlarning ishlab chiqarilish va iste'mol qilinish tezligini nazorat qilish qobiliyati bo'lgan backpressure'ni tabiiy ravishda qo'llab-quvvatlaydi. Bu ilovangizning ma'lumotlar oqimi bilan to'lib ketishini oldini olish uchun muhimdir. Iste'molchilarga ko'proq ma'lumot uchun tayyor bo'lganlarida ishlab chiqaruvchilarga signal berishga imkon berish orqali, Async Iteratorlar ilovangizning yuqori yuklama ostida barqaror va samarali bo'lib qolishini ta'minlashga yordam beradi. Backpressure, ayniqsa, real vaqtdagi ma'lumotlar oqimlari yoki yuqori hajmli ma'lumotlarni qayta ishlash bilan shug'ullanayotganda, tizim barqarorligini ta'minlash uchun muhimdir.

Async Iteratorlardan Foydalanish bo'yicha Eng Yaxshi Amaliyotlar

Async Iteratorlardan maksimal darajada foydalanish uchun ba'zi eng yaxshi amaliyotlarga rioya qilish muhimdir. Ushbu ko'rsatmalar kodingizning samarali, qo'llab-quvvatlanadigan va mustahkam bo'lishini ta'minlashga yordam beradi.

1. Xatoliklarni To'g'ri Boshqarish

Asinxron operatsiyalar bilan ishlaganda, ilovangizning ishdan chiqishini oldini olish uchun xatoliklarni to'g'ri boshqarish muhimdir. Asinxron iteratsiya paytida yuzaga kelishi mumkin bo'lgan har qanday xatoliklarni ushlash uchun try...catch bloklaridan foydalaning. Xatoliklarni to'g'ri boshqarish ilovangizning kutilmagan muammolarga duch kelganda ham barqaror bo'lib qolishini ta'minlaydi, bu esa yanada mustahkam foydalanuvchi tajribasiga hissa qo'shadi.

            
async function consumeGenerator() {
  try {
    for await (const value of myAsyncGenerator([1, 2, 3])) {
      console.log(value);
    }
  } catch (error) {
    console.error(`An error occurred: ${error}`);
    // Xatolikni boshqarish
  }
}

            

              
                Copy
              
            
          

2. Bloklovchi Operatsiyalardan Saqlaning

Asinxron operatsiyalaringiz haqiqatan ham bloklanmasligiga ishonch hosil qiling. Async Iteratorlaringiz ichida uzoq davom etadigan sinxron operatsiyalarni bajarishdan saqlaning, chunki bu asinxron qayta ishlashning afzalliklarini yo'qqa chiqarishi mumkin. Bloklanmaydigan operatsiyalar asosiy ish oqimining javob beruvchi bo'lib qolishini ta'minlaydi, bu esa, ayniqsa, veb-ilovalarda yaxshiroq foydalanuvchi tajribasini taqdim etadi.

3. Parallelizmni Cheklash

Bir nechta Async Iteratorlar bilan ishlaganda, bir vaqtda bajariladigan operatsiyalar soniga e'tibor bering. Parallelizmni cheklash ilovangizning bir vaqtning o'zida juda ko'p vazifalar bilan to'lib ketishini oldini oladi. Bu, ayniqsa, resurs talab qiladigan operatsiyalar bilan ishlaganda yoki cheklangan resurslarga ega muhitlarda ishlaganda muhimdir. Bu xotiraning tugashi va ishlash samaradorligining pasayishi kabi muammolarni oldini olishga yordam beradi.

4. Resurslarni Tozalash

Async Iterator bilan ishingiz tugagach, u foydalanayotgan har qanday resurslarni, masalan, fayl descriptorlari yoki tarmoq ulanishlarini tozalashga ishonch hosil qiling. Bu resurslarning oqib ketishini oldini olishga va ilovangizning umumiy barqarorligini oshirishga yordam beradi. Resurslarni to'g'ri boshqarish uzoq vaqt ishlaydigan ilovalar yoki xizmatlar uchun juda muhim bo'lib, ularning vaqt o'tishi bilan barqaror bo'lib qolishini ta'minlaydi.

5. Murakkab Mantiq uchun Async Generatorlardan Foydalaning

Murakkabroq iterativ mantiq uchun, Async Generatorlar Async Iteratorlarni aniqlashning toza va qo'llab-quvvatlanadigan usulini taqdim etadi. Ular generator funksiyasini to'xtatib turish va qayta ishga tushirish uchun yield kalit so'zidan foydalanishga imkon beradi, bu esa nazorat oqimi haqida mulohaza yuritishni osonlashtiradi. Async Generatorlar, ayniqsa, iterativ mantiq bir nechta asinxron qadamlar yoki shartli tarmoqlarni o'z ichiga olganda foydalidir.

Async Iteratorlar va Observables'larni Taqqoslash

Async Iteratorlar va Observables'lar ikkalasi ham asinxron ma'lumotlar oqimlarini boshqarish uchun patternlardir, lekin ular turli xususiyatlarga va qo'llanilish holatlariga ega.

Async Iteratorlar

• Tortishga asoslangan (Pull-based): Iste'molchi iteratordan keyingi qiymatni aniq so'raydi.
• Yagona obuna: Har bir iterator faqat bir marta iste'mol qilinishi mumkin.
• JavaScript'da o'rnatilgan qo'llab-quvvatlash: Async Iteratorlar va for await...of til spetsifikatsiyasining bir qismidir.

Observables

• Itarishga asoslangan (Push-based): Ishlab chiqaruvchi qiymatlarni iste'molchiga itaradi.
• Ko'p obunalar: Bir Observable'ga bir nechta iste'molchi obuna bo'lishi mumkin.
• Kutubxona talab qiladi: Observables odatda RxJS kabi kutubxona yordamida amalga oshiriladi.

Async Iteratorlar iste'molchi ma'lumotlarni qayta ishlash tezligini nazorat qilishi kerak bo'lgan stsenariylar uchun, masalan, katta fayllarni o'qish yoki paginatsiyalangan API'lardan ma'lumotlarni olish kabi holatlar uchun juda mos keladi. Observables ishlab chiqaruvchi ma'lumotlarni bir nechta iste'molchiga itarishi kerak bo'lgan stsenariylar uchun, masalan, real vaqtdagi ma'lumotlar oqimlari yoki hodisalarga asoslangan arxitekturalar uchun yaxshiroqdir. Async Iteratorlar va Observables'lar o'rtasida tanlov qilish ilovangizning o'ziga xos ehtiyojlari va talablariga bog'liq.

Xulosa

JavaScript Async Iterator patterni asinxron ma'lumotlar oqimlarini boshqarish uchun kuchli va nafis yechimni taqdim etadi. Ma'lumotlarni asinxron ravishda qismlarga bo'lib qayta ishlash orqali, Async Iteratorlar ilovalaringizning ishlash samaradorligi va javob berish qobiliyatini oshirishi mumkin. for await...of tsikli va Async Generatorlar bilan birgalikda, ular asinxron ma'lumotlar bilan ishlash uchun toza va o'qilishi oson sintaksisni taqdim etadi. Ushbu blog postida bayon qilingan eng yaxshi amaliyotlarga rioya qilish orqali siz samarali, qo'llab-quvvatlanadigan va mustahkam ilovalarni yaratish uchun Async Iteratorlarning to'liq salohiyatidan foydalanishingiz mumkin.

Katta fayllar bilan ishlaysizmi, API'lardan ma'lumotlar olasizmi, real vaqtdagi ma'lumotlar oqimlarini boshqarasizmi yoki hodisalarga asoslangan arxitekturalarni qurasizmi, Async Iteratorlar sizga yaxshiroq asinxron kod yozishga yordam beradi. JavaScript dasturlash ko'nikmalaringizni oshirish va global auditoriya uchun yanada samarali va javob beruvchi ilovalarni yaratish uchun ushbu patternni o'zlashtiring.