JavaScript Generator Funksiyalarining Kompozitsiyasi: Generator Zanjirlarini Yaratish

JavaScript generator funksiyalari takrorlanuvchi ketma-ketliklarni yaratishning kuchli usulini taqdim etadi. Ular bajarilishni to'xtatib, qiymatlarni qaytaradi (yield), bu esa ma'lumotlarni samarali va moslashuvchan qayta ishlash imkonini beradi. Generatorlarning eng qiziqarli imkoniyatlaridan biri ularni bir-biriga birlashtirib, murakkab ma'lumotlar konveyerlarini yaratish qobiliyatidir. Ushbu maqolada generator funksiyalari kompozitsiyasi tushunchasi chuqur o'rganiladi va murakkab muammolarni hal qilish uchun generator zanjirlarini yaratishning turli usullari ko'rib chiqiladi.

JavaScript Generator Funksiyalari nima?

Kompozitsiyaga sho'ng'ishdan oldin, keling, generator funksiyalarini qisqacha ko'rib chiqaylik. Generator funksiyasi function* sintaksisi yordamida aniqlanadi. Generator funksiyasi ichida yield kalit so'zi bajarilishni to'xtatib, qiymatni qaytarish uchun ishlatiladi. Generatorning next() metodi chaqirilganda, bajarilish qayerda to'xtagan bo'lsa, o'sha yerdan keyingi yield ifodasi yoki funksiya oxirigacha davom etadi.

Mana oddiy misol:

            
function* numberGenerator(max) {
  for (let i = 0; i <= max; i++) {
    yield i;
  }
}

const generator = numberGenerator(5);

console.log(generator.next()); // Output: { value: 0, done: false }
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: 4, done: false }
console.log(generator.next()); // Output: { value: 5, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

Ushbu generator funksiyasi 0 dan belgilangan maksimal qiymatgacha bo'lgan raqamlarni qaytaradi. next() metodi ikkita xususiyatga ega obyektni qaytaradi: value (qaytarilgan qiymat) va done (generator tugaganligini bildiruvchi mantiqiy qiymat).

Nima uchun Generator Funksiyalarini Kompozitsiya qilish kerak?

Generator funksiyalarini kompozitsiya qilish sizga modulli va qayta ishlatilishi mumkin bo'lgan ma'lumotlarni qayta ishlash konveyerlarini yaratish imkonini beradi. Barcha qayta ishlash bosqichlarini bajaradigan bitta, monolit generator yozish o'rniga, muammoni har biri alohida vazifa uchun mas'ul bo'lgan kichikroq, boshqarilishi osonroq generatorlarga bo'lishingiz mumkin. Keyin bu generatorlarni to'liq konveyerni shakllantirish uchun bir-biriga zanjir qilib ulash mumkin.

Kompozitsiyaning quyidagi afzalliklarini ko'rib chiqing:

• Modullilik: Har bir generator yagona mas'uliyatga ega, bu esa kodni tushunish va saqlashni osonlashtiradi.
• Qayta foydalanish imkoniyati: Generatorlar turli konveyerlarda qayta ishlatilishi mumkin, bu esa kodning takrorlanishini kamaytiradi.
• Testlash qulayligi: Kichik generatorlarni alohida sinovdan o'tkazish osonroq.
• Moslashuvchanlik: Konveyerlarni generatorlarni qo'shish, olib tashlash yoki tartibini o'zgartirish orqali osongina o'zgartirish mumkin.

Generator Funksiyalarini Kompozitsiya qilish Usullari

JavaScript-da generator funksiyalarini kompozitsiya qilishning bir nechta usullari mavjud. Keling, eng keng tarqalgan yondashuvlardan ba'zilarini ko'rib chiqaylik.

1. Generator Delegatsiyasi (yield*)

