Recursive செயல்பாடுகள்

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

தொடரியல்

ஒரு recursive செயல்பாடு பொதுவாக பின்வரும் அமைப்பைக் கொண்டுள்ளது:

function recursiveFunction(params) {
  // Base case: எளிமையான காட்சி
  if (/* base case நிபந்தனை */) {
    // ஒரு மதிப்பைத் திரும்பப் பெறு அல்லது ஒரு செயலைச் செய்
  } else {
    // Recursive case: மாற்றியமைக்கப்பட்ட அளவுருக்களுடன் செயல்பாட்டை அழைக்கவும்
    return recursiveFunction(modifiedParams);
  }
}

பொதுவான பயன்பாட்டு வழக்குகள் Recursive செயல்பாடுகள் பெரும்பாலும் சிறிய, ஒத்த துணைச் சிக்கல்களாகப் பிரிக்கக்கூடிய சிக்கல்களைத் தீர்க்கப் பயன்படுத்தப்படுகின்றன. சில பொதுவான பயன்பாட்டு வழக்குகள் இங்கே:

காரணியங்களைக் (Factorials) கணக்கிடுதல்:

ஒரு எண்ணின் காரணியத்தைக் கணக்கிட ஒரு recursive செயல்பாட்டைப் பயன்படுத்தலாம்.

function factorial(n) {
  if (n === 0) {
    return 1; // Base case
  } else {
    return n * factorial(n - 1); // Recursive case
  }
}

factorial(5); // 120 ஐ திரும்பப் பெறுகிறது

Fibonacci வரிசை: Recursion ஐப் பயன்படுத்தி Fibonacci வரிசையைக் கணக்கிடலாம்.

function fibonacci(n) {
  if (n <= 1) {
    return n; // Base cases: F(0) = 0, F(1) = 1
  } else {
    return fibonacci(n - 1) + fibonacci(n - 2); // Recursive case
  }
}

fibonacci(5); // 5 ஐ திரும்பப் பெறுகிறது

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