JavaScript Generator Strelkali Funksiyalari: Iteratsiya uchun Qisqa Sintaksis

JavaScript generatorlari iteratsiyani boshqarish uchun kuchli mexanizmni taqdim etadi. Strelkali funksiyalarning qisqa sintaksisi bilan birgalikda ular iteratorlarni yaratishning nafis usulini taklif qiladi. Ushbu keng qamrovli qo'llanma generator strelkali funksiyalarini batafsil o'rganib chiqadi va ularning afzalliklaridan foydalanishingizga yordam beradigan misollar va eng yaxshi amaliyotlarni taqdim etadi.

Generator Funksiyalari nima?

Generator funksiyasi JavaScript'dagi maxsus turdagi funksiya bo'lib, uni to'xtatib turish va davom ettirish mumkin, bu esa vaqt o'tishi bilan qiymatlar ketma-ketligini yaratishga imkon beradi. Bunga yield kalit so'zi yordamida erishiladi, u funksiya bajarilishini to'xtatadi va chaqiruvchiga qiymat qaytaradi. Chaqiruvchi keyingi qiymatni so'raganda, funksiya to'xtagan joyidan davom etadi.

An'anaviy generator funksiyalari function* sintaksisi yordamida aniqlanadi:

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

const generator = numberGenerator();

console.log(generator.next().value); // Chiqish: 1
console.log(generator.next().value); // Chiqish: 2
console.log(generator.next().value); // Chiqish: 3
console.log(generator.next().value); // Chiqish: undefined

            

              
                Copy
              
            
          

Strelkali Funksiyalar bilan tanishuv

Strelkali funksiyalar JavaScript'da funksiyalarni aniqlash uchun qisqaroq sintaksisni taqdim etadi. Ular ayniqsa qisqa, oddiy funksiyalar uchun foydalidir va ular this qiymatini avtomatik ravishda atrofdagi kontekstga bog'laydi.

Mana strelkali funksiyaning oddiy misoli:

            const add = (a, b) => a + b;

console.log(add(2, 3)); // Chiqish: 5

            

              
                Copy
              
            
          

Generatorlar va Strelkali Funksiyalarni Birlashtirish

function* sintaksisini standart strelkali funksiya sintaksisi bilan to'g'ridan-to'g'ri birlashtirish mumkin bo'lmasa-da, siz strelkali funksiya yozuvidan foydalanadigan doimiy o'zgaruvchiga generator funksiyasi ifodasini tayinlash orqali shunga o'xshash natijaga erishishingiz mumkin.

Standart generator funksiyasi quyidagicha ko'rinadi:

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

            

              
                Copy
              
            
          

Endi buni strelkali funksiya yordamida ifodalaymiz:

            const myGenerator = function* () {
 yield 1;
 yield 2;
 yield 3;
};

const generator = myGenerator();
console.log(generator.next().value); // 1
console.log(generator.next().value); // 2
console.log(generator.next().value); // 3

            

              
                Copy
              
            
          

Yuqoridagi kod myGenerator doimiysini e'lon qiladi va unga generator funksiyasi ifodasini tayinlaydi. Bu, ayniqsa, oddiy mantiq bilan ishlaganda, generatorlarni yaratishning yanada ixcham usulini ta'minlaydi.

Generator Strelkali Funksiyalarining Afzalliklari

• Qisqa Sintaksis: Strelkali funksiyalar an'anaviy funksiya e'lonlariga qaraganda ixchamroq sintaksisni taklif qiladi, bu esa toza va o'qilishi osonroq kodga olib keladi.
• Yaxshilangan O'qiluvchanlik: Ortiqcha kodni kamaytirish orqali strelkali funksiyalar generatorlaringiz mantig'ini tushunishni osonlashtiradi.
• Funksional Dasturlash: Generator strelkali funksiyalari funksional dasturlash paradigmalariga juda mos keladi, bu yerda funksiyalarga birinchi darajali fuqarolar sifatida qaraladi.

Generator Strelkali Funksiyalari uchun Qo'llash Holatlari

Generator strelkali funksiyalari talab bo'yicha qiymatlar ketma-ketligini yaratish kerak bo'lgan turli xil stsenariylarda ishlatilishi mumkin. Ba'zi keng tarqalgan qo'llash holatlariga quyidagilar kiradi:

• Katta ma'lumotlar to'plamlari bo'yicha iteratsiya: Generatorlar ma'lumotlarni qismlarga bo'lib ishlashga imkon beradi, bu esa katta ma'lumotlar to'plamlari bilan ishlaganda xotira muammolarini oldini oladi.
• Maxsus iteratorlarni amalga oshirish: Siz o'zingizning ma'lumotlar tuzilmalaringiz uchun maxsus iteratorlar yaratishingiz mumkin, bu murakkab ma'lumotlar bilan ishlashni osonlashtiradi.
• Asinxron dasturlash: Generatorlar asinxron kodni soddalashtirish va o'qiluvchanlikni yaxshilash uchun async/await bilan ishlatilishi mumkin.
• Cheksiz ketma-ketliklarni yaratish: Generatorlar cheksiz qiymatlar ketma-ketligini ishlab chiqarishi mumkin, bu simulyatsiyalar va boshqa ilovalar uchun foydali bo'lishi mumkin.

Amaliy Misollar

1-misol: Fibonachchi Ketma-ketligini Yaratish

Ushbu misol Fibonachchi ketma-ketligini yaratish uchun generator strelkali funksiyasidan qanday foydalanishni ko'rsatadi.

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

const sequence = fibonacci();

console.log(sequence.next().value); // Chiqish: 0
console.log(sequence.next().value); // Chiqish: 1
console.log(sequence.next().value); // Chiqish: 1
console.log(sequence.next().value); // Chiqish: 2
console.log(sequence.next().value); // Chiqish: 3
console.log(sequence.next().value); // Chiqish: 5

            

              
                Copy
              
            
          

2-misol: Daraxt Tuzilmasi Bo'yicha Iteratsiya

Ushbu misol daraxt tuzilmasi bo'yicha iteratsiya qilish uchun generator strelkali funksiyasidan qanday foydalanishni ko'rsatadi.

            const tree = {
 value: 1,
 children: [
 {
 value: 2,
 children: [
 { value: 4 },
 { value: 5 }
 ]
 },
 {
 value: 3,
 children: [
 { value: 6 },
 { value: 7 }
 ]
 }
 ]
};

const traverseTree = function* (node) {
 yield node.value;
 if (node.children) {
 for (const child of node.children) {
 yield* traverseTree(child);
 }
 }
};

const traversal = traverseTree(tree);

console.log(traversal.next().value); // Chiqish: 1
console.log(traversal.next().value); // Chiqish: 2
console.log(traversal.next().value); // Chiqish: 4
console.log(traversal.next().value); // Chiqish: 5
console.log(traversal.next().value); // Chiqish: 3
console.log(traversal.next().value); // Chiqish: 6
console.log(traversal.next().value); // Chiqish: 7

            

              
                Copy
              
            
          

3-misol: Oddiy Diapazon Generatorini Amalga Oshirish

Ushbu misol belgilangan diapazondagi raqamlar ketma-ketligini ishlab chiqaradigan generator yaratishni ko'rsatadi.

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

const numbers = range(1, 5);

console.log(numbers.next().value); // Chiqish: 1
console.log(numbers.next().value); // Chiqish: 2
console.log(numbers.next().value); // Chiqish: 3
console.log(numbers.next().value); // Chiqish: 4
console.log(numbers.next().value); // Chiqish: 5

            

              
                Copy
              
            
          

Eng Yaxshi Amaliyotlar

• Tavsiflovchi nomlardan foydalaning: Kodning o'qiluvchanligini yaxshilash uchun generator funksiyalaringiz va o'zgaruvchilaringiz uchun mazmunli nomlarni tanlang.
• Generatorlarni yo'naltirilgan holda saqlang: Har bir generator yagona, aniq belgilangan maqsadga ega bo'lishi kerak.
• Xatolarni chiroyli tarzda qayta ishlang: Kutilmagan xatti-harakatlarning oldini olish uchun xatolarni qayta ishlash mexanizmlarini joriy qiling.
• Kodingizni hujjatlashtiring: Generatorlaringizning maqsadi va funksionalligini tushuntirish uchun izohlar qo'shing.
• Kodingizni sinovdan o'tkazing: Generatorlaringiz to'g'ri ishlayotganiga ishonch hosil qilish uchun birlik testlarini yozing.

Ilg'or Texnikalar

Boshqa Generatorlarga Vakolat Berish

yield* kalit so'zi yordamida iteratsiyani boshqa generatorga topshirishingiz mumkin. Bu sizga kichikroq, qayta ishlatiladigan generatorlardan murakkab iteratorlarni yaratish imkonini beradi.

            const generator1 = function* () {
 yield 1;
 yield 2;
};