yield* kalit so'zi boshqa takrorlanuvchi obyektga, shu jumladan, boshqa generator funksiyasiga delegatsiya qilishning qulay usulini taqdim etadi. yield* ishlatilganda, delegatsiya qilingan takrorlanuvchi obyekt tomonidan qaytarilgan qiymatlar to'g'ridan-to'g'ri joriy generator tomonidan qaytariladi.

Mana yield* yordamida ikkita generator funksiyasini kompozitsiya qilishga misol:

            
function* generateEvenNumbers(max) {
  for (let i = 0; i <= max; i++) {
    if (i % 2 === 0) {
      yield i;
    }
  }
}

function* prependMessage(message, iterable) {
  yield message;
  yield* iterable;
}

const evenNumbers = generateEvenNumbers(10);
const messageGenerator = prependMessage("Even Numbers:", evenNumbers);

for (const value of messageGenerator) {
  console.log(value);
}

// Output:
// Even Numbers:
// 0
// 2
// 4
// 6
// 8
// 10

            

              
                Copy
              
            
          

Ushbu misolda prependMessage xabarni qaytaradi va keyin yield* yordamida generateEvenNumbers generatoriga delegatsiya qiladi. Bu ikki generatorni samarali tarzda bitta ketma-ketlikka birlashtiradi.

2. Qo'lda Iteratsiya va Yielding

Siz generatorlarni qo'lda ham kompozitsiya qilishingiz mumkin, buning uchun delegatsiya qilingan generator bo'ylab iteratsiya qilib, uning qiymatlarini qaytarasiz. Bu yondashuv kompozitsiya jarayonini ko'proq nazorat qilish imkonini beradi, lekin ko'proq kod talab qiladi.

            
function* generateOddNumbers(max) {
  for (let i = 0; i <= max; i++) {
    if (i % 2 !== 0) {
      yield i;
    }
  }
}

function* appendMessage(iterable, message) {
  for (const value of iterable) {
    yield value;
  }
  yield message;
}

const oddNumbers = generateOddNumbers(9);
const messageGenerator = appendMessage(oddNumbers, "End of Sequence");

for (const value of messageGenerator) {
  console.log(value);
}

// Output:
// 1
// 3
// 5
// 7
// 9
// End of Sequence

            

              
                Copy
              
            
          

Ushbu misolda appendMessage for...of tsikli yordamida oddNumbers generatori bo'ylab iteratsiya qiladi va har bir qiymatni qaytaradi. Butun generator bo'ylab iteratsiya qilgandan so'ng, u yakuniy xabarni qaytaradi.

3. Yuqori Tartibli Funksiyalar bilan Funksional Kompozitsiya

