செயல்திறனில் ஜாவாஸ்கிரிப்டின் அடுத்த பாய்ச்சல்: இட்டரேட்டர் ஹெல்பர் ஸ்ட்ரீம் ஃபியூஷன் பற்றிய ஒரு ஆழமான பார்வை

மென்பொருள் மேம்பாட்டு உலகில், செயல்திறனுக்கான தேடல் ஒரு தொடர்ச்சியான பயணம். ஜாவாஸ்கிரிப்ட் டெவலப்பர்களுக்கு, .map(), .filter(), மற்றும் .reduce() போன்ற அரே மெத்தட்களை ஒன்றிணைப்பது தரவு கையாளுதலுக்கான ஒரு பொதுவான மற்றும் நேர்த்தியான முறையாகும். இந்த சரளமான API படிக்க எளிதாகவும், வெளிப்படையாகவும் இருந்தாலும், இது ஒரு குறிப்பிடத்தக்க செயல்திறன் தடையை மறைக்கிறது: இடைநிலை அரேக்களை உருவாக்குவது. சங்கிலியின் ஒவ்வொரு படியும் ஒரு புதிய அரேவை உருவாக்குகிறது, இது நினைவகம் மற்றும் CPU சுழற்சிகளைப் பயன்படுத்துகிறது. பெரிய தரவுத்தொகுப்புகளுக்கு, இது ஒரு செயல்திறன் பேரழிவாக இருக்கலாம்.

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

பாரம்பரிய சங்கிலித் தொடரின் சிக்கல்: இடைநிலை அரேக்களின் கதை

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

வழக்கமான அணுகுமுறை

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

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ...]; // மிக நீண்ட வரிசை என கற்பனை செய்யவும்

const result = numbers .filter(n => n % 2 === 0) // படி 1: இரட்டை எண்களுக்கு வடிகட்டவும் .map(n => n * 2) // படி 2: அவற்றை இரட்டிப்பாக்கவும் .slice(0, 5); // படி 3: முதல் ஐந்தை எடுக்கவும்

இந்த குறியீடு hoàn hảo வாசிக்கக்கூடியது, ஆனால் numbers மில்லியன்கணக்கான கூறுகளைக் கொண்டிருந்தால், ஜாவாஸ்கிரிப்ட் இயந்திரம் திரைக்குப் பின்னால் என்ன செய்கிறது என்பதைப் பார்ப்போம்.

1. சுழற்சி 1 (.filter()): இயந்திரம் முழு numbers அரே வழியாகவும் சுழல்கிறது. இது நினைவகத்தில் ஒரு புதிய இடைநிலை அரேவை உருவாக்குகிறது, அதை evenNumbers என்று அழைப்போம், இது சோதனையில் தேர்ச்சி பெறும் அனைத்து எண்களையும் கொண்டிருக்கும். numbers ஒரு மில்லியன் கூறுகளைக் கொண்டிருந்தால், இது தோராயமாக 500,000 கூறுகளின் வரிசையாக இருக்கலாம்.
2. சுழற்சி 2 (.map()): இயந்திரம் இப்போது முழு evenNumbers அரே வழியாகவும் சுழல்கிறது. இது இரண்டாவது இடைநிலை அரேவை உருவாக்குகிறது, அதை doubledNumbers என்று அழைப்போம், இது மேப்பிங் செயல்பாட்டின் முடிவைச் சேமிக்கும். இது மற்றொரு 500,000 கூறுகளின் வரிசையாகும்.
3. சுழற்சி 3 (.slice()): இறுதியாக, இயந்திரம் doubledNumbers-லிருந்து முதல் ஐந்து கூறுகளை எடுத்து மூன்றாவது, இறுதி அரேவை உருவாக்குகிறது.

மறைக்கப்பட்ட செலவுகள்

இந்த செயல்முறை பல முக்கியமான செயல்திறன் சிக்கல்களை வெளிப்படுத்துகிறது:

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

இதுதான் இட்டரேட்டர் ஹெல்பர்கள் மற்றும் ஸ்ட்ரீம் ஃபியூஷன் தீர்க்க வடிவமைக்கப்பட்ட அடிப்படைப் பிரச்சனை.

இட்டரேட்டர் ஹெல்பர்களை அறிமுகப்படுத்துதல்: தரவு செயலாக்கத்திற்கான ஒரு புதிய முன்னுதாரணம்

