Closures

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

Closures என்றால் என்ன?

ஒரு closure என்பது ஒரு செயல்பாடாகும், இது வெளிப்புறச் செயல்பாடு செயல்படுத்தி முடிந்த பிறகும் அதன் உள்ளடக்க (இணைக்கும்) சொற்பொருள் நோக்கத்திலிருந்து மாறிகளுக்கான அணுகலைத் தக்கவைத்துக் கொள்கிறது. எளிமையான வார்த்தைகளில் கூறுவதானால், ஒரு closure மாறிகளை "closes over" செய்து, அவற்றின் மதிப்புகளைப் பாதுகாக்கிறது, மேலும் உள் செயல்பாடுகளை அவற்றை அணுக அனுமதிக்கிறது.

Closures எவ்வாறு செயல்படுகின்றன

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

1. செயல்பாடு வரையறை (Function Definition): ஒரு செயல்பாடு மற்றொரு செயல்பாட்டிற்குள் வரையறுக்கப்படுகிறது.

2. மாறி குறிப்பு (Variable Reference): உள் செயல்பாடு வெளிப்புற செயல்பாட்டிலிருந்து மாறிகளைக் குறிக்கிறது.

3. ஒரு Closure உருவாக்கம்: உள் செயல்பாடு உருவாக்கப்படும்போது, அது ஒரு closure ஐ உருவாக்குகிறது, அது குறிக்கும் மாறிகளைப் பிடிக்கிறது.

4. இணைக்கும் நோக்கத்திற்கான அணுகல் (Access to Enclosing Scope): வெளிப்புறச் செயல்பாடு செயல்படுத்துவதை முடித்த பின்னரும், உள் செயல்பாடானது வெளிப்புற செயல்பாட்டிலிருந்து மாறிகளை அணுகிப் பயன்படுத்த முடியும்.

நடைமுறை எடுத்துக்காட்டு

ஒரு நடைமுறை எடுத்துக்காட்டுடன் closures ஐ விளக்குவோம்:

function outerFunction() {
  const outerVariable = 'நான் வெளிப்புற செயல்பாட்டிலிருந்து வந்தவன்';

  function innerFunction() {
    console.log(outerVariable);
  }

  return innerFunction;
}

const closureFunction = outerFunction(); // ஒரு closure ஐ உருவாக்குகிறது
closureFunction(); // "நான் வெளிப்புற செயல்பாட்டிலிருந்து வந்தவன்" என பதிவு செய்கிறது

இந்த எடுத்துக்காட்டில், outerFunction outerVariable ஐ வரையறுக்கிறது, மற்றும் innerFunction அதன் எல்லைக்குள் outerVariable ஐ அணுகுகிறது. outerFunction அழைக்கப்படும்போது மற்றும் closureFunction அது திரும்பப் பெறும் மதிப்பிற்கு ஒதுக்கப்படும்போது, அது outerVariable க்கான அணுகலைத் தக்கவைக்கும் ஒரு closure ஐ உருவாக்குகிறது. பின்னர், closureFunction அழைக்கப்படும்போது, outerFunction செயல்படுத்துவதை முடித்திருந்தாலும், அதற்கு outerVariable அணுகல் உள்ளது.

Closures க்கான பயன்பாட்டு வழக்குகள்

Closures ஜாவாஸ்கிரிப்டில் பல்வேறு நடைமுறை பயன்பாட்டு வழக்குகளைக் கொண்டுள்ளன, அவற்றுள்:

• தரவு உறைபொதியாக்கம் (Data Encapsulation): Closures தரவை இணைக்கவும் பாதுகாக்கவும் பயன்படுத்தப்படலாம், இது வெளியிலிருந்து அணுக முடியாததாக ஆக்குகிறது. பல வடிவமைப்பு வடிவங்களில் இது ஒரு அடிப்படைக் கருத்தாகும்.

• செயல்பாட்டு தொழிற்சாலைகள் (Function Factories): குறிப்பிட்ட நடத்தைகளுடன் செயல்பாடுகளை உருவாக்கும் தொழிற்சாலை செயல்பாடுகளை (factory functions) உருவாக்க closures அனுமதிக்கின்றன.

• தனிப்பட்ட மாறிகள் (Private Variables): வெளிப்புறக் குறியீட்டிலிருந்து சில தரவை மறைத்து, பொருள்களுக்குள் தனிப்பட்ட மாறிகள் மற்றும் முறைகளை உருவாக்க closures உதவுகின்றன.

• Callback செயல்பாடுகள்: ஒத்திசைவற்ற செயல்பாடுகளுக்கு இடையே சூழலையும் தரவையும் பராமரிக்க Callbacks பெரும்பாலும் closures ஐ உள்ளடக்கியிருக்கும்.

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

புத்திசாலித்தனமாகப் பயன்படுத்தப்படாவிட்டால் Closures சக்திவாய்ந்த கருவியாகவும் நினைவக கசிவுகளின் சாத்தியமான ஆதாரமாகவும் இருக்கலாம். எனவே, உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டில் உள்ள கருத்தைப் புரிந்துகொள்வதும் அதை விவேகத்துடன் பயன்படுத்துவதும் முக்கியம்.