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

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

அசின்க் இட்டரேட்டர்கள் என்றால் என்ன?

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

முக்கிய கருத்துக்கள்:

• அசின்க் இட்டரபிள் (Async Iterable): `Symbol.asyncIterator` என்ற பெயரில் ஒரு முறையைக் கொண்ட ஒரு பொருள், இது ஒரு அசின்க் இட்டரேட்டரை வழங்குகிறது.
• அசின்க் இட்டரேட்டர் (Async Iterator): ஒரு `next()` முறையை வரையறுக்கும் ஒரு பொருள், இது வழக்கமான இட்டரேட்டர்களைப் போலவே `value` மற்றும் `done` பண்புகளுடன் ஒரு பொருளுக்குத் தீர்க்கும் ஒரு ப்ராமிஸை வழங்குகிறது.
• `for await...of` லூப்: அசின்க் இட்டரபிள்களை மீண்டும் மீண்டும் செய்வதற்கு எளிதாக்கும் ஒரு மொழி கட்டமைப்பு.

ஸ்ட்ரீம் செயலாக்கத்திற்கு அசின்க் இட்டரேட்டர்களை ஏன் பயன்படுத்த வேண்டும்?

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

• நினைவகத் திறன்: முழு தரவுத்தொகுப்பையும் ஒரே நேரத்தில் நினைவகத்தில் ஏற்றுவதற்குப் பதிலாக, தரவுகளைத் துண்டுகளாகச் செயலாக்குதல்.
• பதிலளிக்கும் தன்மை: தரவுகளை அசின்க்ரோனஸாக கையாள்வதன் மூலம் முக்கிய திரெட்டைத் தடுப்பதைத் தவிர்த்தல்.
• இணைக்கும் தன்மை: சிக்கலான தரவு பைப்லைன்களை உருவாக்க பல அசின்க்ரோனஸ் செயல்பாடுகளை ஒன்றாக இணைத்தல்.
• பிழை கையாளுதல்: அசின்க்ரோனஸ் செயல்பாடுகளுக்கு வலுவான பிழை கையாளுதல் வழிமுறைகளை செயல்படுத்துதல்.
• பின்அழுத்த மேலாண்மை (Backpressure Management): நுகர்வோரை அதிகமாகச் சுமைப்படுத்தாமல் இருக்க தரவு நுகரப்படும் விகிதத்தைக் கட்டுப்படுத்துதல்.

அசின்க் இட்டரேட்டர்களை உருவாக்குதல்

ஜாவாஸ்கிரிப்டில் அசின்க் இட்டரேட்டர்களை உருவாக்க பல வழிகள் உள்ளன:

1. அசின்க் இட்டரேட்டர் நெறிமுறையை கைமுறையாக செயல்படுத்துதல்

இதில் `Symbol.asyncIterator` முறையுடன் ஒரு பொருளை வரையறுப்பது அடங்கும், அது ஒரு `next()` முறையுடன் ஒரு பொருளை வழங்குகிறது. `next()` முறை தொடரின் அடுத்த மதிப்புடன் தீர்க்கப்படும் ஒரு ப்ராமிஸை வழங்க வேண்டும், அல்லது தொடர் முடிந்ததும் `{ value: undefined, done: true }` உடன் தீர்க்கப்படும் ஒரு ப்ராமிஸை வழங்க வேண்டும்.

class Counter {
 constructor(limit) {
 this.limit = limit;
 this.count = 0;
 }

 async *[Symbol.asyncIterator]() {
 while (this.count < this.limit) {
 await new Promise(resolve => setTimeout(resolve, 500)); // அசின்க் தாமதத்தை உருவகப்படுத்துங்கள்
 yield this.count++;
 }
 }
}

async function main() {
 const counter = new Counter(5);
 for await (const value of counter) {
 console.log(value); // வெளியீடு: 0, 1, 2, 3, 4 (ஒவ்வொரு மதிப்பிற்கும் இடையில் 500ms தாமதத்துடன்)
 }
 console.log("Done!");
}

main();

2. அசின்க் ஜெனரேட்டர் செயல்பாடுகளைப் பயன்படுத்துதல்