இட்டரேட்டர் ஹெல்பர்ஸ் முன்மொழிவு, பழக்கமான மெத்தட்களின் தொகுப்பை நேரடியாக Iterator.prototype-க்கு சேர்க்கிறது. இதன் பொருள், ஒரு இட்டரேட்டராக இருக்கும் எந்தவொரு பொருளும் (ஜெனரேட்டர்கள் மற்றும் Array.prototype.values() போன்ற மெத்தட்களின் முடிவுகள் உட்பட) இந்த சக்திவாய்ந்த புதிய கருவிகளுக்கான அணுகலைப் பெறுகிறது.

சில முக்கிய மெத்தட்கள் பின்வருமாறு:

• .map(mapperFn)
• .filter(filterFn)
• .take(limit)
• .drop(limit)
• .flatMap(mapperFn)
• .reduce(reducerFn, initialValue)
• .toArray()
• .forEach(fn)
• .some(fn)
• .every(fn)
• .find(fn)

இந்த புதிய ஹெல்பர்களைப் பயன்படுத்தி நமது முந்தைய உதாரணத்தை மீண்டும் எழுதுவோம்:

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ...];

const result = numbers.values() // 1. அரேவிலிருந்து ஒரு இட்டரேட்டரைப் பெறவும் .filter(n => n % 2 === 0) // 2. ஒரு ஃபில்டர் இட்டரேட்டரை உருவாக்கவும் .map(n => n * 2) // 3. ஒரு மேப் இட்டரேட்டரை உருவாக்கவும் .take(5) // 4. ஒரு டேக் இட்டரேட்டரை உருவாக்கவும் .toArray(); // 5. சங்கிலியை இயக்கி முடிவுகளை சேகரிக்கவும்

முதல் பார்வையில், குறியீடு குறிப்பிடத்தக்க வகையில் ஒத்ததாகத் தெரிகிறது. முக்கிய வேறுபாடு தொடக்கப் புள்ளி—numbers.values()—இது அரேவையே தருவதற்குப் பதிலாக ஒரு இட்டரேட்டரைத் தருகிறது, மற்றும் இறுதி செயல்பாடு—.toArray()—இது இறுதி முடிவை உருவாக்க இட்டரேட்டரைப் பயன்படுத்துகிறது. உண்மையான மாயம், இருப்பினும், இந்த இரண்டு புள்ளிகளுக்கு இடையில் என்ன நடக்கிறது என்பதில் உள்ளது.

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

ஸ்ட்ரீம் ஃபியூஷனின் மாயம்: ஒரு நேரத்தில் ஒரு தனிமத்தை செயலாக்குதல்

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

அசெம்பிளி லைன் ஒப்பீடு

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

• அறை 1 (வடிகட்டுதல்): அனைத்து மூலப்பொருட்களும் (முழு அரே) கொண்டுவரப்படுகின்றன. தொழிலாளர்கள் கெட்டவற்றை வடிகட்டுகிறார்கள். நல்லவை அனைத்தும் ஒரு பெரிய தொட்டியில் (முதல் இடைநிலை அரே) வைக்கப்படுகின்றன.
• அறை 2 (மேப்பிங்): நல்ல பொருட்களின் முழு தொட்டியும் அடுத்த அறைக்கு நகர்த்தப்படுகிறது. இங்கே, தொழிலாளர்கள் ஒவ்வொரு பொருளையும் மாற்றியமைக்கிறார்கள். மாற்றியமைக்கப்பட்ட பொருட்கள் மற்றொரு பெரிய தொட்டியில் (இரண்டாவது இடைநிலை அரே) வைக்கப்படுகின்றன.
• அறை 3 (எடுத்தல்): இரண்டாவது தொட்டி இறுதி அறைக்கு நகர்த்தப்படுகிறது, அங்கு ஒரு தொழிலாளி வெறுமனே முதல் ஐந்து பொருட்களை மேலிருந்து எடுத்து மீதமுள்ளவற்றை நிராகரிக்கிறார்.

இந்த செயல்முறை போக்குவரத்து (நினைவக ஒதுக்கீடு) மற்றும் உழைப்பு (கணக்கீடு) ஆகியவற்றில் வீணானது.

இட்டரேட்டர் ஹெல்பர்களால் இயக்கப்படும் ஸ்ட்ரீம் ஃபியூஷன், ஒரு நவீன அசெம்பிளி லைன் போன்றது:

