Node.js માં ઇવેન્ટ્સ અને અસિંક્રોનિસિટીનું સંચાલન કરવું

Node.js એપની ચર્ચાની પ્રક્રિયા, ઇવેન્ટ હેન્ડલિંગ અને અસુમેળ પ્રક્રિયા સાથે સમજવું અને કામ કરવું અગત્યનું છે. Node.js ઘટના એ-સંચાલિત અને અસુમેળ મોડેલ પર વિચારણા કરે છે, જે પૂર્ણ બંધબેસતા વિના કાર્યને ચલાવવાની શક્તિ આપે છે. હકીકતમાં, ઇવેન્ટ હેન્ડલિંગ અને અસુમેળ પ્રક્રિયાને યોગ્ય રીતે સમજવું અને લાગુ કરવું એ પ્રદર્શન ઑપ્ટિમાઇઝ કરવાનો એપ્લિકેશન ભાગ છે.

Node.js ઇવેન્ટ્સ અને કૉલબેક્સમાં

Node.js માં, ઇવેન્ટ્સ અને કૉલબેક્સ અસુમેળ વ્યવસ્થાપનને નિર્ધારિત કરવામાં આવે છે. ઇવેન્ટ્સ એ એપ્લિકેશનમાં બનેતી ચોક્કસ ક્રિયાઓ અથવા ઘટનાઓ હેન્ડલની મદદથી અને પ્રતિસાદ સમાન છે. બીજી તરફ, કૉલબૅક્સ ફંક્શન્સ છે જે ચોક્કસ ઇવેન્ટ અથવા ઑપરેશન પૂર્ણ થવા પછી ચાલુ કરવામાં આવે છે.

Node.js એક ઇવેન્ટ-આધારિત આર્કિટેક્ચર રચના કરે છે જ્યાં એપ્લિકેશનના વિવિધ પ્રસંગો અને તેમને બહાર કાઢી શકે છે. આ એકસાથે બહુવિધ પ્રક્રિયાની અને કાર્યક્ષમ-અવરોધિત માટે પરવાનગી આપે છે.

અસુમેળ માટે હેન્ડલ કરવા માટે સામાન્ય રીતે Node.js માં કૉલબૅક્સનો ઉપયોગ થાય છે. તેઓને કાર્ય કરવા માટે ફાંસો તરીકે કાર્ય થાય છે અને એકવાર પૂર્ણ થાય છે તે પછી તેને ચલાવવામાં આવે છે. કૉલબેક્સ અસુમેળ કાર્યો દરમિયાન ગતિશીલતા અથવા ભૂલ હેન્ડલનો માર્ગ પૂરો પાડે છે.

Node.j માં કૉલબેકનો ઉપયોગ કરવા માટે અહીં ઉદાહરણ છે:

// 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, અમે setTimeoutઅસુમેળ સ્વાસ્થ્યનું અનુકરણ કરવા માટે ઉપયોગ કરીએ છીએ. 2-સેકન્ડના વિલંબ પછી, અમે કેટલાક નમૂનાઓ ડેટા બનાવીએ છીએ અને તેની ભૂલ સાથે કૉલબેક ફંક્શનમાં પાસપાત છીએ (જે nullઆ કિસ્સામાં સેટ છે).

ફંક્શનની બહાર fetchData, અમે તેને કોલટો છીએ અને કોલબૅક ફંક્શન ઘટતા છીએ. કૉલબેકમાં, અમે કોઈપણ સંભવિત ભૂલોને હેન્ડલ છીએ અને પ્રાપ્ત ડેટા પર પર પ્રક્રિયા કરીએ છીએ. જો કોઈ ભૂલ હોય, તો અમે તેને કન્સોલ પર લૉગટાતા છીએ. નહિંતર, અમે ડેટા લોગતા છીએ.

અસુમેળ પ્રક્રિયાને હેન્ડલ કરવા અને એકવાર ડેટા ઉપલબ્ધ થાય તે પછી તેની ખાતરી કરવા માટે Node.js માં કૉલબેકનો ઉપયોગ આ પસંદગીનું મૂળ ઉદાહરણ છે. વાસ્તવિક દૃશ્ય દૃશ્યોમાં, કૉલબૅક્સનો ઉપયોગ સામાન્ય રીતે ડેટાબેઝ ક્વેરે, API વિનંતીઓ અને અન્ય અસુમેળ કાર્યોને હેન્ડલ કરવા માટે થાય છે.

