சுழல் செயல்பாடுகள் என்பது ஒரு முறையை மற்றொரு முறைக்குள் அழைக்கும் செயல்பாடுகள். இருப்பினும், எல்லையற்ற மறுநிகழ்வு அடுக்கு அளவு பிழையை ஏற்படுத்துகிறது. பல கோரிக்கைகள் நிலுவையில் இருப்பதால் அடுக்கு அளவு பிழை ஏற்படுகிறது. செயல்பாட்டை அழைக்கும் போது இந்த சிக்கல் எழுகிறது. அதைக் கருத்தில் கொண்டு, ஜாவாஸ்கிரிப்டில் உள்ள பிழையை விட அதிகபட்ச அழைப்பு அடுக்கு அளவு அதிகமாக உள்ளது என்பதை இந்தக் கட்டுரை விளக்குகிறது. மேலும், பிழையை தீர்க்க தீர்வும் வழங்கப்படுகிறது.
கட்டுரை எங்களுக்கு பின்வருமாறு உதவுகிறது:
- ஜாவாஸ்கிரிப்டில் அதிகபட்ச அழைப்பு அடுக்கு அளவை மீறியது பிழை
- அதிகபட்ச அழைப்பு ஸ்டாக் அளவு மீறப்பட்ட பிழையைத் தீர்க்க, if Condition ஐப் பயன்படுத்துகிறது
- அதிகபட்ச அழைப்பு அடுக்கு அளவு மீறப்பட்ட பிழையைத் தீர்க்க லூப்பிற்காகப் பயன்படுத்துதல்.
ஜாவாஸ்கிரிப்டில் அதிகபட்ச அழைப்பு அடுக்கு அளவை மீறியது பிழை
பயனர் சுழல்நிலை செயல்பாட்டை அழைக்கும் போது அடுக்கு அளவு மீறப்பட்ட பிழை ஏற்படுகிறது. ஒரு முறையை மீண்டும் மீண்டும் செயல்படுத்துவதால் இந்த வகையான பிழை ஏற்படுகிறது. தி fun_user() செயல்பாட்டின் உள்ளே ஒரு சுழல்நிலை அழைப்பாகப் பயன்படுத்தப்படுகிறது fun_user() கன்சோல் சாளரத்தில் பிழையை உருவாக்க JavaScript இல்.
குறியீடு
console.log ( 'அதிகபட்ச அழைப்பு அடுக்கு அளவை மீறிவிட்டது' ) ;
வேடிக்கை_பயனர் ( ) ;
செயல்பாடு வேடிக்கை_பயனர் ( )
{
வேடிக்கை_பயனர் ( ) ;
}
இந்த குறியீட்டில், தி 'அதிகபட்ச அழைப்பு அடுக்கு அளவை மீறியது பிழை' ஒரு முறையை அழைப்பதன் மூலம் உருவாக்கப்படுகிறது “fun_user()” செயல்பாட்டின் உள்ளே.
குறியீடு பிழையைக் காட்டுகிறது 'ரேஞ்ச்பிழை: அதிகபட்ச அழைப்பு அடுக்கு அளவை மீறிவிட்டது.'
இந்த பிழையை தீர்க்க பல வழிகள் உள்ளன வளையத்திற்கு மற்றும் நிபந்தனை அறிக்கைகள் , இது செயல்பாட்டு அழைப்பைக் கட்டுப்படுத்தப் பயன்படும்.
தீர்வு 1: அதிகபட்ச அழைப்பு ஸ்டாக் அளவு மீறப்பட்ட பிழையைத் தீர்க்க, என்றால் நிபந்தனையைப் பயன்படுத்துதல்
பிழையைத் தீர்க்க, JavaScript இல் அடுக்கு அளவைக் கட்டுப்படுத்த if நிபந்தனை பயன்படுத்தப்படுகிறது. உதாரணமாக, குறியீடு கீழே கொடுக்கப்பட்டுள்ளது.
குறியீடு
இருந்தது நான் = 1 ;வேடிக்கை_பயனர் ( நான் ) ;
செயல்பாடு வேடிக்கை_பயனர் ( நான் ) {
என்றால் ( நான் < = 10 )
{
console.log ( 'ஜாவாஸ்கிரிப்ட்டுக்கு வரவேற்கிறோம்' ) ;
நான் =நான்+ 1 ;
வேடிக்கை_பயனர் ( நான் ) ;
} }
குறியீட்டின் விளக்கம் பின்வருமாறு:
- முதலில், ஒரு மாறி 'நான்' மதிப்பு 1 உடன் துவக்கப்பட்டது.
- அதற்கு பிறகு, fun_user() மாறியை அனுப்புவதன் மூலம் முறை பயன்படுத்தப்படுகிறது 'நான்'.
- இந்தச் செயல்பாட்டில், மறு செய்கையைக் கட்டுப்படுத்தும் நிபந்தனை பயன்படுத்தப்பட்டால் 10 .
- இறுதியாக, செய்தி 'ஜாவாஸ்கிரிப்ட்டுக்கு வரவேற்கிறோம்' பயன்படுத்தி காட்டப்படுகிறது “console.log()” முறை.
வெளியீடு
தீர்வு 2: அதிகபட்ச அழைப்பு அடுக்கு அளவு மீறப்பட்ட பிழையைத் தீர்க்க லூப்பைப் பயன்படுத்துதல்
பிழையைத் தீர்க்க, ஜாவாஸ்கிரிப்ட்டில் மறு செய்கைகளைக் கட்டுப்படுத்த ஃபார் லூப் பயன்படுத்தப்படுகிறது. உதாரணமாக, குறியீடு கீழே கொடுக்கப்பட்டுள்ளது.
குறியீடு
விடு வெளியீடு = 0 ;க்கான ( விடு நான் = 5 ; நான் > 0 ; நான்-- )
{
வெளியீடு += சேர் ( 1 , 1 ) ;
}
செயல்பாடு கூட்டு ( a, b ) {
திரும்ப a + b;
}
console.log ( வெளியீடு ) ;
இந்த குறியீட்டில்:
- மாறி 'வெளியீடு' 0 மதிப்புடன் துவக்கப்பட்டது.
- அதன் பிறகு, ஐந்து மறு செய்கைகளைச் செய்ய ஒரு for loop பயன்படுத்தப்படுகிறது. இந்த சுழற்சியில், தி கூட்டு() மதிப்பு 1 ஐ கடந்து முறை அழைக்கப்படுகிறது.
- முறை கூட்டு() இரண்டு மாறிகளின் கூட்டலை வழங்குகிறது அ மற்றும் பி .
- இறுதியில், தி பதிவு() கன்சோல் சாளரத்தில் வெளியீட்டைக் காண்பிக்கும் முறை பயன்படுத்தப்படுகிறது.
வெளியீடு
வெளியீடு திரும்பும் '10' JavaScript இல் அதிகபட்ச அழைப்பு அடுக்கு அளவின் பிழையைத் தீர்ப்பதன் மூலம்.
முடிவுரை
சுழல்நிலை செயல்பாடுகளின் எல்லையற்ற அழைப்பு இவ்வாறு நிகழ்கிறது 'அதிகபட்ச அழைப்பு அடுக்கு அளவை மீறியது பிழை' ஜாவாஸ்கிரிப்டில். இந்த வகை பிழை ஏற்படுவதற்கான காரணங்களை இந்த கட்டுரை விளக்குகிறது. பின்னர், உட்பட இரண்டு தீர்வுகள் 'சுழலுக்கு' மற்றும் 'நிபந்தனை அறிக்கைகள்' பிழையைத் தீர்க்கப் பயன்படுத்தப்படுகின்றன. எனவே, இந்த தீர்வுகளைப் பயன்படுத்துவதன் மூலம் அழைப்பு செயல்பாடுகள் கட்டுப்படுத்தப்படுகின்றன.