• ஒரு ஒற்றை கன்வேயர் பெல்ட் அனைத்து நிலையங்கள் வழியாகவும் இயங்குகிறது.
• ஒரு பொருள் பெல்ட்டில் வைக்கப்படுகிறது. அது வடிகட்டும் நிலையத்திற்கு நகர்கிறது. அது தோல்வியுற்றால், அது அகற்றப்படும். அது தேர்ச்சி பெற்றால், அது தொடர்கிறது.
• அது உடனடியாக மேப்பிங் நிலையத்திற்கு நகர்கிறது, அங்கு அது மாற்றியமைக்கப்படுகிறது.
• பின்னர் அது எண்ணும் நிலையத்திற்கு (take) நகர்கிறது. ஒரு மேற்பார்வையாளர் அதை எண்ணுகிறார்.
• இது தொடர்கிறது, ஒரு நேரத்தில் ஒரு பொருள், மேற்பார்வையாளர் ஐந்து வெற்றிகரமான பொருட்களை எண்ணும் வரை. அந்த நேரத்தில், மேற்பார்வையாளர் "நிறுத்து!" என்று கத்துகிறார், முழு அசெம்பிளி லைனும் மூடப்படுகிறது.

இந்த மாதிரியில், இடைநிலை தயாரிப்புகளின் பெரிய தொட்டிகள் இல்லை, வேலை முடிந்தவுடன் வரி நின்றுவிடுகிறது. இதுதான் இட்டரேட்டர் ஹெல்பர் ஸ்ட்ரீம் ஃபியூஷன் துல்லியமாக செயல்படும் விதம்.

ஒரு படிப்படியான விளக்கம்

நமது இட்டரேட்டர் உதாரணத்தின் செயல்பாட்டைக் கண்காணிப்போம்: numbers.values().filter(...).map(...).take(5).toArray().

1. .toArray() அழைக்கப்படுகிறது. அதற்கு ஒரு மதிப்பு தேவை. அது அதன் மூலமான take(5) இட்டரேட்டரிடமிருந்து அதன் முதல் பொருளைக் கேட்கிறது.
2. take(5) இட்டரேட்டருக்கு எண்ணுவதற்கு ஒரு பொருள் தேவை. அது அதன் மூலமான map இட்டரேட்டரிடமிருந்து ஒரு பொருளைக் கேட்கிறது.
3. map இட்டரேட்டருக்கு மாற்றுவதற்கு ஒரு பொருள் தேவை. அது அதன் மூலமான filter இட்டரேட்டரிடமிருந்து ஒரு பொருளைக் கேட்கிறது.
4. filter இட்டரேட்டருக்கு சோதிக்க ஒரு பொருள் தேவை. அது மூல அரே இட்டரேட்டரிலிருந்து முதல் மதிப்பை இழுக்கிறது: 1.
5. '1'-இன் பயணம்: ஃபில்டர் 1 % 2 === 0 என்பதைச் சரிபார்க்கிறது. இது தவறு. ஃபில்டர் இட்டரேட்டர் 1-ஐ நிராகரித்து, மூலத்திலிருந்து அடுத்த மதிப்பை இழுக்கிறது: 2.
6. '2'-இன் பயணம்:
   • ஃபில்டர் 2 % 2 === 0 என்பதைச் சரிபார்க்கிறது. இது சரி. இது 2-ஐ map இட்டரேட்டருக்கு அனுப்புகிறது.
   • map இட்டரேட்டர் 2-ஐப் பெறுகிறது, 2 * 2-ஐக் கணக்கிடுகிறது, மேலும் அதன் விளைவான 4-ஐ take இட்டரேட்டருக்கு அனுப்புகிறது.
   • take இட்டரேட்டர் 4-ஐப் பெறுகிறது. அது அதன் உள் கவுண்டரைக் குறைக்கிறது (5-லிருந்து 4-ஆக) மற்றும் 4-ஐ toArray() நுகர்வோருக்கு அளிக்கிறது. முதல் முடிவு கண்டுபிடிக்கப்பட்டது.
