Closureஐப்பற்றி அறிந்துகொள்வதற்கு முன்னதாக, அதைப்பயன்படுத்தும் ஓர் எளிய செயற்கூற்றைக்காணலாம்.
[code lang=”javascript”]
function grandParent(g1, g2) {
var g3 = 3;
return function parent(p1, p2) {
var p3 = 33;
return function child(c1, c2) {
var c3 = 333;
return g1 + g2 + g3 + p1 + p2 + p3 + c1 + c2 + c3;
};
};
}
[/code]
இவ்வெடுத்துக்காட்டில் grandParent என்ற செயற்கூறு, g1, g2 என்ற உள்ளீட்டு உருபுகளை ஏற்றுக்கொண்டு, g3 என்ற மாறியை வரையறுத்து, parent என்ற செயற்கூற்றைத் திருப்பியனுப்புகிறது.
parent என்ற செயற்கூறு, p1, p2 என்ற உள்ளீட்டு உருபுகளை ஏற்கிறது. p3 என்ற மாறியை வரையறுக்கிறது. child என்ற செயற்கூற்றைத் திருப்பியனுப்புகிறது.
child என்ற செயற்கூறு c1, c2 என்ற உள்ளீட்டு உருபுகளை ஏற்று, c3ஐ வரையறுத்து, இதுவரை நாம் கடந்துவந்த மாறிகளின் கூட்டுத்தொகையைத் திருப்பியனுப்புகிறது.
இதன் பயன்பாட்டைக் கீழே காணலாம்:
[code lang=”javascript”]
var parentFunc = grandParent(1, 2);
var childFunc = parentFunc(11, 22);
console.log(childFunc(111, 222)); // 738ஐ அச்சிடுகிறது.
// 1 + 2 + 3 + 11 + 22 + 33 + 111 + 222 + 333 == 738
[/code]
இங்கே கவனிக்கவேண்டிய விசயம் என்னவெனில், child செயற்கூற்றினால், அதனை உருவாக்கிய செயற்கூறுகளின் மாறிகள் மற்றும் உள்ளீட்டு உருபுகளை அணுகமுடிகிறது. இங்கே உருவாக்கப்படும் ஒவ்வொரு செயற்கூறும், அவை உருவாகும் நேரத்தில் பெற்ற மாறிகளின் அணுக்கத்தை, அவற்றின் காலமுழுமைக்கும் தக்கவைத்துக்கொள்கின்றன. கீழேயுள்ள படத்தில் ஒவ்வொரு செயற்கூற்றின் அணுக்கமும் தெளிவாகக்காட்டப்பட்டுள்ளது.
செயற்கூற்றுக்கான அணுக்கம் உள்ளவரை, அதன்வரம்புகள் (scope) உயிர்ப்புடன் இருப்பதையே சூழச்சுருட்டு (closure) என்கிறோம்.
இதில் மற்றொரு முக்கியமான விசயம் என்னவென்றால், ஜாவாஸ்கிரிப்ட் போன்ற மொழிகளில், மாறிகள் நிலைமாறாத்தன்மை கொண்டிருப்பதில்லை. எனவே, செயற்கூறுகள் உருவாக்கப்பட்ட காலத்தில் கொண்டிருந்தமதிப்புகள், இயங்கும்காலத்தில் மாற்றப்பட்டிருக்க வாய்ப்பிருக்கிறது. இதனை பின்வரும் எடுத்துக்காட்டு விளக்குகிறது.
[code lang=”javascript”]
for(var i = 0; i < 3; i++) {
setTimeout(function() { alert(i); }, 500 + i);
}
[/code]
இங்கே alert செயற்கூற்றுக்கு கொடுக்கப்பட்ட மாறியான iஇன் மதிப்பு, ஒவ்வொரு சுற்றுக்கும் மாற்றப்படுகிறது. எனவே, உருவாக்ககாலத்தில் அதற்கு 0, 1, 2 என்ற மதிப்புகள் கொடுக்கப்பட்டிருந்தாலும், இயங்கும்போது அதன்மதிப்பு 3 என இருப்பதால், மூன்றுமுறையும் alert-இல் 3 என்ற எண்ணே காட்டப்படுகிறது.
ஆனால், செயற்கூறிய நிரலாக்கமொழிகளில் மாறிகள் நிலைமாறாத்தன்மை கொண்டிருக்கின்றன. எனவே, உருவாக்ககாலத்தில் கொடுக்கப்பட்ட மதிப்பு, ஒருபோதும் மாறுவதில்லை.
மூலம்: Charles Scalfani எழுதிய கட்டுரைத்தொடரின் தமிழாக்கம். அவரது அனுமதியோடு மொழிபெயர்க்கப்பட்டுள்ளது.