ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஆரோ ஃபங்ஷன்கள்: மறுசெய்கைக்கான சுருக்கமான தொடரியல்

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்கள் மறுசெய்கையைக் கட்டுப்படுத்த ஒரு சக்திவாய்ந்த வழிமுறையை வழங்குகின்றன. ஆரோ ஃபங்ஷன்களின் சுருக்கமான தொடரியலுடன் இணைந்தால், அவை இட்டரேட்டர்களை உருவாக்க ஒரு நேர்த்தியான வழியை வழங்குகின்றன. இந்த விரிவான வழிகாட்டி ஜெனரேட்டர் ஆரோ ஃபங்ஷன்களை விரிவாக ஆராய்ந்து, அவற்றின் நன்மைகளைப் பயன்படுத்த உதவும் எடுத்துக்காட்டுகள் மற்றும் சிறந்த நடைமுறைகளை வழங்கும்.

ஜெனரேட்டர் ஃபங்ஷன்கள் என்றால் என்ன?

ஜெனரேட்டர் ஃபங்ஷன் என்பது ஜாவாஸ்கிரிப்டில் ஒரு சிறப்பு வகை ஃபங்ஷன் ஆகும், இதை இடைநிறுத்தி மீண்டும் இயக்க முடியும், இது காலப்போக்கில் மதிப்புகளின் வரிசையை உருவாக்க உங்களை அனுமதிக்கிறது. இது yield என்ற கீவேர்டைப் பயன்படுத்தி அடையப்படுகிறது, இது ஃபங்ஷனின் செயல்பாட்டை இடைநிறுத்தி, அழைப்பாளருக்கு ஒரு மதிப்பை வழங்குகிறது. அழைப்பாளர் அடுத்த மதிப்பைக் கோரும்போது, ஃபங்ஷன் விட்ட இடத்திலிருந்து மீண்டும் தொடங்கும்.

பாரம்பரிய ஜெனரேட்டர் ஃபங்ஷன்கள் function* தொடரியலைப் பயன்படுத்தி வரையறுக்கப்படுகின்றன:

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

const generator = numberGenerator();

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

            

              
                Copy
              
            
          

ஆரோ ஃபங்ஷன்களின் அறிமுகம்

ஆரோ ஃபங்ஷன்கள் ஜாவாஸ்கிரிப்டில் ஃபங்ஷன்களை வரையறுக்க மிகவும் சுருக்கமான தொடரியலை வழங்குகின்றன. அவை குறுகிய, எளிய ஃபங்ஷன்களுக்கு மிகவும் பயனுள்ளதாக இருக்கும், மேலும் அவை சுற்றியுள்ள சூழலுக்கு this மதிப்பை தானாகவே பிணைக்கின்றன.

இங்கே ஆரோ ஃபங்ஷனின் ஒரு எளிய எடுத்துக்காட்டு:

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

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

            

              
                Copy
              
            
          

ஜெனரேட்டர்கள் மற்றும் ஆரோ ஃபங்ஷன்களை இணைத்தல்

function* தொடரியலை நிலையான ஆரோ ஃபங்ஷன் தொடரியலுடன் நேரடியாக இணைக்க முடியாவிட்டாலும், ஆரோ ஃபங்ஷன் குறியீட்டைப் பயன்படுத்தும் ஒரு மாறிலி மாறிக்கு ஒரு ஜெனரேட்டர் ஃபங்ஷன் எக்ஸ்பிரஷனை ஒதுக்குவதன் மூலம் இதே போன்ற முடிவை அடையலாம்.

நிலையான ஜெனரேட்டர் ஃபங்ஷன் இப்படி இருக்கும்:

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

            

              
                Copy
              
            
          

இப்போது, அதை ஒரு ஆரோ ஃபங்ஷனைப் பயன்படுத்தி வெளிப்படுத்துவோம்:

            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
              
            
          

மேலே உள்ள குறியீடு myGenerator என்ற மாறிலியை அறிவித்து, அதற்கு ஒரு ஜெனரேட்டர் ஃபங்ஷன் எக்ஸ்பிரஷனை ஒதுக்குகிறது. இது ஜெனரேட்டர்களை உருவாக்குவதற்கான ஒரு சுருக்கமான வழியை வழங்குகிறது, குறிப்பாக எளிய தர்க்கத்தைக் கையாளும் போது.

