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

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

Node.js இல் நிகழ்வுகள் மற்றும் அழைப்புகள்

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

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

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

Node.js இல் மீண்டும் அழைப்பைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே:

// 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 அழைப்பை உருவாக்குவது அல்லது தரவுத்தளத்தை வினவுவது). இது ஒரு கால்பேக் செயல்பாட்டை ஒரு வாதமாக எடுத்துக்கொள்கிறது.

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

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

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

ஒத்திசைவைக் கையாள வாக்குறுதிகள் மற்றும் ஒத்திசைவு/காத்திருப்பு ஆகியவற்றைப் பயன்படுத்துதல்

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

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

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

// 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 (அல்லது ஏதேனும் ஒத்திசைவற்ற செயல்பாடு) இலிருந்து தரவைப் பெறுவதை உருவகப்படுத்த செயல்பாட்டைப் பயன்படுத்துகிறோம் . resolveஇந்த செயல்பாடு ஒரு வாக்குறுதியை வழங்குகிறது, அங்கு தரவைத் திரும்பப் பெறுவதற்கான செயல்பாட்டை அழைக்கிறோம் .

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

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

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

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