ஜாவாஉரைநிரலில் உருவாக்கிகளை பயன்படுத்துவதுக்குறித்து கற்றுக் கொள்வோம்

ஜாவாஉரைநிரல் ஆர்வலர்களே! – குறிமுறைவரிகளை எழுதிடுகின்ற திறன்களை மேம்ப்படுத்த தயாராக இருக்கின்றீர்களா ?ஆம்எனில் இன்றே, அதற்கான உருவாக்கிகளில் (Generators) மூழ்கிடுவோம் – ஜாவாஉரைநிரலில் இதுஒரு சிறப்பு வகையான செயலியெனகவலைப்பட வேண்டாம், இதுஒன்றும் ராக்கெட்டை பற்றி அறிந்துகொள்வதற்கான ராக்கெட்அறிவியல் அன்று வீணான விவாதங்களை விடுத்த நேரடியாக செயலுக்கு வருவோம்.
உருவாக்கிகள் (Generators) என்றால் என்ன?
எளிமையான சொற்களில் கூறுவதெனில், உருவாக்கிகள் (Generators)என்பவை தங்களின் செயலை இடைநிறுத்தம்செய்து மீண்டும் தொடங்கி வழக்கமாக செயல்படக்கூடிய செயலிகளாகும்.. தொடக்கத்தில் இருந்து இறுதி வரை இயங்கும் வழக்கமான செயலிகளைப் போலன்றி, உருவாக்கிகளில் (Generators) நமக்கு அதிகக் கட்டுப்பாட்டை வழங்குகின்றன.
எவ்வாறு? function* எனும்தொடரியல் , yield எனும் முக்கிய சொல்லின் மந்திரத்தைப் பயன்படுத்துவதன் மூலம். அவற்றை செயலில் காண்போம்!
முதன்முதலான உருவாக்கி(Generator) செயலிக்கான குறிமுறைவரிகளை எழுதுதல்
function* myFirstGenerator() {
yield “Hello ”;
yield “Generators are awesome!”;
yield “Goodbye ”;
}
// Let’s use it!
const gen = myFirstGenerator();
console.log(gen.next()); // { value: ‘Hello ’, done: false }
console.log(gen.next()); // { value: ‘Generators are awesome!’, done: false }
console.log(gen.next()); // { value: ‘Goodbye ’, done: false }
console.log(gen.next()); // { value: undefined, done: true }
இதில் என்ன நடக்கிறது?
yieldஎனும் முக்கியசொல்லானது இந்த செயலியில் ஒரு இடைநிறுத்த புள்ளியாக செயல்படுகிறது.
gen.next()க்கான ஒவ்வொரு அழைப்பும் செயலியை அடுத்த yield எனும் முக்கிய சொல்லிற்கு நகர்த்துகிறது.
மேலும்வேறு yield ஐஅறிந்துகொள்ள இயலாதபோது, ​​உருவாக்கி(Generator) {செயலானது செய்யப்பட்டது: உண்மை } என்ற தகவலைத் தருகின்றது.
நடைமுறை பயன்பாட்டு வழக்கங்ககள்
1. முடிவற்ற தொடர் எண்ணிற்கான உருவாக்கிகளில் (Generators)
எப்போதாவது நினைவகத்தை அழிக்காமல் முடிவற்ற எண்களை உருவாக்க விரும்புகின்றோமா? அவ்வாறான நிலையில் நமக்கு உருவாக்கிகள் (Generators) கைகொடுக்கின்றன!அதற்கான குறிமுறைவரிகள் பின்வருமாறு
function* infiniteNumbers() {
let num = 1;
while (true) {
yield num++;
}
}
const numbers = infiniteNumbers();
console.log(numbers.next().value); // 1
console.log(numbers.next().value); // 2
console.log(numbers.next().value); // 3
// … and so on
2. தரவு பெறுவதற்கான கட்டுப்படுத்தப்பட்ட மீள் செய்கை
தரவைத் துண்டுகளாகப் பெற வேண்டுமா அல்லது சோம்பேறியாக ஏதாவது பதிவேற்றம் செய்ய வேண்டுமா? நமக்காகவே உருவாக்கிகள் (Generators) உதவ தயாராக இருக்கின்றன அதற்கான குறிமுறைவரிகள் பின்வருமாறு:
function* fetchInChunks(data) {
for (let i = 0; i < data.length; i += 2) {
yield data.slice(i, i + 2);
}
}
const chunks = fetchInChunks([1, 2, 3, 4, 5, 6, 7, 8]);
console.log(chunks.next().value); // [1, 2]
console.log(chunks.next().value); // [3, 4]
console.log(chunks.next().value); // [5, 6]
உருவாக்கிகள் (Generators)பொறுப்புவழங்குவதில் வேடிக்கையாக செய்திடலாம்
yieldஎன்பதை பயன்படுத்தி உருவாக்கிகளானவை மற்ற உருவாக்கிகளை அழைக்கலாம்*. அவைகளை ஒன்றாகச் செயல்பட வைத்திடலாம்:
function* innerGenerator() {
yield “I’m the inner generator ”;
}
function* outerGenerator() {
yield “I’m the outer generator ”;
yield* innerGenerator();
yield “Back to the outer generator ”;
}
const gen = outerGenerator();
for (const value of gen) {
console.log(value);
}
இதன்வெளியீடு:
I’m the outer generator
I’m the inner generator
Back to the outer generator
உருவாக்கிகளை(Generators) ஏன் பயன்படுத்த வேண்டும்?
சோம்பேறிதனமான மதிப்பீடு: தேவைப்படும் போது மட்டுமே மதிப்புகளை உருவாக்கிடுக.
சிறந்த செயல்திறன்: எல்லா முடிவுகளையும் முன்கூட்டியே கணக்கிட வேண்டிய அவசியமில்லை.
ஒத்திசைவற்ற செயல்: ஒத்திசைவுடன் இணைக்கவும்/தூய்மையான ஒத்திசைவு குறிமுறைவரிகளுக்காக காத்திருந்திடுக.
தந்திரமானக் கேள்வி!
உருவாக்கி(Generator) எனும் செயலியானது ஒத்திசைவற்றதாக இருக்க முடியுமா? ஆம் எனில், அதை எவ்வாறுப் பயன்படுத்துவது?
குறிமுறைவரிகளில் முயற்சித்திடுக!
முடிவாக
உருவாக்கிகள்(Generators) முதலில் சற்று தந்திரமானதாகத் தோன்றலாம், ஆனால் சில பயிற்சிகள் மூலம், அவை ஜாவாஉரைநிரலின் கருவிகளின் களஞ்சியத்தில் சக்திவாய்ந்த கருவியாக மாறக்கூடும். எதனையும் சிறியதாகத் தொடங்கிடுக, அவைகளின் சாத்தியக்கூறுகளை ஆய்ந்திடுக, விரைவில் அவைகளை ஒரு சார்பு போல பயன்படுத்திடமுடியும்!
மகிழ்ச்சியான குறிமுறைவரிகளின் முயற்சிக்கு வாழ்த்துக்கள்!