ஜாவாஸ்கிரிப்ட்டின் ஒற்றை நூல் தன்மை (Single-Threaded Nature of JavaScript)

ஜாவாஸ்கிரிப்ட் என்பது ஒற்றை நூல் நிரலாக்க மொழியாகும் (single-threaded programming language), இது ஒரு முக்கிய நூலில் (main thread) குறியீட்டை வரிசையாகச் (sequentially) செயல்படுத்துகிறது. வலைப் பயன்பாடுகளில் பதிலளிக்கும் தன்மையை (responsiveness) உறுதிசெய்து, முக்கிய நூலைத் தடுக்காமல் (without blocking) பணிகளைத் திறமையாகக் கையாள, தடுப்பற்ற ஒத்திசைவற்ற வடிவங்களை (non-blocking asynchronous patterns) இது நம்பியுள்ளது. இது ஒத்திசைவை (concurrency) எளிதாக்கும் அதே வேளையில், கால்பேக்குகள் (callbacks) மற்றும் நிகழ்வு உந்துதல் (event-driven) நிரலாக்கத்தின் திறம்படப் பயன்பாடு தேவைப்படுகிறது.

ஒற்றை நூல் ஜாவாஸ்கிரிப்ட்டைப் புரிந்துகொள்வது (Understanding Single-Threaded JavaScript)

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

ஒரு நூல், ஒரு பணி (One Thread, One Task): ஜாவாஸ்கிரிப்ட் ஒற்றைச் செயலாக்க நூலிற்குள் (single execution thread) இயங்குகிறது, அதாவது அதால் ஒரு நேரத்தில் ஒரு பணியை மட்டுமே செய்ய முடியும். இந்த நூல் பெரும்பாலும் "முக்கிய நூல் (main thread)" அல்லது "நிகழ்வு லூப் (event loop)" என்று குறிப்பிடப்படுகிறது.
தடுப்பது vs தடுக்காதது (Blocking vs. Non-Blocking): ஜாவாஸ்கிரிப்ட் குறியீடு இயல்பாகவே தடுக்காதது (non-blocking). அதாவது, அதிக நேரம் எடுக்கும் செயல்பாடு (நெட்வொர்க் கோரிக்கை (network request) அல்லது கோப்பு வாசிப்பு (file read) போன்ற) எதிர்கொள்ளப்படும் போது, ஜாவாஸ்கிரிப்ட் அது முடிவடையும் வரை காத்திருக்காது. அதற்குப் பதிலாக, அது பணியைச் சூழலின் மற்றொரு பகுதிக்கு (எ.கா., உலாவி அல்லது Node.js இயக்க நேரம்) அளித்து, மற்ற குறியீட்டைத் தொடர்ந்து செயல்படுத்துகிறது.
ஒத்திசைவற்ற நிரலாக்கம் (Asynchronous Programming): முக்கிய நூலைத் தடுக்காமல் அதிக நேரம் எடுக்கும் செயல்பாடுகளைக் கையாள, ஜாவாஸ்கிரிப்ட் ஒத்திசைவற்ற நிரலாக்க வடிவங்களை (asynchronous programming patterns) பெரிதும் நம்பியுள்ளது. கால்பேக்குகள், பிராமிஸ்கள் (Promises) மற்றும் async/await போன்ற செயல்பாடுகள் டெவலப்பர்களை ஒத்திசைவற்ற செயல்பாடுகளுடன் திறம்படச் செயல்பட அனுமதிக்கின்றன.
நிகழ்வு-உந்துதல் (Event-Driven): ஜாவாஸ்கிரிப்ட் பெரும்பாலும் "நிகழ்வு-உந்துதல்" என விவரிக்கப்படுகிறது. அதாவது பயனர் தொடர்புகள் (கிளிக்குகள், விசை அழுத்தங்கள்), டைமர்கள் (timers) அல்லது நெட்வொர்க் பதில்கள் (network responses) போன்ற நிகழ்வுகளைக் (events) கேட்டு அதற்கேற்பப் பதிலளிக்கிறது. ஒரு நிகழ்வு நிகழும்போது, அதனுடன் தொடர்புடைய கால்பேக் செயல்பாடு செயல்படுத்தப்படுகிறது.
ஒருங்கிணைப்பு மாதிரி (Concurrency Model): ஜாவாஸ்கிரிப்ட் ஒற்றை நூலில் இயங்கும் அதே வேளையில், ஒத்திசைவு மாதிரியானது குறியீட்டின் ஒருங்கிணைந்த செயலாக்கத்தை செயல்படுத்துகிறது. பதிலளிக்கும் தன்மை மற்றும் தடுக்காத நடத்தை (non-blocking behavior) ஆகியவற்றை உறுதி செய்யும் வகையில் ஒத்திசைவற்ற பணிகளைச் செயல்படுத்துவதை நிர்வகிக்கும் நிகழ்வு லூப் (event loop) போன்ற வழிமுறைகள் மூலம் இது அடையப்படுகிறது.
உலாவி மற்றும் சுற்றுச்சூழல் தொடர்பு (Browser and Environment Interaction): வலை மேம்பாட்டில், ஜாவாஸ்கிரிப்ட் உலாவியின் ஆவணப் பொருள் மாதிரி (Document Object Model - DOM) மற்றும் பிற உலாவி APIகளுடன் தொடர்பு கொள்கிறது. பதிலளிக்கக்கூடிய பயனர் இடைமுகத்தைப் (user interface) பராமரிக்க, ஜாவாஸ்கிரிப்ட் குறியீடு விரைவாகவும் திறமையாகவும் செயல்பட வேண்டும் மற்றும் தேவையான போது தனித்தனி நூல்களுக்கு நேரம் எடுக்கும் செயல்பாடுகளை வழங்க வேண்டும்.

