Node.js இல் நிகழ்வுகள் மற்றும் ஒத்திசைவின்மை ஆகியவற்றைக் கையாளுதல்

Node.js பயன்பாடுகளை உருவாக்கும் செயல்பாட்டில், நிகழ்வைக் கையாளுதல் மற்றும் ஒத்திசைவற்ற செயலாக்கத்தைப் புரிந்துகொள்வதும் வேலை செய்வதும் முக்கியம். Node.js ஒரு நிகழ்வு-உந்துதல் மற்றும் ஒத்திசைவற்ற மாதிரியில் கட்டமைக்கப்பட்டுள்ளது, இது பணிகளை முடிவடையும் வரை காத்திருக்காமல் செயல்படுத்த அனுமதிக்கிறது. உண்மையில், நிகழ்வைக் கையாளுதல் மற்றும் ஒத்திசைவற்ற செயலாக்கத்தைப் புரிந்துகொள்வது மற்றும் சரியாகப் பயன்படுத்துவது பயன்பாட்டின் செயல்திறனை மேம்படுத்துவதில் இன்றியமையாத பகுதியாகும்.

callback Node.js இல் நிகழ்வுகள் மற்றும் நிகழ்வுகள்

Node.js இல், callback ஒத்திசைவற்ற செயல்பாடுகளைக் கையாள்வதில் நிகழ்வுகள் மற்றும் கள் முக்கிய பங்கு வகிக்கின்றன. நிகழ்வுகள் என்பது ஒரு பயன்பாட்டில் நிகழும் சில செயல்கள் அல்லது நிகழ்வுகளைக் கையாளவும் பதிலளிக்கவும் ஒரு வழியாகும். Callback s, மறுபுறம், ஒரு குறிப்பிட்ட நிகழ்வு அல்லது செயல்பாடு முடிந்ததும் செயல்படுத்தப்படும் செயல்பாடுகள்.

Node.js ஒரு நிகழ்வு-உந்துதல் கட்டமைப்பை வழங்குகிறது, அங்கு பயன்பாட்டின் வெவ்வேறு பகுதிகள் நிகழ்வுகளை வெளியிடலாம் மற்றும் அவற்றைக் கேட்கலாம். ஒரே நேரத்தில் பல செயல்பாடுகளை திறமையான மற்றும் தடுக்காத செயலாக்கத்தை இது அனுமதிக்கிறது.

Callback s பொதுவாக Node.js இல் ஒத்திசைவற்ற செயல்பாடுகளைக் கையாளப் பயன்படுகிறது. அவை செயல்பாடுகளுக்கு வாதங்களாக அனுப்பப்பட்டு, செயல்பாடு முடிந்ததும் செயல்படுத்தப்படும். Callback ஒத்திசைவற்ற பணிகளின் போது ஏற்படும் முடிவுகள் அல்லது பிழைகளைக் கையாள s ஒரு வழியை வழங்குகிறது.

Node.js இல் பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே callback:

// A function that takes a callback
function fetchData(callback) {  
  // Simulate fetching data from an asynchronous operation  
  setTimeout(() => {  
    const data = { name: 'John', age: 30 };  
    callback(null, data); // Pass the data to the callback  
  }, 2000); // Simulate a 2-second delay  
}  
  
// Call the fetchData function and provide a callback  
fetchData((error, data) => {  
  if(error) {  
    console.error('Error:', error);  
  } else {  
    console.log('Data:', data);  
  }  
});  

இந்த எடுத்துக்காட்டில், fetchData ஒரு ஒத்திசைவற்ற செயல்பாட்டிலிருந்து தரவைப் பெறுவதை உருவகப்படுத்தும் ஒரு செயல்பாடு எங்களிடம் உள்ளது(எ.கா., API அழைப்பை உருவாக்குவது அல்லது தரவுத்தளத்தை வினவுவது). இது ஒரு callback செயல்பாட்டை ஒரு வாதமாக எடுத்துக்கொள்கிறது.

செயல்பாட்டின் உள்ளே, ஒத்திசைவற்ற செயல்பாட்டை உருவகப்படுத்தப் fetchData பயன்படுத்துகிறோம். setTimeout 2-வினாடி தாமதத்திற்குப் பிறகு, நாங்கள் சில மாதிரித் தரவை உருவாக்கி, ஒரு பிழையுடன் செயல்பாட்டிற்கு அனுப்புகிறோம்(இது இந்த வழக்கில் callback அமைக்கப்பட்டுள்ளது). null

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

callback ஒத்திசைவற்ற செயல்பாடுகளைக் கையாள Node.jsஐப் பயன்படுத்துவதற்கும், தரவு கிடைத்தவுடன் செயலாக்கப்படுவதை உறுதி செய்வதற்கும் இது ஒரு அடிப்படை எடுத்துக்காட்டு. நிஜ உலகக் காட்சிகளில், callback தரவுத்தள வினவல்கள், API கோரிக்கைகள் மற்றும் பிற ஒத்திசைவற்ற பணிகளைக் கையாள பொதுவாக கள் பயன்படுத்தப்படுகின்றன.

