ஜாவாஸ்கிரிப்டில் கால் ஸ்டாக்குகள் (Call Stacks)

ஜாவாஸ்கிரிப்டில், கால் ஸ்டாக் (Call Stack) என்பது LIFO (கடைசியாக உள்ளே, முதலில் வெளியே - Last-In, First-Out) கொள்கையைப் பயன்படுத்தி செயல்பாட்டு அழைப்புகளை (function invocation/call) தற்காலிகமாகச் சேமித்து நிர்வகிக்கும் ஒரு தரவுக் கட்டமைப்பாகும் (data structure).

கால் ஸ்டாக் என்றால் என்ன?

உங்கள் குறியீட்டில் உள்ள செயல்பாட்டு அழைப்புகளைக் (function calls) கண்காணிப்பதற்கு கால் ஸ்டாக் பொறுப்பாகும். ஜாவாஸ்கிரிப்ட் மொழிபெயர்ப்பாளர் (interpreter) தற்போது எந்தச் செயல்பாடு இயங்குகிறது மற்றும் அந்தச் செயல்பாட்டிற்குள் எந்தச் செயல்பாடுகள் அழைக்கப்படுகின்றன என்பதைக் கண்காணிக்க கால் ஸ்டாக் உதவுகிறது.

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

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

கால் ஸ்டாக்கில் ஒரு எடுத்துக்காட்டு

ஒரு கால் ஸ்டாக் எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வதற்கான அடிப்படை எடுத்துக்காட்டு இங்கே:

function firstFunction() {
    console.log("First function is called.");
    secondFunction();
    console.log("First function is done.");
}

function secondFunction() {
    console.log("Second function is called.");
    thirdFunction();
    console.log("Second function is done.");
}

function thirdFunction() {
    console.log("Third function is called.");
}

firstFunction();

வெளியீடு (Output):

First function is called.
Second function is called.
Third function is called.
Second function is done.
First function is done.

கால் ஸ்டாக் எவ்வாறு செயல்படுகிறது

1. firstFunction அழைக்கப்படும்போது, அது கால் ஸ்டாக்கில் சேர்க்கப்படும்.
2. firstFunction க்குள், secondFunction அழைக்கப்படுகிறது, எனவே அது கால் ஸ்டாக்கில் சேர்க்கப்படுகிறது.
3. secondFunction க்குள், thirdFunction அழைக்கப்படுகிறது, எனவே அது கால் ஸ்டாக்கில் சேர்க்கப்படுகிறது.
4. thirdFunction நிறைவடைகிறது மற்றும் கால் ஸ்டாக்கில் இருந்து அகற்றப்படுகிறது.
5. secondFunction மீண்டும் தொடங்குகிறது, நிறைவடைகிறது, மற்றும் கால் ஸ்டாக்கில் இருந்து அகற்றப்படுகிறது.
6. firstFunction மீண்டும் தொடங்குகிறது, நிறைவடைகிறது, மற்றும் கால் ஸ்டாக்கில் இருந்து அகற்றப்படுகிறது.

ஸ்டாக் ஓவர்ஃப்ளோ (Stack Overflow)

கால் ஸ்டாக்கில் அதிகப்படியான செயல்பாட்டு அழைப்புகள் இருக்கும்போது ஒரு ஸ்டாக் ஓவர்ஃப்ளோ ஏற்படுகிறது. மறுநிகழ்வை (recursion) நிறுத்த ஒரு அடிப்படை வழக்கு (base case) இல்லாத சுழல் செயல்பாடுகளில் (recursive functions) இது நிகழலாம்.

function recursiveFunction() {
    recursiveFunction();
}

recursiveFunction();

இது "Maximum call stack size exceeded" என்ற பிழையை ஏற்படுத்தும்.