Siz generator kompozitsiyasining yanada funksional va deklarativ uslubini yaratish uchun yuqori tartibli funksiyalardan foydalanishingiz mumkin. Bu generatorlarni kirish sifatida qabul qiladigan va ma'lumotlar oqimida transformatsiyalarni amalga oshiradigan yangi generatorlarni qaytaradigan funksiyalarni yaratishni o'z ichiga oladi.

            
function* numberRange(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

function mapGenerator(generator, transform) {
  return function*() {
    for (const value of generator) {
      yield transform(value);
    }
  };
}

function filterGenerator(generator, predicate) {
  return function*() {
    for (const value of generator) {
      if (predicate(value)) {
        yield value;
      }
    }
  };
}

const numbers = numberRange(1, 10);
const squaredNumbers = mapGenerator(numbers, x => x * x)();
const evenSquaredNumbers = filterGenerator(squaredNumbers, x => x % 2 === 0)();

for (const value of evenSquaredNumbers) {
  console.log(value);
}

// Output:
// 4
// 16
// 36
// 64
// 100

            

              
                Copy
              
            
          

Ushbu misolda mapGenerator va filterGenerator yuqori tartibli funksiyalar bo'lib, ular generator va transformatsiya yoki predikat funksiyasini kirish sifatida qabul qiladi. Ular asl generator tomonidan qaytarilgan qiymatlarga transformatsiya yoki filtrni qo'llaydigan yangi generator funksiyalarini qaytaradi. Bu sizga ushbu yuqori tartibli funksiyalarni bir-biriga zanjir qilib bog'lash orqali murakkab konveyerlar qurish imkonini beradi.

4. Generator Konveyer Kutubxonalari (masalan, IxJS)

Bir nechta JavaScript kutubxonalari takrorlanuvchi obyektlar va generatorlar bilan yanada funksional va deklarativ tarzda ishlash uchun yordamchi dasturlarni taqdim etadi. Bunga misol qilib IxJS (Interactive Extensions for JavaScript) ni keltirish mumkin, u takrorlanuvchi obyektlarni o'zgartirish va birlashtirish uchun boy operatorlar to'plamini taqdim etadi.

Eslatma: Tashqi kutubxonalardan foydalanish loyihangizga bog'liqliklar qo'shadi. Foyda va xarajatlarni baholang.

            
// Example using IxJS (install: npm install ix)
const { from, map, filter } = require('ix/iterable');

function* numberRange(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

const numbers = from(numberRange(1, 10));
const squaredNumbers = map(numbers, x => x * x);
const evenSquaredNumbers = filter(squaredNumbers, x => x % 2 === 0);

for (const value of evenSquaredNumbers) {
  console.log(value);
}

// Output:
// 4
// 16
// 36
// 64
// 100

            

              
                Copy
              
            
          

Ushbu misolda avvalgi misoldagi kabi o'zgartirishlarni amalga oshirish uchun IxJS ishlatiladi, lekin yanada ixcham va deklarativ tarzda. IxJS takrorlanuvchi obyektlarda ishlaydigan map va filter kabi operatorlarni taqdim etadi, bu esa murakkab ma'lumotlarni qayta ishlash konveyerlarini yaratishni osonlashtiradi.

Generator Funksiyalari Kompozitsiyasining Haqiqiy Hayotdagi Misollari

Generator funksiyalari kompozitsiyasini turli xil real hayotiy stsenariylarga qo'llash mumkin. Mana bir nechta misollar:

1. Ma'lumotlarni O'zgartirish Konveyerlari

Tasavvur qiling, siz CSV faylidan ma'lumotlarni qayta ishlayapsiz. Siz turli xil o'zgartirishlarni amalga oshirish uchun generatorlar konveyerini yaratishingiz mumkin, masalan:

• CSV faylini o'qish va har bir qatorni obyekt sifatida qaytarish.
• Ma'lum mezonlarga ko'ra qatorlarni filtrlash (masalan, faqat ma'lum bir mamlakat kodiga ega bo'lgan qatorlar).
• Har bir qatordagi ma'lumotlarni o'zgartirish (masalan, sanalarni ma'lum bir formatga o'tkazish, hisob-kitoblarni amalga oshirish).
• O'zgartirilgan ma'lumotlarni yangi faylga yoki ma'lumotlar bazasiga yozish.

Ushbu bosqichlarning har biri alohida generator funksiyasi sifatida amalga oshirilishi va keyin to'liq ma'lumotlarni qayta ishlash konveyerini shakllantirish uchun bir-biriga birlashtirilishi mumkin. Masalan, agar ma'lumotlar manbai butun dunyo bo'ylab mijozlar joylashuvining CSV fayli bo'lsa, sizda mamlakat bo'yicha filtrlash (masalan, "Yaponiya", "Braziliya", "Germaniya") va keyin markaziy ofisgacha bo'lgan masofani hisoblaydigan transformatsiyani qo'llash kabi bosqichlar bo'lishi mumkin.

2. Asinxron Ma'lumotlar Oqimlari

Generatorlar veb-soket yoki API kabi asinxron ma'lumotlar oqimlarini qayta ishlash uchun ham ishlatilishi mumkin. Siz oqimdan ma'lumotlarni oladigan va har bir elementni mavjud bo'lganda qaytaradigan generator yaratishingiz mumkin. Keyin bu generator ma'lumotlarda transformatsiyalar va filtrlashni amalga oshirish uchun boshqa generatorlar bilan kompozitsiya qilinishi mumkin.

Sahifalangan API-dan foydalanuvchi profillarini olishni ko'rib chiqing. Generator har bir sahifani olishi va o'sha sahifadagi foydalanuvchi profillarini yield* yordamida qaytarishi mumkin. Boshqa bir generator esa bu profillarni oxirgi bir oydagi faolligiga qarab filtrlashi mumkin.

3. Maxsus Iteratorlarni Amalga Oshirish

Generator funksiyalari murakkab ma'lumotlar tuzilmalari uchun maxsus iteratorlarni amalga oshirishning ixcham usulini taqdim etadi. Siz ma'lumotlar tuzilmasini aylanib chiqadigan va uning elementlarini ma'lum bir tartibda qaytaradigan generator yaratishingiz mumkin. Keyin bu iterator for...of tsikllarida yoki boshqa takrorlanuvchi kontekstlarda ishlatilishi mumkin.

Masalan, siz binar daraxtni ma'lum bir tartibda (masalan, in-order, pre-order, post-order) aylanib chiqadigan yoki elektron jadvalning katakchalarini qator bo'yicha iteratsiya qiladigan generator yaratishingiz mumkin.

Generator Funksiyalari Kompozitsiyasi uchun Eng Yaxshi Amaliyotlar

Generator funksiyalarini kompozitsiya qilishda yodda tutish kerak bo'lgan ba'zi eng yaxshi amaliyotlar:

• Generatorlarni kichik va aniq maqsadli qiling: Har bir generator yagona, aniq belgilangan mas'uliyatga ega bo'lishi kerak. Bu kodni tushunish, sinovdan o'tkazish va saqlashni osonlashtiradi.
• Tavsiflovchi nomlardan foydalaning: Generatorlaringizga ularning maqsadini aniq ko'rsatuvchi tavsiflovchi nomlar bering.
• Xatoliklarni ehtiyotkorlik bilan boshqaring: Xatoliklarning konveyer bo'ylab tarqalishini oldini olish uchun har bir generator ichida xatoliklarni qayta ishlashni amalga oshiring. Generatorlaringiz ichida try...catch bloklaridan foydalanishni ko'rib chiqing.
• Ishlash samaradorligini hisobga oling: Generatorlar odatda samarali bo'lsa-da, murakkab konveyerlar baribir ishlash samaradorligiga ta'sir qilishi mumkin. Kodingizni profillang va kerakli joylarda optimallashtiring.
• Kodingizni hujjatlashtiring: Har bir generatorning maqsadini va uning konveyerdagi boshqa generatorlar bilan qanday o'zaro ta'sir qilishini aniq hujjatlashtiring.

Ilg'or Texnikalar

Generator Zanjirlarida Xatoliklarni Boshqarish

Generator zanjirlarida xatoliklarni qayta ishlash ehtiyotkorlikni talab qiladi. Generator ichida xatolik yuzaga kelganda, u butun konveyerni buzishi mumkin. Siz qo'llashingiz mumkin bo'lgan bir nechta strategiya mavjud:

1. Generatorlar ichida Try-Catch: Eng oddiy yondashuv - har bir generator funksiyasi ichidagi kodni try...catch blokiga o'rash. Bu sizga xatoliklarni mahalliy darajada qayta ishlash va ehtimol standart qiymat yoki maxsus xatolik obyektini qaytarish imkonini beradi.
2. Xatolik Chegaralari (Reactdan olingan, bu yerga moslashtirilishi mumkin bo'lgan konsepsiya): O'zining delegatsiya qilingan generatori tomonidan yuzaga kelgan har qanday istisnolarni ushlaydigan o'rovchi (wrapper) generator yarating. Bu sizga xatolikni qayd etish va zaxira qiymat bilan zanjirni davom ettirish imkonini beradi.

            
function* potentiallyFailingGenerator() {
  try {
    // Code that might throw an error
    const result = someRiskyOperation();
    yield result;
  } catch (error) {
    console.error("Error in potentiallyFailingGenerator:", error);
    yield null; // Or yield a specific error object
  }
}

function* errorBoundary(generator) {
    try {
        yield* generator();
    } catch (error) {
        console.error("Error Boundary Caught:", error);
        yield "Fallback Value"; // Or some other recovery mechanism
    }
}

const myGenerator = errorBoundary(potentiallyFailingGenerator);

for (const value of myGenerator) {
  console.log(value);
}

            

              
                Copy
              
            
          

Asinxron Generatorlar va Kompozitsiya

JavaScript-da asinxron generatorlarning paydo bo'lishi bilan endi siz asinxron ma'lumotlarni tabiiyroq qayta ishlaydigan generator zanjirlarini yaratishingiz mumkin. Asinxron generatorlar async function* sintaksisidan foydalanadi va asinxron operatsiyalarni kutish uchun await kalit so'zini ishlatishi mumkin.

            
async function* fetchUsers(userIds) {
  for (const userId of userIds) {
    const user = await fetchUser(userId); // Assuming fetchUser is an async function
    yield user;
  }
}

async function* filterActiveUsers(users) {
  for await (const user of users) {
    if (user.isActive) {
      yield user;
    }
  }
}

async function fetchUser(id) {
    //Simulate an async fetch
    return new Promise(resolve => {
        setTimeout(() => {
            resolve({ id: id, name: `User ${id}`, isActive: id % 2 === 0});
        }, 500);
    });
}

async function main() {
  const userIds = [1, 2, 3, 4, 5];
  const users = fetchUsers(userIds);
  const activeUsers = filterActiveUsers(users);

  for await (const user of activeUsers) {
    console.log(user);
  }
}

main();

//Possible output:
// { id: 2, name: 'User 2', isActive: true }
// { id: 4, name: 'User 4', isActive: true }

            

              
                Copy
              
            
          

Asinxron generatorlar bo'ylab iteratsiya qilish uchun for await...of tsiklidan foydalanish kerak. Asinxron generatorlarni oddiy generatorlar kabi yield* yordamida kompozitsiya qilish mumkin.

Xulosa

Generator funksiyalari kompozitsiyasi JavaScript-da modulli, qayta ishlatilishi mumkin bo'lgan va sinovdan o'tkaziladigan ma'lumotlarni qayta ishlash konveyerlarini yaratish uchun kuchli texnikadir. Murakkab muammolarni kichikroq, boshqariladigan generatorlarga bo'lish orqali siz yanada barqaror va moslashuvchan kod yaratishingiz mumkin. CSV faylidan ma'lumotlarni o'zgartiryapsizmi, asinxron ma'lumotlar oqimlarini qayta ishlayapsizmi yoki maxsus iteratorlarni amalga oshiryapsizmi, generator funksiyalari kompozitsiyasi sizga toza va samaraliroq kod yozishga yordam beradi. Generator funksiyalarini kompozitsiya qilishning turli usullarini, jumladan, generator delegatsiyasi, qo'lda iteratsiya va yuqori tartibli funksiyalar bilan funksional kompozitsiyani tushunib, siz o'z JavaScript loyihalaringizda generatorlarning to'liq salohiyatidan foydalanishingiz mumkin. Eng yaxshi amaliyotlarga rioya qilishni, xatoliklarni ehtiyotkorlik bilan boshqarishni va generator konveyerlaringizni loyihalashda ishlash samaradorligini hisobga olishni unutmang. Turli yondashuvlar bilan tajriba qiling va ehtiyojlaringiz va kodlash uslubingizga eng mos keladigan usullarni toping. Nihoyat, generator asosidagi ish oqimlaringizni yanada yaxshilash uchun IxJS kabi mavjud kutubxonalarni o'rganing. Amaliyot bilan siz JavaScript generator funksiyalari yordamida murakkab va samarali ma'lumotlarni qayta ishlash yechimlarini yarata olasiz.