s ஐப் பயன்படுத்துதல் Promise மற்றும் ஒத்திசைவற்ற தன்மையைக் கையாளுதல் async/await

"ஒத்திசைவற்ற செயல்பாடுகளைப் பயன்படுத்துதல் Promise மற்றும் கையாளுதல்" என்பது Node.js இல் ஒத்திசைவற்ற பணிகளை எளிதான மற்றும் திறமையான முறையில் கையாளும் பொதுவான அணுகுமுறையாகும். ஒத்திசைவற்ற செயல்பாடுகளை நிர்வகிக்கவும் கையாளவும் உதவும் ஒரு பொருளாகும், அதே சமயம் ஒத்திசைவற்ற குறியீட்டைப் போலவே ஒத்திசைவற்ற குறியீட்டை எழுத அனுமதிக்கும் தொடரியல் ஆகும். async/await Promise JavaScript async/await

Promise மற்றும் பயன்படுத்துவதன் மூலம், ஒத்திசைவற்ற குறியீட்டை மிகவும் எளிதாகவும் உள்ளுணர்வுடனும் எழுதலாம். ஒத்திசைவற்ற செயல்பாடுகளைக் கையாள நாம் இனி செயல்பாடுகளைப் பயன்படுத்த வேண்டியதில்லை மற்றும் நரகத்துடன்(உள்ளமைக்கப்பட்ட செயல்பாடுகள்) சமாளிக்க வேண்டியதில்லை. அதற்குப் பதிலாக, a முடிவடையும் வரை காத்திருந்து அதன் முடிவைத் தர காத்திருக்கும் முக்கிய சொல்லைப் பயன்படுத்தலாம். async/await callback callback callback Promise

ஒத்திசைவற்ற செயல்பாடுகளைக் கையாள Node.js ஐப் Promise பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே: async/await

// A mock function to fetch data from an API  
function fetchData() {  
  return new Promise((resolve, reject) => {  
    setTimeout(() => {  
      const data = { name: 'John', age: 30 };  
      resolve(data); // Return data within the Promise  
    }, 2000);  
  });  
}  
  
// Using async/await to handle asynchronous operations  
async function getData() {  
  try {  
    const data = await fetchData(); // Wait for the Promise to complete and return the data  
    console.log('Data:', data);  
  } catch(error) {  
    console.error('Error:', error);  
  }  
}  
  
// Call the getData function  
getData();  

fetchData இந்த எடுத்துக்காட்டில், API(அல்லது ஏதேனும் ஒத்திசைவற்ற செயல்பாடு) இலிருந்து தரவைப் பெறுவதை உருவகப்படுத்த செயல்பாட்டைப் பயன்படுத்துகிறோம். இந்த செயல்பாடு a ஐ வழங்குகிறது, அங்கு தரவைத் திரும்பப்பெற செயல்பாட்டை Promise அழைக்கிறோம். resolve

செயல்பாட்டிற்கு வெளியே, பிழைகளைக் கையாள fetchData ஒரு தொகுதியைப் பயன்படுத்துகிறோம். try/catch செயல்பாட்டில், தரவை முடிக்க மற்றும் திரும்பும் வரை காத்திருக்க முக்கிய சொல்லைப் getData பயன்படுத்துகிறோம். இல் பிழை இருந்தால், அது ஒரு விதிவிலக்கைத் தூக்கி எறியும், அதைத் தொகுதியில் கையாளுவோம். await Promise Promise catch

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

ஒத்திசைவற்ற செயல்பாடுகளைக் கையாளும் போது எங்கள் குறியீட்டைப் பயன்படுத்தி மேலும் படிக்கக்கூடியதாகவும் புரிந்துகொள்ள எளிதாகவும் Promise செய்கிறது. இது நரகத்தைத் தவிர்க்க உதவுகிறது மற்றும் ஒத்திசைவான குறியீட்டை எழுதுவதைப் போன்றே வரிசைமுறை முறையில் குறியீட்டை எழுத அனுமதிக்கிறது. async/await callback

முடிவு: நிகழ்வு கையாளுதல் மற்றும் ஒத்திசைவற்ற செயலாக்கம் ஆகியவை Node.js பயன்பாடுகளின் வளர்ச்சியில் இரண்டு முக்கிய அம்சங்களாகும். தொடர்புடைய கருத்துகள் மற்றும் கருவிகளைப் புரிந்துகொண்டு சரியாகப் பயன்படுத்துவதன் மூலம், நீங்கள் Node.js இயங்குதளத்தில் திறமையான, நெகிழ்வான மற்றும் நம்பகமான பயன்பாடுகளை உருவாக்கலாம்.