7. toArray() ஒரு மதிப்பைக் கொண்டுள்ளது. அது take(5)-இடமிருந்து அடுத்த ஒன்றைக் கேட்கிறது. முழு செயல்முறையும் மீண்டும் நிகழ்கிறது.
8. ஃபில்டர் 3-ஐ இழுக்கிறது (தோல்வி), பின்னர் 4-ஐ (தேர்ச்சி). 4 என்பது 8-ஆக மேப் செய்யப்படுகிறது, அது எடுக்கப்படுகிறது.
9. take(5) ஐந்து மதிப்புகளை அளிக்கும் வரை இது தொடர்கிறது. ஐந்தாவது மதிப்பு அசல் எண் 10-இலிருந்து இருக்கும், இது 20-ஆக மேப் செய்யப்படுகிறது.
10. take(5) இட்டரேட்டர் அதன் ஐந்தாவது மதிப்பை அளித்தவுடன், அதன் வேலை முடிந்துவிட்டது என்று அது அறியும். அடுத்த முறை அதனிடம் ஒரு மதிப்பு கேட்கப்படும்போது, அது முடிந்துவிட்டதாக சமிக்ஞை செய்யும். முழு சங்கிலியும் நின்றுவிடுகிறது. 11, 12 எண்கள் மற்றும் மூல அரேவில் உள்ள மில்லியன் கணக்கான மற்றவை பார்க்கப்படவே இல்லை.

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

நடைமுறை பயன்பாடுகள் மற்றும் செயல்திறன் ஆதாயங்கள்

இட்டரேட்டர் ஹெல்பர்களின் சக்தி எளிய அரே கையாளுதலுக்கு அப்பாற்பட்டது. இது சிக்கலான தரவு செயலாக்கப் பணிகளை திறமையாகக் கையாள புதிய சாத்தியங்களைத் திறக்கிறது.

காட்சி 1: பெரிய தரவுத்தொகுப்புகள் மற்றும் ஸ்ட்ரீம்களைச் செயலாக்குதல்

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

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

// ஒரு பெரிய கோப்பிலிருந்து வரிகளை வழங்கும் ஜெனரேட்டரின் கருத்தியல் உதாரணம் function* readLines(filePath) { // கோப்பை முழுவதுமாக ஏற்றாமல் வரி வரியாக படிக்கும் செயல்பாடு // yield line; } const errorCount = readLines('huge_app.log').values() .map(line => JSON.parse(line)) .filter(logEntry => logEntry.level === 'error') .take(100) // முதல் 100 பிழைகளைக் கண்டறியவும் .reduce((count) => count + 1, 0);

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

காட்சி 2: முன்கூட்டியே முடித்தல் மற்றும் குறுக்குவழி

இதை நாம் ஏற்கனவே .take() உடன் பார்த்தோம், ஆனால் இது .find(), .some(), மற்றும் .every() போன்ற மெத்தட்களுக்கும் பொருந்தும். ஒரு பெரிய தரவுத்தளத்தில் நிர்வாகியாக இருக்கும் முதல் பயனரைக் கண்டுபிடிப்பதைக் கருத்தில் கொள்ளுங்கள்.

அரே-அடிப்படையிலானது (திறனற்றது):

const firstAdmin = users.filter(u => u.isAdmin)[0];

இங்கே, முதல் பயனரே ஒரு நிர்வாகியாக இருந்தாலும், .filter() முழு users அரே வழியாகவும் சுழலும்.

இட்டரேட்டர்-அடிப்படையிலானது (திறமையானது):

const firstAdmin = users.values().find(u => u.isAdmin);

.find() ஹெல்பர் ஒவ்வொரு பயனரையும் ஒவ்வொன்றாகச் சோதித்து, முதல் பொருத்தத்தைக் கண்டறிந்தவுடன் முழு செயல்முறையையும் உடனடியாக நிறுத்திவிடும்.

காட்சி 3: எல்லையற்ற தொடர்களுடன் வேலை செய்தல்

சோம்பல் மதிப்பீடு சாத்தியமான எல்லையற்ற தரவு மூலங்களுடன் வேலை செய்வதை சாத்தியமாக்குகிறது, இது அரேக்களுடன் சாத்தியமற்றது. ஜெனரேட்டர்கள் அத்தகைய தொடர்களை உருவாக்க hoàn hảo.

function* fibonacci() { let a = 0, b = 1; while (true) { yield a; [a, b] = [b, a + b]; } } // 1000-ஐ விட பெரிய முதல் 10 ஃபிபோனச்சி எண்களைக் கண்டறியவும் const result = fibonacci() .filter(n => n > 1000) .take(10) .toArray(); // result will be [1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393]