ஜெனரேட்டர் ஆரோ ஃபங்ஷன்களின் நன்மைகள்

• சுருக்கமான தொடரியல்: பாரம்பரிய ஃபங்ஷன் அறிவிப்புகளுடன் ஒப்பிடும்போது ஆரோ ஃபங்ஷன்கள் மிகவும் சுருக்கமான தொடரியலை வழங்குகின்றன, இது தெளிவான மற்றும் வாசிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கிறது.
• மேம்படுத்தப்பட்ட வாசிப்புத்திறன்: தேவையற்ற குறியீட்டைக் குறைப்பதன் மூலம், ஆரோ ஃபங்ஷன்கள் உங்கள் ஜெனரேட்டர்களின் தர்க்கத்தைப் புரிந்துகொள்வதை எளிதாக்குகின்றன.
• ஃபங்ஷனல் புரோகிராமிங்: ஜெனரேட்டர் ஆரோ ஃபங்ஷன்கள் ஃபங்ஷனல் புரோகிராமிங் முன்னுதாரணங்களுக்கு மிகவும் பொருத்தமானவை, அங்கு ஃபங்ஷன்கள் முதல் தர குடிமக்களாகக் கருதப்படுகின்றன.

ஜெனரேட்டர் ஆரோ ஃபங்ஷன்களுக்கான பயன்பாட்டு வழக்குகள்

தேவைக்கேற்ப மதிப்புகளின் வரிசையை நீங்கள் உருவாக்க வேண்டிய பல்வேறு சூழ்நிலைகளில் ஜெனரேட்டர் ஆரோ ஃபங்ஷன்களைப் பயன்படுத்தலாம். சில பொதுவான பயன்பாட்டு வழக்குகள் பின்வருமாறு:

• பெரிய தரவுத்தொகுப்புகளில் மறுசெய்கை செய்தல்: ஜெனரேட்டர்கள் தரவை சிறு பகுதிகளாகச் செயலாக்க உங்களை அனுமதிக்கின்றன, பெரிய தரவுத்தொகுப்புகளைக் கையாளும்போது நினைவகச் சிக்கல்களைத் தவிர்க்கின்றன.
• தனிப்பயன் இட்டரேட்டர்களை செயல்படுத்துதல்: உங்கள் தரவுக் கட்டமைப்புகளுக்கு தனிப்பயன் இட்டரேட்டர்களை உருவாக்கலாம், இது சிக்கலான தரவுகளுடன் வேலை செய்வதை எளிதாக்குகிறது.
• ஒத்திசைவற்ற நிரலாக்கம்: ஒத்திசைவற்ற குறியீட்டை எளிதாக்கவும் வாசிப்புத்திறனை மேம்படுத்தவும் ஜெனரேட்டர்களை async/await உடன் பயன்படுத்தலாம்.
• முடிவற்ற வரிசைகளை உருவாக்குதல்: ஜெனரேட்டர்கள் முடிவற்ற மதிப்புகளின் வரிசைகளை உருவாக்க முடியும், இது உருவகப்படுத்துதல்கள் மற்றும் பிற பயன்பாடுகளுக்கு பயனுள்ளதாக இருக்கும்.

நடைமுறை எடுத்துக்காட்டுகள்

எடுத்துக்காட்டு 1: ஒரு ஃபைபோனச்சி வரிசையை உருவாக்குதல்

இந்த எடுத்துக்காட்டு ஃபைபோனச்சி வரிசையை உருவாக்க ஒரு ஜெனரேட்டர் ஆரோ ஃபங்ஷனை எவ்வாறு பயன்படுத்துவது என்பதைக் காட்டுகிறது.

            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); // Output: 0
console.log(sequence.next().value); // Output: 1
console.log(sequence.next().value); // Output: 1
console.log(sequence.next().value); // Output: 2
console.log(sequence.next().value); // Output: 3
console.log(sequence.next().value); // Output: 5

            

              
                Copy
              
            
          

எடுத்துக்காட்டு 2: ஒரு மரம் போன்ற அமைப்பில் மறுசெய்கை செய்தல்

