ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்கள்: இட்டரேட்டர் புரோட்டோகால் செயலாக்கத்தில் தேர்ச்சி பெறுதல்

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

இட்டரேட்டர்கள் மற்றும் இட்டரேட்டர் புரோட்டோகாலைப் புரிந்துகொள்ளுதல்

ஜெனரேட்டர்களுக்குள் செல்வதற்கு முன், இட்டரேட்டர்கள் மற்றும் இட்டரேட்டர் புரோட்டோகால் பற்றிய கருத்தைப் புரிந்துகொள்வது முக்கியம். ஒரு இட்டரேட்டர் என்பது ஒரு வரிசையை வரையறுக்கும் ஒரு ஆப்ஜெக்ட் ஆகும், மேலும், முடிவடையும் போது, சாத்தியமான ஒரு ரிட்டர்ன் மதிப்பைக் கொண்டிருக்கும். இன்னும் குறிப்பாக, ஒரு இட்டரேட்டர் என்பது next() முறையைக் கொண்ட எந்தவொரு ஆப்ஜெக்ட் ஆகும், இது இரண்டு பண்புகளுடன் ஒரு ஆப்ஜெக்ட்டை வழங்குகிறது:

• value: வரிசையில் அடுத்த மதிப்பு.
• done: இட்டரேட்டர் முடிந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு பூலியன். true என்பது வரிசையின் முடிவைக் குறிக்கிறது.

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

அரேக்கள், ஸ்டிரிங்ஸ், மேப்ஸ் மற்றும் செட்ஸ் போன்ற பல உள்ளமைக்கப்பட்ட ஜாவாஸ்கிரிப்ட் தரவுக் கட்டமைப்புகள், இயல்பாகவே இட்டரேபிளாக உள்ளன, ஏனெனில் அவை இட்டரேட்டர் புரோட்டோகாலை செயல்படுத்துகின்றன. இது for...of லூப்களைப் பயன்படுத்தி அவற்றின் கூறுகளை எளிதாக லூப் செய்ய அனுமதிக்கிறது.

எடுத்துக்காட்டு: ஒரு வரிசையை இட்டரேட் செய்தல்

            const myArray = [1, 2, 3];

const iterator = myArray[Symbol.iterator]();

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 }

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

            

              
                Copy
              
            
          

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

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

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

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

எடுத்துக்காட்டு: ஒரு எளிய ஜெனரேட்டர்

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

const gen = numberGenerator();

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

            

              
                Copy
              
            
          

ஜெனரேட்டர்கள் இட்டரேட்டர் புரோட்டோகாலை எவ்வாறு செயல்படுத்துகின்றன

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

முக்கியமாக, ஜெனரேட்டர் ஆப்ஜெக்ட்களும் தாமாகவே இட்டரேபிளாக உள்ளன! அவற்றிடம் Symbol.iterator முறை உள்ளது, இது வெறுமனே ஜெனரேட்டர் ஆப்ஜெக்ட்டையே வழங்குகிறது. இது ஜெனரேட்டர்களை for...of லூப்கள் மற்றும் இட்டரேபிள் ஆப்ஜெக்ட்களை எதிர்பார்க்கும் பிற கட்டமைப்புகளுடன் பயன்படுத்துவதை மிகவும் எளிதாக்குகிறது.

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்களின் நடைமுறைப் பயன்பாட்டு நிகழ்வுகள்

ஜெனரேட்டர்கள் பல்துறை திறன் கொண்டவை மற்றும் பரந்த அளவிலான சூழ்நிலைகளில் பயன்படுத்தப்படலாம். இங்கே சில பொதுவான பயன்பாட்டு நிகழ்வுகள்:

1. தனிப்பயன் இட்டரேட்டர்கள்

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

எடுத்துக்காட்டு: பைனரி ட்ரீயை இட்டரேட் செய்தல்

            class Node {
 constructor(value) {
 this.value = value;
 this.left = null;
 this.right = null;
 }
}

class BinaryTree {
 constructor(root) {
 this.root = root;
 }

 *[Symbol.iterator]() {
 function* inOrderTraversal(node) {
 if (node) {
 yield* inOrderTraversal(node.left); // recursively yield values from the left subtree
 yield node.value;
 yield* inOrderTraversal(node.right); // recursively yield values from the right subtree
 }
 }
 yield* inOrderTraversal(this.root);
 }
}

// Create a sample binary tree
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

const tree = new BinaryTree(root);

// Iterate over the tree using the custom iterator
for (const value of tree) {
 console.log(value); // Output: 4, 2, 5, 1, 3
}

            

              
                Copy
              
            
          

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

2. முடிவற்ற வரிசைகள்

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

எடுத்துக்காட்டு: ஃபிபோனாச்சி எண்களை உருவாக்குதல்

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

const fib = fibonacciGenerator();

console.log(fib.next().value); // Output: 0
console.log(fib.next().value); // Output: 1
console.log(fib.next().value); // Output: 1
console.log(fib.next().value); // Output: 2
console.log(fib.next().value); // Output: 3
// ... and so on

            

              
                Copy
              
            
          