அசின்க் ஜெனரேட்டர் செயல்பாடுகள் அசின்க் இட்டரேட்டர்களை உருவாக்குவதற்கு மிகவும் சுருக்கமான தொடரியலை வழங்குகின்றன. அவை `async function*` தொடரியலைப் பயன்படுத்தி வரையறுக்கப்படுகின்றன மற்றும் மதிப்புகளை அசின்க்ரோனஸாக உருவாக்க `yield` என்ற முக்கிய சொல்லைப் பயன்படுத்துகின்றன.

async function* generateSequence(start, end) {
 for (let i = start; i <= end; i++) {
 await new Promise(resolve => setTimeout(resolve, 500)); // அசின்க் தாமதத்தை உருவகப்படுத்துங்கள்
 yield i;
 }
}

async function main() {
 const sequence = generateSequence(1, 3);
 for await (const value of sequence) {
 console.log(value); // வெளியீடு: 1, 2, 3 (ஒவ்வொரு மதிப்பிற்கும் இடையில் 500ms தாமதத்துடன்)
 }
 console.log("Done!");
}

main();

3. ஏற்கனவே உள்ள அசின்க் இட்டரபிள்களை மாற்றுதல்

`map`, `filter`, மற்றும் `reduce` போன்ற செயல்பாடுகளைப் பயன்படுத்தி ஏற்கனவே உள்ள அசின்க் இட்டரபிள்களை நீங்கள் மாற்றலாம். இந்த செயல்பாடுகளை அசின்க் ஜெனரேட்டர் செயல்பாடுகளைப் பயன்படுத்தி செயல்படுத்தலாம், இது அசல் இட்டரபிளில் உள்ள தரவைச் செயலாக்கும் புதிய அசின்க் இட்டரபிள்களை உருவாக்கும்.

async function* map(iterable, transform) {
 for await (const value of iterable) {
 yield await transform(value);
 }
}

async function* filter(iterable, predicate) {
 for await (const value of iterable) {
 if (await predicate(value)) {
 yield value;
 }
 }
}

async function main() {
 async function* numbers() {
 yield 1;
 yield 2;
 yield 3;
 }

 const doubled = map(numbers(), async (x) => x * 2);
 const even = filter(doubled, async (x) => x % 2 === 0);

 for await (const value of even) {
 console.log(value); // வெளியீடு: 2, 4, 6
 }
 console.log("Done!");
}

main();

பொதுவான அசின்க் இட்டரேட்டர் பேட்டர்ன்கள்

திறமையான ஸ்ட்ரீம் செயலாக்கத்திற்காக அசின்க் இட்டரேட்டர்களின் சக்தியைப் பயன்படுத்தும் பல பொதுவான பேட்டர்ன்கள் உள்ளன:

1. பஃபரிங் (Buffering)

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

async function* buffer(iterable, bufferSize) {
 let buffer = [];
 for await (const value of iterable) {
 buffer.push(value);
 if (buffer.length === bufferSize) {
 yield buffer;
 buffer = [];
 }
 }
 if (buffer.length > 0) {
 yield buffer;
 }
}

async function main() {
 async function* numbers() {
 yield 1;
 yield 2;
 yield 3;
 yield 4;
 yield 5;
 }

 const buffered = buffer(numbers(), 2);

 for await (const value of buffered) {
 console.log(value); // வெளியீடு: [1, 2], [3, 4], [5]
 }
 console.log("Done!");
}

main();

2. த்ராட்லிங் (Throttling)

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

async function* throttle(iterable, delay) {
 for await (const value of iterable) {
 yield value;
 await new Promise(resolve => setTimeout(resolve, delay));
 }
}

async function main() {
 async function* numbers() {
 yield 1;
 yield 2;
 yield 3;
 yield 4;
 yield 5;
 }

 const throttled = throttle(numbers(), 1000); // 1 வினாடி தாமதம்

 for await (const value of throttled) {
 console.log(value); // வெளியீடு: 1, 2, 3, 4, 5 (ஒவ்வொரு மதிப்பிற்கும் இடையில் 1-வினாடி தாமதத்துடன்)
 }
 console.log("Done!");
}

main();

3. டிபவுன்சிங் (Debouncing)

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

async function* debounce(iterable, delay) {
 let timeoutId;
 let lastValue;
 for await (const value of iterable) {
 lastValue = value;
 clearTimeout(timeoutId);
 timeoutId = setTimeout(() => {
 yield lastValue;
 }, delay);
 }
 if (timeoutId) {
 clearTimeout(timeoutId);
 yield lastValue; // கடைசி மதிப்பைச் செயலாக்கவும்
 }
}