પ્રોમિસનો ઉપયોગ કરવો અને અસમકાલીન બહુચર્ચિત હેન્ડલ કરવા માટે અસિંક/પ્રતિક્ષા કરો

"અસુમેળ વિકાસને હેન્ડલ કરવા માટે પ્રોમિસ અને અસિંક/પ્રતિક્ષાનો ઉપયોગ કરવો" એ અસુમેળ કાર્યોને સરળ અને કાર્યક્ષમ રીતે હેન્ડલ કરવા માટે Node.js માં એક સામાન્ય અભિગમ છે. પ્રોમિસ એ JavaScript ઑબ્જેક્ટ છે જે અમને અસિંક્રોનસ ઑપરેશન મેનેજ કરવામાં અને હેન્ડલ કરવામાં મદદ કરે છે, જ્યારે async/await એ સિન્ટૅક્સ છે જે અમને સિંક્રનસની કોડ સમાન રીતે અસિક્રોનસ કોડ લખવા દે છે.

વચન અને એસિંક/પ્રતીક્ષાનો ઉપયોગ કરીને, અમે અસુમેળ કોડ વધુ સરળ અને સહજ રીતે લખીએ છીએ. અસિંક્રોન્સ ઑપરેશનને હેન્ડલ કરવા માટે અમારે હવે કૉલબૅક ફંક્શન્સનો ઉપયોગ કરવાની અને કૉલબૅક હેલ (નેસ્ટેડ કૉલબૅક ફંક્શન્સ) સાથે કંપનીની જરૂર નથી. તેના બદલે, અમે કીવર્ડનો ઉપયોગ કરીને પૂર્ણ રાહ જોઈશું અને તેને આગળ ધપાવીશું.

અસુમેળ જોડાણને હેન્ડલ કરવા માટે Node.js માં વચન અને 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();

આ ઉદાહરણમાં, અમે fetchDataAPI (અથવા કોઈપણ અસિંક્રોન્સ ઑપરેશન) માંથી ડેટા પુનઃકરણ અનુકરણ કરવા માટે ફંક્શનનો ઉપયોગ કરીએ છીએ. આ ફંક્શન પ્રોમિસ આપે છે, જ્યાં અમે resolveડેટા આપવા માટે ફંક્શનને કૉલ કરીએ છીએ.

કાર્યની બહાર fetchData, અમે try/catchભૂલને નિયંત્રિત કરવા માટે બ્લોકનો ઉપયોગ અર્થ કરીએ છીએ. ફંક્શનમાં getData, અમે awaitતમારી બદલીનો પૂર્ણાહુતિ રાહ જોવા માટે કીવર્તન ઉપયોગિતા અને ડેટા વર્ડ કાઉન્ટી છીએ. જો પ્રોમિસમાં કોઈ ભૂલ હશે, તો તે અપવાદ કરશે અને અમે તેને બ્લોકમાં હેન્ડલ ભાગ catch.

અંતે, અમે getDataઅસુમેળ પ્રક્રિયા શરૂ કરવા માટે ફંક્શનને કોલોટો કરીએ છીએ. સંપૂર્ણ પૂર્ણ થયા પછી અને ડેટા પૂર્ણ કર્યા પછી પરિણામ કન્સોલ પર લૉગ કરવામાં આવશે.

અસિંક્રોનસ ઑપરેશન્સ સાથે કામકાજ તમારા સમયાંતરે પ્રોમિસ અને અસિંક/પ્રતિક્ષાનો ઉપયોગ અમારા કોડને વધુ વાંચવા માટે યોગ્ય અને પ્રક્રિયામાં સરળ બનાવે છે. તે અમને કૉલબેક હેલને મદદ કરે છે અને અમને સિંક્રનસ કોડ લખવાની જેમ ક્રમિક કોડ લખવાની ખાતરી આપે છે.

નિષ્કર્ષ: Node.js એપ્લિકેશન ડેવલપમેન્ટ ઇવેન્ટ હેન્ડલિંગ અને અસુમેળ પ્રક્રિયા એ બે નિર્ણાયક પરીક્ષાઓ છે. સંબંધિત વિભાવનાઓ અને સાધનોને અને યોગ્ય રીતે ઉપયોગ કરીને, તમે Node.js પ્લેટફોર્મ પર કાર્યક્ષમ, લ્યુચીક અને પ્રતિષ્ઠિત એપ્લિકેશનો બનાવી શકો છો.