fibonacciGenerator ஃபங்ஷன் ஃபிபோனாச்சி எண்களின் முடிவற்ற வரிசையை உருவாக்குகிறது. while (true) லூப் ஜெனரேட்டர் காலவரையின்றி மதிப்புகளை தொடர்ந்து உற்பத்தி செய்வதை உறுதி செய்கிறது. மதிப்புகள் தேவைக்கேற்ப உருவாக்கப்படுவதால், இந்த ஜெனரேட்டர் முடிவற்ற நினைவகத்தை உட்கொள்ளாமல் ஒரு முடிவற்ற வரிசையைக் குறிக்க முடியும்.

3. ஒத்திசைவற்ற நிரலாக்கம் (Asynchronous Programming)

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

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

            function fetchData(url) {
 return new Promise((resolve, reject) => {
 fetch(url)
 .then(response => response.json())
 .then(data => resolve(data))
 .catch(error => reject(error));
 });
}

function* dataFetcher() {
 try {
 const user = yield fetchData('https://jsonplaceholder.typicode.com/users/1');
 console.log('User:', user);
 const posts = yield fetchData(`https://jsonplaceholder.typicode.com/posts?userId=${user.id}`);
 console.log('Posts:', posts);
 } catch (error) {
 console.error('Error fetching data:', error);
 }
}

function runGenerator(generator) {
 const iterator = generator();

 function iterate(result) {
 if (result.done) return;

 const promise = result.value;

 promise
 .then(value => iterate(iterator.next(value)))
 .catch(error => iterator.throw(error));
 }

 iterate(iterator.next());
}

runGenerator(dataFetcher);

            

              
                Copy
              
            
          

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

நவீன ஒத்திசைவற்ற ஜாவாஸ்கிரிப்டுக்கு `async/await` பெரும்பாலும் விரும்பப்பட்டாலும், கடந்த காலத்தில் (மற்றும் சில சமயங்களில் இப்போதும்) ஒத்திசைவற்ற கட்டுப்பாட்டு ஓட்டத்திற்காக ஜெனரேட்டர்கள் எவ்வாறு பயன்படுத்தப்பட்டன என்பதைப் புரிந்துகொள்வது மொழியின் பரிணாம வளர்ச்சியைப் பற்றிய மதிப்புமிக்க நுண்ணறிவை வழங்குகிறது.

4. தரவு ஸ்ட்ரீமிங் மற்றும் செயலாக்கம்

ஜெனரேட்டர்கள் பெரிய தரவுத்தொகுப்புகள் அல்லது தரவு ஸ்ட்ரீம்களை நினைவக-திறமையான முறையில் செயலாக்க பயன்படுத்தப்படலாம். தரவுத் துண்டுகளை படிப்படியாக வழங்குவதன் மூலம், முழு தரவுத்தொகுப்பையும் ஒரே நேரத்தில் நினைவகத்தில் ஏற்றுவதைத் தவிர்க்கலாம்.

எடுத்துக்காட்டு: ஒரு பெரிய CSV கோப்பைச் செயலாக்குதல்

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

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

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

 for await (const line of rl) {
 // Process each line (e.g., parse CSV data)
 const data = line.split(',');
 yield data;
 }
}

async function main() {
 const csvGenerator = processCSV('large_data.csv');

 for await (const row of csvGenerator) {
 console.log('Row:', row);
 // Perform operations on each row
 }
}

main();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு ஒரு பெரிய CSV கோப்பை வரி வரியாகப் படிக்க fs மற்றும் readline மாட்யூல்களைப் பயன்படுத்துகிறது. processCSV ஜெனரேட்டர் ஃபங்ஷன் CSV கோப்பின் ஒவ்வொரு வரிசையையும் ஒரு அரேவாக வழங்குகிறது. async/await தொடரியல் கோப்பு வரிகளை ஒத்திசைவற்ற முறையில் இட்டரேட் செய்யப் பயன்படுகிறது, இது முக்கிய த்ரெட்டைத் தடுக்காமல் கோப்பு திறமையாக செயலாக்கப்படுவதை உறுதி செய்கிறது. இங்கு முக்கியமானது, முழு CSV யையும் முதலில் நினைவகத்தில் ஏற்ற முயற்சிப்பதற்குப் பதிலாக, ஒவ்வொரு வரிசையும் *படிக்கப்படும்போதே* செயலாக்குவதாகும்.

மேம்பட்ட ஜெனரேட்டர் நுட்பங்கள்

1. `yield*` உடன் ஜெனரேட்டர் கலவை

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

எடுத்துக்காட்டு: பல ஜெனரேட்டர்களை இணைத்தல்

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

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

function* combinedGenerator() {
 yield* generator1();
 yield* generator2();
 yield 5;
}

const combined = combinedGenerator();

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

            

              
                Copy
              
            
          

combinedGenerator ஃபங்ஷன் generator1 மற்றும் generator2 இலிருந்து மதிப்புகளை, கூடுதலாக 5 என்ற மதிப்புடன் இணைக்கிறது. yield* முக்கிய சொல் உள் இட்டரேட்டர்களை திறம்பட சமன் செய்து, ஒற்றை வரிசை மதிப்புகளை உருவாக்குகிறது.