இந்த குறியீடு hoàn hảo இயங்குகிறது. fibonacci() ஜெனரேட்டர் என்றென்றும் இயங்கக்கூடும், ஆனால் செயல்பாடுகள் சோம்பலாக இருப்பதாலும், .take(10) ஒரு நிறுத்த நிபந்தனையை வழங்குவதாலும், நிரல் கோரிக்கையை திருப்திப்படுத்த தேவையான அளவு ஃபிபோனச்சி எண்களை மட்டுமே கணக்கிடுகிறது.

பரந்த சுற்றுச்சூழல் அமைப்பைப் பார்ப்பது: அசிங்க் இட்டரேட்டர்கள்

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

ஒரு பக்கங்களாகப் பிரிக்கப்பட்ட API-ஐ செயலாக்குதல், Node.js-லிருந்து ஒரு கோப்பு ஸ்ட்ரீமைப் படித்தல், அல்லது ஒரு WebSocket-இலிருந்து தரவைக் கையாளுதல் ஆகியவற்றை கற்பனை செய்து பாருங்கள். இவை அனைத்தும் இயற்கையாகவே அசிங்க் ஸ்ட்ரீம்களாக குறிப்பிடப்படுகின்றன. அசிங்க் இட்டரேட்டர் ஹெல்பர்களுடன், நீங்கள் அதே அறிவிப்பு .map() மற்றும் .filter() தொடரியலை அவற்றின் மீது பயன்படுத்தலாம்.

// பக்கங்களாகப் பிரிக்கப்பட்ட API-ஐ செயலாக்குவதற்கான கருத்தியல் உதாரணம் async function* fetchAllUsers() { let url = '/api/users?page=1'; while (url) { const response = await fetch(url); const data = await response.json(); for (const user of data.users) { yield user; } url = data.nextPageUrl; } } // ஒரு குறிப்பிட்ட நாட்டிலிருந்து முதல் 5 செயலில் உள்ள பயனர்களைக் கண்டறியவும் const activeUsers = await fetchAllUsers() .filter(user => user.isActive) .filter(user => user.country === 'DE') .take(5) .toArray();

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

தொடங்குதல் மற்றும் தற்போதைய நிலை

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

இன்று இட்டரேட்டர் ஹெல்பர்களை எவ்வாறு பயன்படுத்துவது

• உலாவி மற்றும் Node.js இயக்க நேரங்கள்: முக்கிய உலாவிகளின் (Chrome/V8 போன்றவை) மற்றும் Node.js-இன் சமீபத்திய பதிப்புகள் இந்த அம்சங்களை செயல்படுத்தத் தொடங்கியுள்ளன. அவற்றை இயல்பாக அணுக நீங்கள் ஒரு குறிப்பிட்ட கொடியை இயக்க வேண்டும் அல்லது மிகச் சமீபத்திய பதிப்பைப் பயன்படுத்த வேண்டியிருக்கலாம். எப்போதும் சமீபத்திய பொருந்தக்கூடிய அட்டவணைகளை (எ.கா., MDN அல்லது caniuse.com-இல்) சரிபார்க்கவும்.
• பாலிஃபில்கள்: பழைய இயக்க நேரங்களை ஆதரிக்க வேண்டிய உற்பத்தி சூழல்களுக்கு, நீங்கள் ஒரு பாலிஃபில்லைப் பயன்படுத்தலாம். மிகவும் பொதுவான வழி core-js நூலகத்தின் மூலம், இது பெரும்பாலும் பேபல் போன்ற டிரான்ஸ்பைலர்களால் சேர்க்கப்படுகிறது. பேபல் மற்றும் core-js-ஐ உள்ளமைப்பதன் மூலம், நீங்கள் இட்டரேட்டர் ஹெல்பர்களைப் பயன்படுத்தி குறியீட்டை எழுதலாம் மற்றும் அதை பழைய சூழல்களில் வேலை செய்யும் சமமான குறியீடாக மாற்றலாம்.

முடிவுரை: ஜாவாஸ்கிரிப்டில் திறமையான தரவு செயலாக்கத்தின் எதிர்காலம்

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

ஒவ்வொரு டெவலப்பருக்குமான முக்கிய குறிப்புகள்:

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

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