பாகம் 2 : node.js தமிழில்

ஆரம்ப காலங்களில் ஒருவர் ஒரு கணனியில் ஒரு தடவையில் ஒரு செயலை மட்டும் நிகழ்தும் நிலமையே இருந்தது. அதற்கான காரணம் அக்காலத்துக் கணனிகளின் வினைத்திறனும் கணனி வலையமைப்புகளின் குறைபாடுகளேயாகும். ஆயினும் காலவோட்டத்தில் கணனிகளின் வினைத்திறன் கூடிவிட்டமையுடன் கணனி வலையமைப்புகள் புதிய ஒரு நிலையைப் பெற்றுவிட்டன. குறிப்பாக இன்றைய இணையப் புரட்சி காரணமாக செயிலிகள் ஒரு செயலிற்காக காத்திருக்க வேண்டும் எனும் நிலமை மாறத் தொடங்கியது. Blocking Programming எனும் முறமையின் அழிவு இதனுடனேயே ஆரம்பமாகியது.

Multi-threading எனும் செயன்முறை இன்றைய ஜாவா, சீசார்ப் போன்ற மொழிகளில் கோலோச்சுகின்றது. இது பல செயல்களை ஒன்றை ஒன்று தடுக்காமல் சமாந்தரமாக இயகப்பபடுகின்றது.ஆயினும் இது சிலவேளைகளில் மென்பொருள் வல்லுனர்களுக்கு தலையிடியாக அமைந்துவிடும். இந்த Multi-Threading முறை மூலம் ஒரே வளத்தை இரண்டு Threads அணுக முயன்று Deadlock எல்லாம் வந்துவிடக்கூடய வாய்ப்புகள் உண்டு. ஆயினும் பயப்படவேண்டாம் இவற்றை எல்லாம் சமாளிக்க இன்றைய நவீன மென்பொருள் மொழிகளில் வாய்ப்புகள் மற்றும் வசதிகள் உண்டு.

மற்றைய வழங்கிகளில் இருந்து node.js எவ்வாறு வேறுபடுகின்றது

node.js மூலம் வளர்ந்து விரிவடையும் என எண்ணும் எந்தவொரு இணைய வழங்கிக்காவுப் பாவிக்க முடியும். உங்கள் தளம், சேவை விரிவடையும் போது அதற்கேற்றவாறு மாற்றி அமைக்க இடம்தரும் தன்மையை node.js கொண்டிருப்பது அதன் சிறப்பியல்பு.

node.js ஆனது PHP, Java, C# இணைய சேவை வழங்கிகளை (Web Services) விடவும் அதிக வேகமாக இருப்பதற்கான காரணம் node.js இன் பின்ணனியில் சி மொழி இருக்கின்றமையாகும். வழமையாகவே சி மொழியில் எழுதப்படும் செயலிகள் வேகமாக இயங்குவதை நாம் அவதானித்து இருக்கின்றோம்தானே.

தற்போதைய நவீன இணைய சேவை வழங்கிகள் மற்றும் அதை எழுதப் பயன்படும் மொழிகள் பல வேலைகளை ஒரேதடவையில் செய்யும் வல்லமை வாய்ந்தவை (Multi Threading). ஆனால் node.js ஒரு செயலை மட்டுமே ஒருதடவையில் செய்யும். அதாவது தனக்கு வரும் கோரிக்கைகளை ஒரு நிரையாக நிறுத்தி வரிசையாக வரும் கோரிக்கைகளை அலசி ஆராய்ந்து பதில் அனுப்பும். இதன் காரணமாகத்தான் node.js வழங்கியில் ஒரு கோரிக்கை ஏதோவொரு காரணத்தால் பிழையடைந்தால் முற்றுமுழுதாக வழங்கியே செயல்இழந்துவிடும்.

அப்படியானால் வரிசையில் வைத்து ஒன்றொன்றாகத்தான் தனக்கு வரும் கோரிக்கைகளை பரீசிலிக்குமானால் எப்படி அத்தனை வேகமாக இயங்குகின்றது? ஒரு இணையசேவைக் கோரிக்கை நீண்ட நேரம் எடுத்துவிட்டால் அடுத்த கோரிக்கைகள் இன்னும் நேரமாகுமே? இப்படியெல்லாம் கேள்விகள் எழக்கூடும். இதற்கு node.js இன் பதில்தான் Event driven programming & Callback functions எனப்படும் முறைமை.

Event driven programming & Callback செயன்முறை என்றால் என்ன

அதாவது நீங்கள் ஒரு வேலையை செய்ய இணைய வழங்கியிடும் கோருகின்றீர்கள் அந்த வேலை முடியும் வரை node.js காத்திருக்காது அந்த வேலைக்கான உத்தரவை வழங்கிவிட்டு அடுத்த கோரிக்கையைப் பரிசீலிக்கத்தொடங்கிவிடும். முதல் கோரிக்கை நிறைவேற்றப்பட்டதும் Callback function அழைக்கப்பட்டு பதில் சேவையை கோரியவரிற்கு வழங்கப்படும். என்ன குளப்பமாக உள்ளதா?