எடுத்துக்காட்டு

// Simulating an asynchronous operation with a callback
function simulateAsyncOperation(callback) {
  setTimeout(function () {
    console.log("Async operation completed.");
    callback();
  }, 2000); // Simulating a 2-second delay
}

console.log("Start of the program");

// Initiating an asynchronous operation
simulateAsyncOperation(function () {
  console.log("Callback executed: Handling the result.");
});

console.log("End of the program");

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

குறியீடு விளக்கம் (Code Explanation):

setTimeout ஐப் பயன்படுத்தி ஒத்திசைவற்ற செயல்பாட்டை உருவகப்படுத்தும் simulateAsyncOperation செயல்பாட்டை (function) நாங்கள் வரையறுக்கிறோம். இந்தச் செயல்பாடு ஒரு கால்பேக்கை ஒரு வாதமாக (argument) எடுத்துக்கொள்கிறது, இது ஒத்திசைவற்ற செயல்பாடு முடிவடையும் போது செயல்படுத்தப்படும்.
"நிரலின் தொடக்கம் (Start of the program)" என்பதை உள்நுழைவதன் (logging) மூலம் நிரலைத் தொடங்குகிறோம்.
simulateAsyncOperation ஐப் பயன்படுத்தி, கால்பேக் செயல்பாட்டைக் கடந்து (passing), ஒத்திசைவற்ற செயல்பாட்டைத் தொடங்குகிறோம். இந்தச் செயல்பாடு 2-வினாடி தாமதத்திற்குப் பிறகு செயல்படுத்தப்படும்.
ஒத்திசைவற்ற செயல்பாட்டைத் தொடங்கிய உடனேயே, "நிரலின் முடிவு (End of the program)" என்பதை உள்நுழைகிறோம்.

செயலாக்க ஓட்டம் (Execution Flow):

