Jassif Team Institution

JavaScript Generators

ஒரு JavaScript செயல்பாடு ஒரு மதிப்பை மட்டுமே திரும்பப் பெற முடியும்.

ஒரு JavaScript ஜெனரேட்டர் பல மதிப்புகளை ஒவ்வொன்றாகத் திரும்பப் பெற முடியும்.

ஒரு JavaScript ஜெனரேட்டர் தரவின் ஓட்டத்தை வழங்க முடியும்.

ஒரு JavaScript ஜெனரேட்டர் இடைநிறுத்தப்பட்டு மீண்டும் தொடரப்படலாம்.

Generator Functions

ஒரு ஜெனரேட்டர் செயல்பாடு function* தொடரியலைப் பயன்படுத்தி வரையறுக்கப்படுகிறது:

function* myGenerator() {}

அழைக்கப்படும் போது, ஒரு ஜெனரேட்டர் செயல்பாடு நேரடி மதிப்பை அல்ல, ஒரு ஜெனரேட்டர் பொருளைத் தரும்:

{value:1, done:false}

Generator Objects

ஒரு ஜெனரேட்டர் பொருள் ஜெனரேட்டர் செயல்பாட்டால் திரும்பப் பெறப்படுகிறது.

இது மீளக்கூடிய மற்றும் மீள்வி நெறிமுறைகள் இரண்டிற்கும் இணங்குகிறது, அதாவது இது for...of லூப்களைப் பயன்படுத்தி மீள்வு செய்யப்படலாம்.

Example

function* myStream() {
  // return {value:1, done:false}
  yield 1;

  // return {value:2, done:false}
  yield 2;

  // return {value:3, done:true}
  return 3;
}

// ஒரு ஜெனரேட்டரை உருவாக்கவும்
let myGenerator = myStream();

// ஜெனரேட்டர் மீது மீள்வு செய்யவும்
for (let value of myGenerator) {
  // code
}

The yield Keyword

yield முக்கிய சொல் செயல்பாட்டை இடைநிறுத்தி ஒரு மதிப்பை அழைப்பாளருக்குத் தரும்.

ஜெனரேட்டரின் நிலை பாதுகாக்கப்படுகிறது, மற்றும் next() அழைக்கப்படும் போது yield புள்ளியிலிருந்து மீண்டும் தொடரப்படலாம்.

ஜெனரேட்டர்கள் yield அழைப்புகளுக்கு இடையே அவற்றின் உள் நிலையை பராமரிக்கின்றன, அவை விட்ட இடத்திலிருந்து செயல்பாட்டைத் தொடர அனுமதிக்கின்றன.

Example

function* myStream() {
  // return {value:1, done:false}
  yield 1;

  // return {value:2, done:false}
  yield 2;

  // return {value:3, done:false}
  yield 3;
}

// ஒரு ஜெனரேட்டரை உருவாக்கவும்
let myGenerator = myStream();

// ஜெனரேட்டர் மீது மீள்வு செய்யவும்
for (let value of myGenerator) {
  // code
}

Generator Object Methods

ஒரு ஜெனரேட்டர் பொருள் மீளக்கூடிய மற்றும் மீள்வி நெறிமுறைகளுக்கு இணங்குகிறது.

இது for...of லூப்களுடன் மீள்வு செய்யப்படலாம்.

இதற்கு முறைகளும் உள்ளன:

The next() Method

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

இது ஒரு மதிப்பு மற்றும் ஒரு பூலியன் கொண்ட ஒரு பொருளைத் தரும், ஜெனரேட்டர் முடிந்துள்ளதா என்பதைக் குறிக்கிறது:

{ value: value, done: true|false}

Custom Iterators

ஜெனரேட்டர்கள் சிக்கலான தரவு கட்டமைப்புகள் அல்லது வரிசைகளுக்கான தனிப்பயன் மீள்விகளை உருவாக்குவதை எளிதாக்குகின்றன.

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

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

Example

function* numberGenerator() {
  let number = 1;
  while (true) {
    yield number;
    number++;
  }
}

// ஜெனரேட்டரை உருவாக்கவும்
const gen = numberGenerator();

// முதல் 5 எண்களைப் பெறவும்
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // 3
console.log(gen.next().value); // 4
console.log(gen.next().value); // 5

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

JavaScript Generators பயிற்சி

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

function* simpleGenerator() {
  yield 'A';
  yield 'B';
  yield 'C';
  return 'D';
}

const gen = simpleGenerator();

பின்வரும் குறியீட்டை இயக்கிய பின் result மாறியின் மதிப்பு என்ன?

let result = '';
for (let value of gen) {
  result += value;
}