const generator2 = function* () {
 yield 3;
 yield 4;
};

const combinedGenerator = function* () {
 yield* generator1();
 yield* generator2();
};

const combined = combinedGenerator();

console.log(combined.next().value); // Chiqish: 1
console.log(combined.next().value); // Chiqish: 2
console.log(combined.next().value); // Chiqish: 3
console.log(combined.next().value); // Chiqish: 4

            

              
                Copy
              
            
          

Generatorlarga Qiymatlarni Uzatish

next() metodi yordamida generatorga qiymatlarni uzatishingiz mumkin. Bu sizga generatorning xatti-harakatlarini tashqaridan boshqarish imkonini beradi.

            const echoGenerator = function* () {
 const value = yield;
 return value;
};

const echo = echoGenerator();

echo.next(); // Generatorni ishga tushirish
console.log(echo.next("Hello").value); // Chiqish: Hello

            

              
                Copy
              
            
          

Global Mulohazalar

Generator strelkali funksiyalarini global kontekstda ishlatganda, quyidagilarni hisobga olish muhim:

• Brauzer mosligi: Maqsadli brauzerlaringiz ES6 xususiyatlarini, jumladan, strelkali funksiyalar va generatorlarni qo'llab-quvvatlashiga ishonch hosil qiling. Eski brauzerlarni qo'llab-quvvatlash uchun Babel kabi transpilyatordan foydalanishni o'ylab ko'ring.
• Kod tashkiloti: Xizmat ko'rsatish qulayligini oshirish va nomlar to'qnashuvining oldini olish uchun kodingizni modullarga ajrating.
• Xalqarolashtirish: Agar ilovangiz bir nechta tillarni qo'llab-quvvatlasa, generatorlaringizda xalqarolashtirishni to'g'ri boshqarishga ishonch hosil qiling. Masalan, sana formatlash hududga qarab turlicha amalga oshirilishi kerak bo'lishi mumkin.
• Foydalanish imkoniyati: Generatorlaringiz nogironligi bo'lgan foydalanuvchilar uchun ochiq ekanligiga ishonch hosil qiling. Bu yaratilgan qiymatlarga kirishning muqobil usullarini taqdim etishni o'z ichiga olishi mumkin.

Generator Strelkali Funksiyalari va Asinxron Operatsiyalar

Generatorlar asinxron operatsiyalar bilan birlashtirilganda ayniqsa kuchli bo'ladi. Ular sinxron kod kabi ko'rinadigan va ishlaydadigan asinxron kod yozish uchun ishlatilishi mumkin, bu esa uni tushunish va saqlashni osonlashtiradi. Bu odatda generator bilan birgalikda async va await yordamida amalga oshiriladi.

            async function* fetchAndProcessData(urls) {
 for (const url of urls) {
 try {
 const response = await fetch(url);
 const data = await response.json();
 yield data;
 } catch (error) {
 console.error(`Failed to fetch data from ${url}: ${error}`);
 }
 }
}

async function main() {
 const urls = [
 'https://jsonplaceholder.typicode.com/todos/1',
 'https://jsonplaceholder.typicode.com/todos/2',
 'https://jsonplaceholder.typicode.com/todos/3'
 ];

 const dataStream = fetchAndProcessData(urls);

 for await (const item of dataStream) {
 console.log(item);
 }
}

main();

            

              
                Copy
              
            
          

Ushbu misolda, fetchAndProcessData funksiyasi bir nechta URL manzillaridan ma'lumotlarni olib keladigan va natijalarni qaytaradigan asinxron generatordir. main funksiyasi generator bo'yicha for await...of tsikli yordamida iteratsiya qiladi, bu esa unga ma'lumotlar paydo bo'lishi bilan ularni qayta ishlashga imkon beradi.

Xulosa

JavaScript generator strelkali funksiyalari iteratorlarni yaratishning kuchli va qisqa usulini taqdim etadi. Ularning sintaksisi, afzalliklari va qo'llanilish holatlarini tushunib, siz ulardan samaraliroq, o'qilishi oson va saqlanishi oson kod yozish uchun foydalanishingiz mumkin. Katta ma'lumotlar to'plamlari bilan ishlaysizmi, maxsus iteratorlarni amalga oshirasizmi yoki asinxron kodni soddalashtirasizmi, generator strelkali funksiyalari sizning JavaScript asboblar to'plamingizda qimmatli vosita bo'lishi mumkin.