2. `next()` உடன் ஜெனரேட்டர்களுக்கு மதிப்புகளை அனுப்புதல்

ஒரு ஜெனரேட்டர் ஆப்ஜெக்ட்டின் next() முறை ஒரு ஆர்குமென்ட்டை ஏற்க முடியும், இது பின்னர் ஜெனரேட்டர் ஃபங்ஷனுக்குள் yield வெளிப்பாட்டின் மதிப்பாக அனுப்பப்படுகிறது. இது ஜெனரேட்டருக்கும் அழைப்பாளருக்கும் இடையே இருவழித் தொடர்பை அனுமதிக்கிறது.

எடுத்துக்காட்டு: ஊடாடும் ஜெனரேட்டர்

            function* interactiveGenerator() {
 const input1 = yield 'What is your name?';
 console.log('Received name:', input1);

 const input2 = yield 'What is your favorite color?';
 console.log('Received color:', input2);

 return `Hello, ${input1}! Your favorite color is ${input2}.`;
}

const interactive = interactiveGenerator();

console.log(interactive.next().value); // Output: What is your name?
console.log(interactive.next('Alice').value); // Output: Received name: Alice
 // Output: What is your favorite color?
console.log(interactive.next('Blue').value); // Output: Received color: Blue
 // Output: Hello, Alice! Your favorite color is Blue.
console.log(interactive.next()); // Output: { value: Hello, Alice! Your favorite color is Blue., done: true }

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், interactiveGenerator ஃபங்ஷன் பயனரிடம் அவர்களின் பெயர் மற்றும் பிடித்த நிறத்தைக் கேட்கிறது. பயனரின் உள்ளீட்டை ஜெனரேட்டருக்குத் திருப்பி அனுப்ப next() முறை பயன்படுத்தப்படுகிறது, இது பின்னர் ஒரு தனிப்பயனாக்கப்பட்ட வாழ்த்தை உருவாக்க அதைப் பயன்படுத்துகிறது. இது வெளிப்புற உள்ளீட்டிற்கு பதிலளிக்கும் ஊடாடும் நிரல்களை உருவாக்க ஜெனரேட்டர்கள் எவ்வாறு பயன்படுத்தப்படலாம் என்பதை விளக்குகிறது.

3. `throw()` உடன் பிழை கையாளுதல்

ஒரு ஜெனரேட்டர் ஆப்ஜெக்ட்டின் throw() முறை ஜெனரேட்டர் ஃபங்ஷனுக்குள் ஒரு விதிவிலக்கை வீசப் பயன்படுத்தப்படலாம். இது ஜெனரேட்டரின் சூழலுக்குள் பிழை கையாளுதல் மற்றும் சுத்தம் செய்ய அனுமதிக்கிறது.

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

            function* errorGenerator() {
 try {
 yield 'Starting...';
 throw new Error('Something went wrong!');
 yield 'This will not be executed.';
 } catch (error) {
 console.error('Caught error:', error.message);
 yield 'Recovering...';
 }
 yield 'Finished.';
}

const errorGen = errorGenerator();

console.log(errorGen.next().value); // Output: Starting...
console.log(errorGen.next().value); // Output: Caught error: Something went wrong!
 // Output: Recovering...
console.log(errorGen.next().value); // Output: Finished.
console.log(errorGen.next().value); // Output: undefined

            

              
                Copy
              
            
          

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

4. `return()` உடன் மதிப்புகளைத் திருப்புதல்

ஒரு ஜெனரேட்டர் ஆப்ஜெக்ட்டின் return() முறை ஜெனரேட்டரை முன்கூட்டியே முடித்து ஒரு குறிப்பிட்ட மதிப்பைத் திருப்பப் பயன்படுத்தப்படலாம். இது வளங்களை சுத்தம் செய்ய அல்லது ஒரு வரிசையின் முடிவை சமிக்ஞை செய்ய பயனுள்ளதாக இருக்கும்.

எடுத்துக்காட்டு: ஒரு ஜெனரேட்டரை முன்கூட்டியே முடித்தல்

            function* earlyExitGenerator() {
 yield 1;
 yield 2;
 return 'Exiting early!';
 yield 3; // This will not be executed
}

const exitGen = earlyExitGenerator();

console.log(exitGen.next().value); // Output: 1
console.log(exitGen.next().value); // Output: 2
console.log(exitGen.next().value); // Output: Exiting early!
console.log(exitGen.next().value); // Output: undefined
console.log(exitGen.next().done); // Output: true

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், earlyExitGenerator ஃபங்ஷன் return அறிக்கையை சந்திக்கும்போது முன்கூட்டியே முடிகிறது. return() முறை குறிப்பிட்ட மதிப்பைத் திருப்பி, done பண்பை true ஆக அமைக்கிறது, இது ஜெனரேட்டர் முடிந்துவிட்டது என்பதைக் குறிக்கிறது.

ஜாவாஸ்கிரிப்ட் ஜெனரேட்டர்களைப் பயன்படுத்துவதன் நன்மைகள்

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

முடிவுரை

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

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