இந்தக் கட்டுரை ஜாவாஸ்கிரிப்ட்டில் எதையாவது மீண்டும் மீண்டும் செய்வது எப்படி என்பது பற்றிய பல்வேறு முறைகளைப் பற்றி விவாதிக்கிறது.
ஜாவாஸ்கிரிப்ட்டில் எதையாவது மீண்டும் செய்வது எப்படி?
ஒரு சரத்தை ஜாவாஸ்கிரிப்ட்டில் பின்வரும் வழிகளில் மீண்டும் செய்ய முடியும்:
- while loop முறையைப் பயன்படுத்துதல்
- ES6 ரிபீட்() முறையைப் பயன்படுத்துதல்
- மறுநிகழ்வைப் பயன்படுத்துதல்
- நிரப்பு () முறையைப் பயன்படுத்துதல்
ஒவ்வொரு முறையையும் விரிவாகப் பார்ப்போம்.
முறை 1: வைல் லூப்பைப் பயன்படுத்தி ஜாவாஸ்கிரிப்டில் ஏதாவது ஒன்றை மீண்டும் செய்யவும்
' போது ” என்பது ஜாவாஸ்கிரிப்டில் ஒரு கட்டுப்பாட்டு ஓட்ட அறிக்கையாகும், இது ஒரு குறிப்பிட்ட நிபந்தனையின் கீழ் மீண்டும் மீண்டும் செயல்படுத்தப்படுகிறது. ஒவ்வொரு மறு செய்கைக்கும் முன் நிலைமை கவனிக்கப்படுகிறது. நிபந்தனை துல்லியமாக இருக்கும் வரை லூப் இயங்கும். நிபந்தனை தவறாக இருந்தால், லூப் இயங்குவதை நிறுத்துகிறது. பின்வரும் குறியீடு, while லூப்களைப் பயன்படுத்தி ஜாவாஸ்கிரிப்டில் மீண்டும் மீண்டும் செய்யும் செயல்முறையை விளக்குகிறது:
DOCTYPE html >
< html >
< கையால் எழுதப்பட்ட தாள் >
செயல்பாடு மீண்டும் ( str, எண்ணிக்கை ) {
rpt_Str விடுங்கள் = '' ;
போது ( எண்ணிக்கை > 0 ) {
rpt_Str += str ;
எண்ணிக்கை --;
}
திரும்ப rpt_Str ;
}
ஆவணம். எழுது ( மீண்டும் ( 'டெய்லர்' , 6 ) ) ;
கையால் எழுதப்பட்ட தாள் >
html >
மேலே உள்ள எடுத்துக்காட்டில்:
- 'str' மற்றும் 'count' என்ற அளவுருக்களுடன் ஸ்கிரிப்ட் குறிச்சொல்லின் உள்ளே ஒரு செயல்பாடு மீண்டும் () வரையறுக்கப்படுகிறது.
- அடுத்து, 'rpt_str' என்ற வெற்று சரத்தை வரையறுத்து, எண்ணிக்கை 0 ஐ விட அதிகமாக இருக்க வேண்டும் என்ற நிபந்தனையுடன் சிறிது நேர சுழற்சியைத் தொடங்கினோம்.
- “rpt_str” ஆனது “str” மதிப்பைக் கொண்டுள்ளது, மேலும் நிபந்தனை உண்மையாக இல்லாவிட்டால் லூப் இயங்கும். இந்த வழக்கில், எண்ணிக்கை மதிப்பு 6 எனவே சரம் 6 முறை அச்சிடப்படும்.
வெளியீடு
'TAYLOR' என்ற சரம் 6 முறை மீண்டும் மீண்டும் செய்யப்படும், இது எண்ணிக்கைக்கு சமம்:
முறை 2: ES6 ரிபீட்()ஐப் பயன்படுத்தி ஜாவாஸ்கிரிப்ட்டில் எதையாவது செய்யவும்
ES6 மீண்டும் () ஜாவாஸ்கிரிப்ட்டில் ஒரு சரத்தை மீண்டும் செய்ய பயன்படுத்தலாம். அழைக்கப்படும் போது குறிப்பிட்ட நகல்களைக் கொண்ட ஒரு சரம் திரும்பும். ரிபீட்() ஐப் பயன்படுத்தி ஒரு சரத்தை எவ்வாறு மீண்டும் செய்யலாம் என்பதைக் காட்டும் குறியீட்டின் எடுத்துக்காட்டு இங்கே:
DOCTYPE html >< html >
< கையால் எழுதப்பட்ட தாள் >
செயல்பாடு rpt_str ( str, எண்ணிக்கை ) {
என்றால் ( எண்ணிக்கை > 0 )
திரும்ப str. மீண்டும் ( எண்ணிக்கை ) ;
வேறு
திரும்ப '' ;
}
ஆவணம். எழுது ( rpt_str ( 'ஜாவாஸ்கிரிப்ட்' , 5 ) ) ;
கையால் எழுதப்பட்ட தாள் >
html >
மேலே உள்ள குறியீட்டில்,
- ஒரு செயல்பாடு “rpt_str()” அளவுருக்கள் str மற்றும் எண்ணிக்கையுடன் வரையறுக்கப்படுகிறது.
- str மதிப்பு 'ஜாவாஸ்கிரிப்ட்' என ஒதுக்கப்பட்டுள்ளது, இது எண்ணுவதற்கு ஒதுக்கப்பட்ட மதிப்பின் படி மீண்டும் நிகழும்.
வெளியீடு
இந்த எடுத்துக்காட்டில், எண்ணுவதற்கு ஒதுக்கப்பட்ட மதிப்பு 5 ஆகும், எனவே ரிபீட்() செயல்பாடு ஜாவாஸ்கிரிப்டை 5 முறை மீண்டும் செய்யும்:
முறை 3: ரிகர்ஷனைப் பயன்படுத்தி ஜாவாஸ்கிரிப்ட்டில் எதையாவது செய்யவும்
விரும்பிய முடிவைப் பெறாத வரை, மறுநிகழ்வு ஒரு செயல்பாட்டை மீண்டும் மீண்டும் அழைக்க உதவுகிறது. மறுநிகழ்வில், மறுநிகழ்வை முடிக்க முதன்மை/அடிப்படை வழக்கு குறிப்பிடப்பட வேண்டும். இது வழக்கமாக ஒரு நிபந்தனை விதிக்குள் உள்ளது. நாம் விரும்பிய முடிவைப் பெறும் வரை மீண்டும் மீண்டும் தன்னை அழைப்பதன் மூலம் சுழல்நிலை செயல்பாடு செயல்படுகிறது. பின்வரும் உதாரணம் ஜாவாஸ்கிரிப்டில் மீண்டும் மீண்டும் செய்ய மறுநிகழ்வு முறையைப் புரிந்துகொள்ள உதவுகிறது:
! DOCTYPE html >< html >
< கையால் எழுதப்பட்ட தாள் >
செயல்பாடு rpt_str ( str, எண்ணிக்கை ) {
என்றால் ( எண்ணிக்கை < 0 )
திரும்ப '' ;
என்றால் ( எண்ணிக்கை === 1 )
திரும்ப str ;
வேறு
திரும்ப str + rpt_str ( str, எண்ணிக்கை - 1 ) ;
}
ஆவணம். எழுது ( rpt_str ( 'குறியீடு' , 7 ) ) ;
கையால் எழுதப்பட்ட தாள் >
html >
மேலே உள்ள குறியீட்டில்:
- ஒரு செயல்பாடு “rpt_str()” என்பது “str” மற்றும் “count” அளவுருக்கள் மூலம் வரையறுக்கப்படுகிறது.
- எண்ணிக்கையின் மதிப்பு 0 ஐ விடக் குறைவாக இருந்தால், ஒரு வெற்று சரம் வழங்கப்படும். எண்ணிக்கையின் மதிப்பு 1 எனில், அது str ஐ வழங்கும் மற்றும் str இன் மதிப்பு 1 ஐ விட அதிகமாக இருந்தால், செயல்பாடு str இன் உள்ளீட்டு மதிப்பை rpt_str(str, எண்ணிக்கை – 1) இலிருந்து பெறுகிறது.
- இங்கே, str இன் மதிப்பு “CODE” மற்றும் எண்ணிக்கையின் மதிப்பு 7 எனவே மீண்டும் மீண்டும் வரும் சரம் CODE ஐ 7 முறை அச்சிடும்.
வெளியீடு:
முறை 4: நிரப்பு() செயல்பாட்டைப் பயன்படுத்தி ஜாவாஸ்கிரிப்டில் ஏதாவது ஒன்றை மீண்டும் செய்யவும்
JavaScript வழங்குகிறது a நிரப்பு() நிலையான மதிப்புகளுடன் ஒரு வரிசையை நிரப்ப அனுமதிக்கும் முறை. ஜாவாஸ்கிரிப்ட்டில் எதையாவது மீண்டும் செய்ய, join() செயல்பாட்டுடன் இதைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, சரம் மதிப்புகளை நிரப்பு() செயல்பாட்டைப் பயன்படுத்தி வெற்று வரிசையில் செருகலாம் மற்றும் மீண்டும் மீண்டும் சரத்தைப் பெற ஜாயின்() செயல்பாட்டுடன் ஒன்றாக இணைக்கலாம். நிரப்பு() செயல்பாட்டின் மூலம் ஒரு சரத்தை எவ்வாறு மீண்டும் செய்யலாம் என்பதைக் காட்டும் குறியீட்டின் எடுத்துக்காட்டு இங்கே:
< html >< உடல் >
< கையால் எழுதப்பட்ட தாள் >
str விடுங்கள் = 'முன்பக்கம்'
rpt_str ஐ விடுங்கள் = வரிசை ( 5 ) . நிரப்பவும் ( str ) . சேர ( '' )
ஆவணம். எழுது ( rpt_str ) ;
கையால் எழுதப்பட்ட தாள் >
உடல் >
html >
மேலே உள்ள எடுத்துக்காட்டில்:
- ஒரு மாறி str வரையறுக்கப்பட்டு 'FRONTEND' மதிப்புடன் ஒதுக்கப்படுகிறது.
- வரிசை(5) செயல்பாடு 5 ஸ்லாட்டுகளை உருவாக்கும், அதில் சரம் நிரப்பப்பட்டு மீண்டும் மீண்டும் சரத்தை உருவாக்க ஒன்றாக இணைக்கப்படும். மதிப்பு “rpt_str” மாறியில் சேமிக்கப்படுகிறது.
- document.write(rpt_str) மீண்டும் மீண்டும் வரும் சரத்தை அச்சிடும்.
வெளியீடு
குறியீட்டை இயக்கும்போது, 'FRONTEND' என்ற சரம் 5 முறை மீண்டும் மீண்டும் செய்யப்படும்:
வெவ்வேறு முறைகளைப் பயன்படுத்தி ஜாவாஸ்கிரிப்ட்டில் எதையாவது மீண்டும் செய்வது அவ்வளவுதான்.
முடிவுரை
ஜாவாஸ்கிரிப்ட்டில் எதையாவது மீண்டும் மீண்டும் செய்வதற்கான ஒரு வழக்கமான முறை, ES6 ரிபீட்() செயல்பாட்டைப் பயன்படுத்துகிறது, இது உறுப்புகளின் மறு செய்கைகளின் எண்ணிக்கையைக் குறிக்கும் குறிப்பிட்ட அளவுருவை எடுக்கும். சிறிது நேர வளையம், சுழல்நிலை செயல்பாடுகள் அல்லது நிரப்பு() முறை போன்ற பிற முறைகள். இந்தக் கட்டுரை, ஜாவாஸ்கிரிப்டில் எதையாவது திரும்பத் திரும்பச் செய்யக்கூடிய பல்வேறு வழிகளை அவற்றின் எடுத்துக்காட்டுகளுடன் விளக்குகிறது.