JavaScript Generatorlari: Iterator Protokoli va Asinxron Iteratsiyani O'zlashtirish

JavaScript Generatorlari iteratsiyani boshqarish va asinxron operatsiyalarni boshqarish uchun kuchli mexanizmni taqdim etadi. Ular Iterator Protokoli asosida qurilgan va uni asinxron ma'lumotlar oqimlarini uzluksiz boshqarish uchun kengaytiradi. Ushbu qo'llanma JavaScript Generatorlarining to'liq tahlilini, ularning asosiy tushunchalari, ilg'or xususiyatlari va zamonaviy JavaScript dasturlashdagi amaliy qo'llanilishini o'z ichiga oladi.

Iterator Protokolini Tushunish

Iterator Protokoli JavaScriptda obyektlarning qanday qilib iteratsiya qilinishini belgilaydigan asosiy tushunchadir. U ikkita asosiy elementni o'z ichiga oladi:

• Iterable (Iteratsiyalanuvchi): Iteratorni qaytaradigan usulga (Symbol.iterator) ega bo'lgan obyekt.
• Iterator: next() usulini belgilaydigan obyekt. next() usuli ikkita xususiyatga ega obyektni qaytaradi: value (ketma-ketlikdagi keyingi qiymat) va done (iteratsiyaning tugaganligini ko'rsatuvchi mantiqiy qiymat).

Buni oddiy misol bilan ko'rib chiqamiz:

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

for (const value of myIterable) {
  console.log(value); // Output: 1, 2, 3
}

            

              
                Copy
              
            
          

Ushbu misolda, myIterable iteratsiyalanuvchi obyekt hisoblanadi, chunki u Symbol.iterator usuliga ega. Symbol.iterator usuli 1, 2 va 3 qiymatlarini birma-bir ishlab chiqaradigan next() usuliga ega iterator obyektini qaytaradi. Iteratsiya uchun boshqa qiymatlar qolmaganda, done xususiyati true ga aylanadi.

JavaScript Generatorlari bilan Tanishtiruv

Generatorlar JavaScriptda to'xtatib turilishi va qayta davom ettirilishi mumkin bo'lgan maxsus turdagi funksiyalardir. Ular bir necha chaqiruvlar davomida o'z holatini saqlaydigan funksiya yozish orqali iterativ algoritmni aniqlashga imkon beradi. Generatorlar function* sintaksisi va yield kalit so'zidan foydalanadi.

Mana oddiy generator misoli:

            
function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

const generator = numberGenerator();

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

            

              
                Copy
              
            
          

Siz numberGenerator() ni chaqirganingizda, u funksiya tanasini darhol bajarmaydi. Buning o'rniga, u generator obyektini qaytaradi. generator.next() ga har bir murojaat funksiyani yield kalit so'ziga duch kelguncha bajaradi. yield kalit so'zi funksiyani to'xtatib turadi va berilgan qiymat bilan obyektni qaytaradi. next() yana chaqirilganda, funksiya to'xtagan joyidan davom etadi.

Generator Funksiyalari va Oddiy Funksiyalar

Generator funksiyalari va oddiy funksiyalar o'rtasidagi asosiy farqlar:

• Generator funksiyalari function o'rniga function* yordamida aniqlanadi.
• Generator funksiyalari bajarilishni to'xtatib turish va qiymat qaytarish uchun yield kalit so'zidan foydalanadi.
• Generator funksiyasini chaqirish funksiya natijasini emas, balki generator obyektini qaytaradi.

Iterator Protokoli bilan Generatorlardan Foydalanish

Generatorlar avtomatik ravishda Iterator Protokoliga mos keladi. Bu shuni anglatadiki, siz ularni to'g'ridan-to'g'ri for...of sikllarida va boshqa iteratorni ishlatadigan funksiyalarda qo'llashingiz mumkin.

            
function* fibonacciGenerator() {
  let a = 0, b = 1;
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

const fibonacci = fibonacciGenerator();

for (let i = 0; i < 10; i++) {
  console.log(fibonacci.next().value); // Output: The first 10 Fibonacci numbers
}

            

              
                Copy
              
            
          

Ushbu misolda fibonacciGenerator() Fibonachchi ketma-ketligini beradigan cheksiz generatordir. Biz generator nusxasini yaratamiz va keyin birinchi 10 ta sonni chop etish uchun uning ustida iteratsiya qilamiz. E'tibor bering, iteratsiyani cheklamasa, bu generator abadiy ishlaydi.

Generatorlarga Qiymat Uzatish

Shuningdek, next() usuli yordamida generatorga qiymatlarni qayta uzatishingiz mumkin. next() ga uzatilgan qiymat yield ifodasining natijasiga aylanadi.

            
function* echoGenerator() {
  const input = yield;
  console.log(`You entered: ${input}`);
}

const echo = echoGenerator();

echo.next(); // Start the generator
echo.next("Hello, World!"); // Output: You entered: Hello, World!

            

              
                Copy
              
            
          

Bu holatda, birinchi next() chaqiruvi generatorni ishga tushiradi. Ikkinchi next("Hello, World!") chaqiruvi "Hello, World!" satrini generatorga uzatadi, keyin u input o'zgaruvchisiga biriktiriladi.

Generatorlarning Ilg'or Xususiyatlari

yield*: Boshqa Iteratsiyalanuvchiga Delegatsiya Qilish

yield* kalit so'zi iteratsiyani boshqa iteratsiyalanuvchi obyektga, shu jumladan boshqa generatorlarga delegatsiya qilishga imkon beradi.

            
function* subGenerator() {
  yield 4;
  yield 5;
  yield 6;
}

function* mainGenerator() {
  yield 1;
  yield 2;
  yield 3;
  yield* subGenerator();
  yield 7;
  yield 8;
}

const main = mainGenerator();

for (const value of main) {
  console.log(value); // Output: 1, 2, 3, 4, 5, 6, 7, 8
}

            

              
                Copy
              
            
          

yield* subGenerator() qatori subGenerator() tomonidan berilgan qiymatlarni mainGenerator() ketma-ketligiga samarali tarzda kiritadi.

return() va throw() Usullari

Generator obyektlari, shuningdek, generatorni muddatidan oldin to'xtatish yoki unga xatolik yuborish imkonini beruvchi return() va throw() usullariga ega.

            
function* exampleGenerator() {
  try {
    yield 1;
    yield 2;
    yield 3;
  } finally {
    console.log("Cleaning up...");
  }
}

const gen = exampleGenerator();

console.log(gen.next()); // Output: { value: 1, done: false }
console.log(gen.return("Finished")); // Output: Cleaning up...
// Output: { value: 'Finished', done: true }
console.log(gen.next()); // Output: { value: undefined, done: true }


function* errorGenerator() {
  try {
    yield 1;
    yield 2;
  } catch (e) {
    console.error("Error caught:", e);
  }
  yield 3;
}

const errGen = errorGenerator();

console.log(errGen.next()); // Output: { value: 1, done: false }
console.log(errGen.throw(new Error("Something went wrong!"))); // Output: Error caught: Error: Something went wrong!
// Output: { value: 3, done: false }
console.log(errGen.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

return() usuli finally blokini (agar mavjud bo'lsa) bajaradi va done xususiyatini true qilib belgilaydi. throw() usuli generator ichida xatolik yuboradi, uni try...catch bloki yordamida ushlab olish mumkin.

Asinxron Iteratsiya va Asinxron Generatorlar

Asinxron Iteratsiya asinxron ma'lumotlar oqimlarini boshqarish uchun Iterator Protokolini kengaytiradi. U ikkita yangi tushunchani kiritadi:

• Async Iterable (Asinxron Iteratsiyalanuvchi): Asinxron iteratorni qaytaradigan usulga (Symbol.asyncIterator) ega bo'lgan obyekt.
• Async Iterator (Asinxron Iterator): Promise qaytaradigan next() usulini belgilaydigan obyekt. Promise ikkita xususiyatga ega obyekt bilan yechiladi: value (ketma-ketlikdagi keyingi qiymat) va done (iteratsiyaning tugaganligini ko'rsatuvchi mantiqiy qiymat).

Asinxron Generatorlar asinxron iteratorlarni yaratishning qulay usulini taqdim etadi. Ular async function* sintaksisi va await kalit so'zidan foydalanadi.

            
async function* asyncNumberGenerator() {
  await delay(1000); // Simulate an asynchronous operation
  yield 1;
  await delay(1000);
  yield 2;
  await delay(1000);
  yield 3;
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function main() {
  const asyncGenerator = asyncNumberGenerator();

  for await (const value of asyncGenerator) {
    console.log(value); // Output: 1, 2, 3 (with 1 second delay between each)
  }
}

main();

            

              
                Copy
              
            
          

Ushbu misolda, asyncNumberGenerator() har biri o'rtasida 1 soniyalik kechikish bilan sonlarni beradigan asinxron generatordir. for await...of tsikli asinxron generator bo'yicha iteratsiya qilish uchun ishlatiladi. await kalit so'zi har bir qiymatning asinxron tarzda qayta ishlanishini ta'minlaydi.

Asinxron Iteratsiyalanuvchini Qo'lda Yaratish

Asinxron generatorlar odatda asinxron iteratsiyalanuvchilarni yaratishning eng oson usuli bo'lsa-da, siz ularni Symbol.asyncIterator yordamida qo'lda ham yaratishingiz mumkin.

            
const myAsyncIterable = {
  data: [1, 2, 3],
  [Symbol.asyncIterator]() {
    let index = 0;
    return {
      next: async () => {
        await delay(500);
        if (index < this.data.length) {
          return { value: this.data[index++], done: false };
        } else {
          return { value: undefined, done: true };
        }
      }
    };
  }
};

async function main2() {
  for await (const value of myAsyncIterable) {
    console.log(value); // Output: 1, 2, 3 (with 0.5 second delay between each)
  }
}

main2();

            

              
                Copy
              
            
          

Generatorlar va Asinxron Generatorlar uchun Qo'llanilish Holatlari

Generatorlar va asinxron generatorlar turli xil stsenariylarda foydalidir, jumladan:

• Kechiktirilgan Baholash (Lazy Evaluation): Qiymatlarni talab bo'yicha yaratish, bu ayniqsa katta ma'lumotlar to'plamlari bilan ishlaganda samaradorlikni oshirishi va xotira sarfini kamaytirishi mumkin. Masalan, butun faylni xotiraga yuklamasdan katta CSV faylini qatorma-qator qayta ishlash.
• Holatni Boshqarish: Bir nechta funksiya chaqiruvlari davomida holatni saqlab qolish, bu murakkab algoritmlarni soddalashtirishi mumkin. Masalan, turli holatlar va o'tishlarga ega o'yinni amalga oshirish.
• Asinxron Ma'lumotlar Oqimlari: Serverdan keladigan ma'lumotlar yoki foydalanuvchi kiritishi kabi asinxron ma'lumotlar oqimlarini boshqarish. Masalan, ma'lumotlar bazasidan yoki real vaqt rejimida ishlaydigan API'dan ma'lumotlarni oqim bilan uzatish.
• Boshqaruv Oqimi: Maxsus boshqaruv oqimi mexanizmlarini, masalan, korutinlarni (coroutines) amalga oshirish.
• Testlash: Modul testlarida (unit tests) murakkab asinxron stsenariylarni simulyatsiya qilish.

Turli Mintaqalardagi Misollar

Keling, generatorlar va asinxron generatorlar turli mintaqalar va kontekstlarda qanday qo'llanilishi mumkinligiga oid ba'zi misollarni ko'rib chiqaylik:

• Elektron Tijorat (Global): Asinxron generator yordamida ma'lumotlar bazasidan natijalarni qismlarga bo'lib oladigan mahsulot qidiruvini amalga oshirish. Bu foydalanuvchi interfeysini natijalar mavjud bo'lganda bosqichma-bosqich yangilashga imkon beradi, bu esa foydalanuvchining joylashuvi yoki tarmoq tezligidan qat'i nazar, foydalanuvchi tajribasini yaxshilaydi.
• Moliyaviy Ilovalar (Yevropa): Hisob-kitoblarni amalga oshirish va hisobotlarni samarali yaratish uchun generatorlardan foydalanib, katta moliyaviy ma'lumotlar to'plamlarini (masalan, fond bozori ma'lumotlari) qayta ishlash. Bu tartibga soluvchi talablarga muvofiqlik va risklarni boshqarish uchun juda muhimdir.
• Logistika (Osiyo): Yuklarni kuzatib borish va yetkazib berish marshrutlarini optimallashtirish uchun asinxron generatorlar yordamida GPS qurilmalaridan real vaqt rejimida joylashuv ma'lumotlarini oqim bilan uzatish. Bu murakkab logistika muammolari bo'lgan mintaqada samaradorlikni oshirishga va xarajatlarni kamaytirishga yordam beradi.
• Ta'lim (Afrika): Asinxron generatorlar yordamida kontentni dinamik ravishda yuklaydigan interaktiv o'quv modullarini ishlab chiqish. Bu shaxsiylashtirilgan o'quv tajribasini ta'minlaydi va cheklangan tarmoq o'tkazuvchanligiga ega hududlardagi talabalarning ta'lim resurslariga kirishini ta'minlaydi.
• Sog'liqni Saqlash (Amerika): Hayotiy ko'rsatkichlarni kuzatish va anomaliyalarni real vaqt rejimida aniqlash uchun asinxron generatorlar yordamida tibbiy sensorlardan bemor ma'lumotlarini qayta ishlash. Bu bemorlarga yordam ko'rsatish sifatini yaxshilashga va tibbiy xatolar xavfini kamaytirishga yordam beradi.

Generatorlardan Foydalanish bo'yicha Eng Yaxshi Amaliyotlar

• Iterativ Algoritmlar uchun Generatorlardan Foydalaning: Generatorlar iteratsiya va holatni boshqarishni o'z ichiga olgan algoritmlar uchun juda mos keladi.
• Asinxron Ma'lumotlar Oqimlari uchun Asinxron Generatorlardan Foydalaning: Asinxron generatorlar asinxron ma'lumotlar oqimlarini boshqarish va asinxron operatsiyalarni bajarish uchun idealdir.
• Xatoliklarni To'g'ri Boshqaring: Generatorlar va asinxron generatorlar ichidagi xatoliklarni boshqarish uchun try...catch bloklaridan foydalaning.
• Kerak bo'lganda Generatorlarni To'xtating: Kerak bo'lganda generatorlarni muddatidan oldin to'xtatish uchun return() usulidan foydalaning.
• Samaradorlik Oqibatlarini Hisobga Oling: Generatorlar ba'zi hollarda samaradorlikni oshirishi mumkin bo'lsa-da, ular qo'shimcha yuklamalarni ham keltirib chiqarishi mumkin. Generatorlar sizning maxsus holatingiz uchun to'g'ri tanlov ekanligiga ishonch hosil qilish uchun kodingizni sinchkovlik bilan sinab ko'ring.

Xulosa

JavaScript Generatorlari va Asinxron Generatorlar zamonaviy JavaScript ilovalarini yaratish uchun kuchli vositalardir. Iterator Protokolini tushunish va yield hamda await kalit so'zlarini o'zlashtirish orqali siz yanada samarali, qo'llab-quvvatlanadigan va kengaytiriladigan kod yozishingiz mumkin. Katta ma'lumotlar to'plamlarini qayta ishlaysizmi, asinxron operatsiyalarni boshqarasizmi yoki murakkab algoritmlarni amalga oshirasizmi, generatorlar sizga keng ko'lamli dasturlash muammolarini hal qilishda yordam beradi.

Ushbu keng qamrovli qo'llanma sizga generatorlardan samarali foydalanishni boshlash uchun kerakli bilim va misollarni taqdim etdi. Misollar bilan tajriba qiling, turli xil qo'llanilish holatlarini o'rganing va o'z loyihalaringizda JavaScript Generatorlarining to'liq salohiyatini oching.