இந்த குறியீட்டை நீங்கள் இயக்கும்போது, ஒத்திசைவற்ற செயல்பாடு முடிவதற்கு 2 வினாடிகள் எடுத்தாலும், நிரல் தடுப்பதில்லை (does not block) என்பதை நீங்கள் கவனிப்பீர்கள். "நிரலின் முடிவு (End of the program)" செய்தியானது ஒத்திசைவற்ற செயல்பாட்டைத் தொடங்கிய உடனேயே உள்நுழைந்து, ஜாவாஸ்கிரிப்ட்டின் தடுக்காத நடத்தையை (non-blocking behavior) விளக்குகிறது.
2-வினாடி தாமதத்திற்குப் பிறகு, "ஒத்திசைவற்ற செயல்பாடு முடிந்தது (Async operation completed)" செய்தி உள்நுழையும், அதைத் தொடர்ந்து "கால்பேக் செயல்படுத்தப்பட்டது: முடிவைக் கையாளுதல் (Callback executed: Handling the result)", ஒத்திசைவற்ற செயல்பாடு முடிந்ததும் கால்பேக் செயல்பாடு செயல்படுத்தப்பட்டதைக் குறிக்கிறது.

முக்கியத் தகவல்கள் (Key Takeaways):

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

நன்மைகள் மற்றும் சவால்கள் (Benefits and Challenges)

நன்மைகள்:

எளிமை (Simplicity): ஒற்றை-நூல் செயலாக்கமானது நிரலாக்க மாதிரியை (programming model) எளிதாக்குகிறது மற்றும் சிக்கலான ஒருங்கிணைப்பு (concurrency) தொடர்பான பிழைகளின் (bugs) அபாயத்தைக் குறைக்கிறது.
கணிப்புத்தன்மை (Predictability): ஒற்றை நூல் தன்மை, செயல்படுத்தும் வரிசை (order of execution) மற்றும் உங்கள் நிரலின் நிலை குறித்துக் காரணத்தைக் கூறுவதை (reason about) எளிதாக்குகிறது.

சவால்கள்:

தடுக்கும் செயல்பாடுகள் (Blocking Operations): நீண்ட நேரம் இயங்கும் செயல்பாடுகள் முக்கிய நூலைத் தடுக்கலாம், இது மோசமான பயனர் அனுபவத்திற்கு வழிவகுக்கும், குறிப்பாக வலைப் பயன்பாடுகளில்.
கால்பேக் நரகம் (Callback Hell): கால்பேக்குகளை அதிகமாகப் பயன்படுத்துவது (பெரும்பாலும் "கால்பேக் நரகம்" என்று குறிப்பிடப்படுகிறது) குறியீட்டைப் படிக்கவும் பராமரிக்கவும் கடினமாக்கும்.
ஒருங்கிணைப்பு இடையூறு (Concurrency Bottleneck): ஜாவாஸ்கிரிப்ட் ஒற்றை நூலில் இயங்குவதால் CPU-பிணைக்கப்பட்ட (CPU-bound) பணிகளால் பல மையச் செயலிகளை (multi-core processors) முழுமையாகப் பயன்படுத்த முடியாது.

ஜாவாஸ்கிரிப்ட்டின் ஒற்றை நூல் தன்மை மொழியின் வரையறுக்கும் அம்சமாகும். இது நிரலாக்கத்தின் சில அம்சங்களை எளிதாக்கும் அதே வேளையில், ஒத்திசைவற்ற பணிகளைக் கையாள்வது மற்றும் பதிலளிக்கக்கூடிய பயன்பாடுகளை (responsive applications) உறுதி செய்வது போன்ற சவால்களை அளிக்கிறது. ஜாவாஸ்கிரிப்ட் டெவலப்பர்களுக்கு ஒத்திசைவற்ற வடிவங்களின் (asynchronous patterns) பயனுள்ள பயன்பாடு மற்றும் நிகழ்வு உந்துதல் மாதிரியைப் (event-driven model) புரிந்துகொள்வது அவசியம்.

ஒற்றை நூல் தன்மை