async function main() {
 async function* input() {
 yield 'a';
 await new Promise(resolve => setTimeout(resolve, 200));
 yield 'ab';
 await new Promise(resolve => setTimeout(resolve, 100));
 yield 'abc';
 await new Promise(resolve => setTimeout(resolve, 500));
 yield 'abcd';
 }

 const debounced = debounce(input(), 300);

 for await (const value of debounced) {
 console.log(value); // வெளியீடு: abcd
 }
 console.log("Done!");
}

main();

4. பிழை கையாளுதல்

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

async function* processData(iterable) {
 for await (const value of iterable) {
 try {
 // செயலாக்கத்தின் போது ஏற்படக்கூடிய பிழையை உருவகப்படுத்துங்கள்
 if (value === 3) {
 throw new Error("Processing error!");
 }
 yield value * 2;
 } catch (error) {
 console.error("Error processing value:", value, error);
 yield null; // அல்லது பிழையை வேறு வழியில் கையாளவும்
 }
 }
}

async function main() {
 async function* numbers() {
 yield 1;
 yield 2;
 yield 3;
 yield 4;
 yield 5;
 }

 const processed = processData(numbers());

 for await (const value of processed) {
 console.log(value); // வெளியீடு: 2, 4, null, 8, 10
 }
 console.log("Done!");
}

main();

நிஜ உலகப் பயன்பாடுகள்

அசின்க் இட்டரேட்டர் பேட்டர்ன்கள் பல்வேறு நிஜ உலகச் சூழ்நிலைகளில் மதிப்புமிக்கவை:

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

அசின்க் இட்டரேட்டர்கள் மற்றும் அப்சர்வேபிள்கள் (RxJS) ஒப்பீடு

அசின்க் இட்டரேட்டர்கள் அசின்க்ரோனஸ் ஸ்ட்ரீம்களைக் கையாள ஒரு நேட்டிவ் வழியை வழங்கினாலும், RxJS (Reactive Extensions for JavaScript) போன்ற லைப்ரரிகள் ரியாக்டிவ் புரோகிராமிங்கிற்கு மேலும் மேம்பட்ட அம்சங்களை வழங்குகின்றன. இங்கே ஒரு ஒப்பீடு:

அம்சம்	அசின்க் இட்டரேட்டர்கள்	RxJS அப்சர்வேபிள்கள்
நேட்டிவ் ஆதரவு	ஆம் (ES2018+)	இல்லை (RxJS லைப்ரரி தேவை)
ஆபரேட்டர்கள்	வரையறுக்கப்பட்டவை (தனிப்பயன் செயலாக்கங்கள் தேவை)	விரிவானவை (வடிகட்டுதல், மேப்பிங், இணைத்தல் போன்றவற்றிற்கான உள்ளமைக்கப்பட்ட ஆபரேட்டர்கள்)
பின்அழுத்தம் (Backpressure)	அடிப்படையானது (கைமுறையாக செயல்படுத்தலாம்)	மேம்பட்டது (பஃபரிங், டிராப்பிங், மற்றும் த்ராட்லிங் போன்ற பின்அழுத்தத்தைக் கையாள்வதற்கான உத்திகள்)
பிழை கையாளுதல்	கைமுறை (Try/catch பிளாக்குகள்)	உள்ளமைக்கப்பட்டவை (பிழை கையாளுதல் ஆபரேட்டர்கள்)
ரத்து செய்தல்	கைமுறை (தனிப்பயன் தர்க்கம் தேவை)	உள்ளமைக்கப்பட்டவை (சந்தா மேலாண்மை மற்றும் ரத்து செய்தல்)
கற்றல் வளைவு	குறைந்தது (எளிமையான கருத்து)	அதிகமானது (மேலும் சிக்கலான கருத்துக்கள் மற்றும் ஏபிஐ)

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

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

அசின்க் இட்டரேட்டர்களுடன் பணிபுரியும் போது, பின்வரும் சிறந்த நடைமுறைகளைக் கருத்தில் கொள்ளுங்கள்:

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

முடிவுரை

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

மேலும் ஆராய

• MDN வலை ஆவணங்கள்: for await...of
• நோட்.ஜேஎஸ் ஸ்ட்ரீம்ஸ் ஏபிஐ: Node.js Stream
• RxJS: Reactive Extensions for JavaScript