இந்த எடுத்துக்காட்டு ஒரு மரம் போன்ற அமைப்பில் மறுசெய்கை செய்ய ஒரு ஜெனரேட்டர் ஆரோ ஃபங்ஷனை எவ்வாறு பயன்படுத்துவது என்பதைக் காட்டுகிறது.

            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); // Output: 1
console.log(traversal.next().value); // Output: 2
console.log(traversal.next().value); // Output: 4
console.log(traversal.next().value); // Output: 5
console.log(traversal.next().value); // Output: 3
console.log(traversal.next().value); // Output: 6
console.log(traversal.next().value); // Output: 7

            

              
                Copy
              
            
          

எடுத்துக்காட்டு 3: ஒரு எளிய வரம்பு ஜெனரேட்டரை செயல்படுத்துதல்

இந்த எடுத்துக்காட்டு ஒரு குறிப்பிட்ட வரம்பிற்குள் எண்களின் வரிசையை உருவாக்கும் ஒரு ஜெனரேட்டரை உருவாக்குவதைக் காட்டுகிறது.

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

const numbers = range(1, 5);

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

            

              
                Copy
              
            
          

சிறந்த நடைமுறைகள்

• விளக்கமான பெயர்களைப் பயன்படுத்துங்கள்: குறியீட்டின் வாசிப்புத்திறனை மேம்படுத்த உங்கள் ஜெனரேட்டர் ஃபங்ஷன்கள் மற்றும் மாறிகளுக்கு அர்த்தமுள்ள பெயர்களைத் தேர்வு செய்யவும்.
• ஜெனரேட்டர்களைக் கவனம் சிதறாமல் வைத்திருங்கள்: ஒவ்வொரு ஜெனரேட்டருக்கும் ஒரு தனி, நன்கு வரையறுக்கப்பட்ட நோக்கம் இருக்க வேண்டும்.
• பிழைகளை நளினமாகக் கையாளவும்: எதிர்பாராத நடத்தையைத் தடுக்க பிழை கையாளும் வழிமுறைகளைச் செயல்படுத்தவும்.
• உங்கள் குறியீட்டை ஆவணப்படுத்துங்கள்: உங்கள் ஜெனரேட்டர்களின் நோக்கம் மற்றும் செயல்பாட்டை விளக்க கருத்துரைகளைச் சேர்க்கவும்.
• உங்கள் குறியீட்டைச் சோதிக்கவும்: உங்கள் ஜெனரேட்டர்கள் சரியாக வேலை செய்கின்றன என்பதை உறுதிப்படுத்த யூனிட் சோதனைகளை எழுதவும்.

மேம்பட்ட நுட்பங்கள்

மற்ற ஜெனரேட்டர்களுக்கு ஒப்படைத்தல்

yield* என்ற கீவேர்டைப் பயன்படுத்தி மற்றொரு ஜெனரேட்டருக்கு மறுசெய்கையை ஒப்படைக்கலாம். இது சிறிய, மீண்டும் பயன்படுத்தக்கூடிய ஜெனரேட்டர்களிலிருந்து சிக்கலான இட்டரேட்டர்களை உருவாக்க உங்களை அனுமதிக்கிறது.

            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); // Output: 1
console.log(combined.next().value); // Output: 2
console.log(combined.next().value); // Output: 3
console.log(combined.next().value); // Output: 4

            

              
                Copy
              
            
          

ஜெனரேட்டர்களுக்குள் மதிப்புகளை அனுப்புதல்

next() முறையைப் பயன்படுத்தி ஒரு ஜெனரேட்டருக்குள் மதிப்புகளை அனுப்பலாம். இது ஜெனரேட்டரின் நடத்தையை வெளியிலிருந்து கட்டுப்படுத்த உங்களை அனுமதிக்கிறது.

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

const echo = echoGenerator();

echo.next(); // Start the generator
console.log(echo.next("Hello").value); // Output: Hello

            

              
                Copy
              
            
          

உலகளாவிய பரிசீலனைகள்

உலகளாவிய சூழலில் ஜெனரேட்டர் ஆரோ ஃபங்ஷன்களைப் பயன்படுத்தும்போது, பின்வருவனவற்றைக் கருத்தில் கொள்வது அவசியம்:

• உலாவி இணக்கத்தன்மை: உங்கள் இலக்கு உலாவிகள் ஆரோ ஃபங்ஷன்கள் மற்றும் ஜெனரேட்டர்கள் உட்பட ES6 அம்சங்களை ஆதரிக்கின்றன என்பதை உறுதிப்படுத்தவும். பழைய உலாவிகளை ஆதரிக்க பேபல் போன்ற ஒரு டிரான்ஸ்பைலரைப் பயன்படுத்தவும்.
• குறியீடு அமைப்பு: பராமரிப்பை மேம்படுத்தவும் பெயரிடல் முரண்பாடுகளைத் தவிர்க்கவும் உங்கள் குறியீட்டை மாட்யூல்களாக ஒழுங்கமைக்கவும்.
• சர்வதேசமயமாக்கல்: உங்கள் பயன்பாடு பல மொழிகளை ஆதரித்தால், உங்கள் ஜெனரேட்டர்களில் சர்வதேசமயமாக்கலைச் சரியாகக் கையாளுவதை உறுதிப்படுத்திக் கொள்ளுங்கள். உதாரணமாக, தேதி வடிவமைப்பு இடத்தைப் பொறுத்து வித்தியாசமாகக் கையாளப்பட வேண்டியிருக்கும்.
• அணுகல்தன்மை: உங்கள் ஜெனரேட்டர்கள் குறைபாடுகள் உள்ள பயனர்களுக்கு அணுகக்கூடியவை என்பதை உறுதிப்படுத்தவும். இது உருவாக்கப்பட்ட மதிப்புகளை அணுக மாற்று வழிகளை வழங்குவதை உள்ளடக்கியிருக்கலாம்.

ஜெனரேட்டர் ஆரோ ஃபங்ஷன்கள் மற்றும் ஒத்திசைவற்ற செயல்பாடுகள்

ஒத்திசைவற்ற செயல்பாடுகளுடன் இணைக்கப்படும்போது ஜெனரேட்டர்கள் குறிப்பாக சக்திவாய்ந்தவை. ஒத்திசைவான குறியீடு போல தோற்றமளிக்கும் மற்றும் செயல்படும் ஒத்திசைவற்ற குறியீட்டை எழுத அவற்றைப் பயன்படுத்தலாம், இது புரிந்துகொள்வதற்கும் பராமரிப்பதற்கும் எளிதாக்குகிறது. இது பொதுவாக ஒரு ஜெனரேட்டருடன் இணைந்து async மற்றும் await ஐப் பயன்படுத்தி செய்யப்படுகிறது.

            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
              
            
          

இந்த எடுத்துக்காட்டில், fetchAndProcessData ஃபங்ஷன் ஒரு ஒத்திசைவற்ற ஜெனரேட்டர் ஆகும், இது பல URLகளிலிருந்து தரவைப் பெற்று முடிவுகளை வழங்குகிறது. main ஃபங்ஷன் for await...of லூப்பைப் பயன்படுத்தி ஜெனரேட்டரில் மறுசெய்கை செய்கிறது, இது தரவு கிடைக்கும்போது அதைச் செயலாக்க அனுமதிக்கிறது.

முடிவுரை

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர் ஆரோ ஃபங்ஷன்கள் இட்டரேட்டர்களை உருவாக்க ஒரு சக்திவாய்ந்த மற்றும் சுருக்கமான வழியை வழங்குகின்றன. அவற்றின் தொடரியல், நன்மைகள் மற்றும் பயன்பாட்டு வழக்குகளைப் புரிந்துகொள்வதன் மூலம், நீங்கள் அவற்றை மிகவும் திறமையான, வாசிக்கக்கூடிய மற்றும் பராமரிக்கக்கூடிய குறியீட்டை எழுதப் பயன்படுத்தலாம். நீங்கள் பெரிய தரவுத்தொகுப்புகளுடன் பணிபுரிந்தாலும், தனிப்பயன் இட்டரேட்டர்களைச் செயல்படுத்தினாலும், அல்லது ஒத்திசைவற்ற குறியீட்டை எளிதாக்கினாலும், ஜெனரேட்டர் ஆரோ ஃபங்ஷன்கள் உங்கள் ஜாவாஸ்கிரிப்ட் கருவித்தொகுப்பில் ஒரு மதிப்புமிக்க கருவியாக இருக்க முடியும்.