உதாரணமாக அம்மா இன்று கேக் செய்வதாக உத்தேசித்துள்ளார். அதே வேளை நீங்கள் எனக்கு புடிங் வேண்டும் என்று கேட்கின்றீர்கள். இப்போது அம்மாவிடும் இரண்டு கோரிக்கைகள் உள்ளன. முதலில் புடிங் செய்வதற்கான உள்ளுடன்கள் இப்போது வீட்டில் இல்லை. அவர் உங்களை முன்னால் இருக்கும் கடையில் சென்று புடிங் செய்வதற்கான பொருட்களை வாங்கிவருமாறு கூறுகின்றார். நீங்கள் புடிங் செய்யத் தேவையான பொருட்களை வாங்கிவரும் வரை காத்திருக்காமல் உங்களை அனுப்பிவிட்டு கேக் செய்யும் வேலையை ஆரம்பித்துவிடுவார். பொருட்களுடன் நீங்கள் மறுபடியும் வந்து அம்மாவை அழைப்பதாக வைத்துக்கொள்ளுவோம். அழைத்து அவரிடனம் பொருட்களைக் கொடுக்கின்றீர்கள். இவ்வாறு அழைப்பதையே Callback function என்று அழைகின்றார்கள். இப்போது அம்மா புடிங் வேலையை முடித்துவிடுவார். அப்படியே அரைவாசியில் தொங்கும் கேக் வேலையையும் முடித்துவிடுவார்.

node.js படிக்க வந்தா இவன் என்ன புடிங், கேக், டோனட் எண்டு கடுப்பேத்துறான் என்று நீங்கள் நெருமுவது காதில் கேட்கின்றது. சரி அடுத்து ஒரு Callback function க்கான ஒரு உதாரணத்தைப் பார்த்துவிடுவோமா?

// முறை ஒன்று
fs.readFile('index.html', function(err, contents){
	// கோப்பின் உள்ளடக்கத்தை கன்சோலில் எழுதுகின்றோம்
	console.log(contents);
)};

// முறை இரண்டு
var callback = function(err, contents){
	console.log(contents);
};
fs.readFile('index.html', callback);

முழுமையான உதாரணம்

var fs = require('fs');

fs.readFile('index.html', function (err, data) {
  if (err) throw err;
  console.log(data);
});

index.html எனும் கோப்பு உங்கள் app.js உள்ள கோப்புறையில் உள்ளமையை உறுதிப்படுத்துமாறு கேட்டுக்கொள்கின்றேன். வழமையான மென்பொருள் எழுதும் வழிமுறையில் பொதுவாக functionகள் ஒரு முடிவை இயக்க முடிவில் வெளியனுப்பும்(return). ஆயினும் node.js பயன்படுத்தும் Event Driven Programming இல் முடிவை வெளியனுப்புவதற்குப் பதிலாக இயக்கம் முடிவடைந்ததும் அழைக்கப்படவேண்டிய function ஐக் குறிப்பிடுகின்றோம். நீண்ட நேரம் எடுக்கும் I/O இயக்கங்கள் முடிவடைந்ததும் அந்த function அழைக்கப்படும். இதன் மூலம் காத்திருக்கும் நேரம் கணிசமாகக் குறைக்கப்படுகின்றது.

node இல் கோப்புகளை திறந்து வாசிக்க File System எனும் Module ஐப் பயன்படுத்தலாம். இன்றைய பாகத்தில் callback function பற்றி அறிந்து கொண்டோம். இனி அடுத்த அத்தியாயத்தில் node.js பற்றி மேலும் அறிந்து கொள்ளலாம்.

அடுத்த திங்கள் கிழமை வெளிவரும் பதிவில் nodejs இன் Package Manager பற்றி விரிவாக அறிந்து கொள்ளலாம். பொறுமையாகப் படித்தமைக்கு நன்றி.

செயலியை இங்கே பதிவிறக்கிக்கொள்ளலாம்

5 thoughts on “பாகம் 2 : node.js தமிழில்”

  1. வேண்hம்பா இந்த வம்பு…. தலையைச் சுற்றுகிறது!

  2. எனக்கு சம்பந்தமே இல்லாத துறையென்றாலும் நன்றாக புரிகிறது.எளிமையான நடையில் உள்ளது.

  3. event
    னிகல்வு

    event-driven
    னிகல்வு இயக்கம்

    event-driven environment
    னிகல்வு இயக்கச் சூலல்

    event-driven language
    னிகல்வு இயக்க மொலி

    event-driven processing
    னிகல்வு இயக்கச் செயலாக்கம்

    event-driven program
    னிகல்வு இயக்கக் கட்டலய்னிரல்

    event-driven programming
    னிகல்வு இயக்கக் கட்டலய்னிரலாக்கம்

    event handler
    னிகல்வுக் கய்யாலி

    event service routine
    னிகல்வுச் சேவய் னடய்முரய்

Leave a Reply