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

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

 

callback Node.js માં ઇવેન્ટ્સ અને એસ

Node.js માં, ઘટનાઓ અને callback s અસુમેળ કામગીરીને નિયંત્રિત કરવામાં નિર્ણાયક ભૂમિકા ભજવે છે. ઇવેન્ટ્સ એ એપ્લિકેશનમાં બનતી અમુક ક્રિયાઓ અથવા ઘટનાઓને હેન્ડલ કરવાની અને તેનો પ્રતિસાદ આપવાની રીત છે. 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 અસુમેળ કામગીરીને હેન્ડલ કરવા અને એકવાર ડેટા ઉપલબ્ધ થાય તે પછી તેની પ્રક્રિયા કરવામાં આવે તેની ખાતરી કરવા માટે નોડ.જેએસમાં ઉપયોગ કરવાનું આ મૂળભૂત ઉદાહરણ છે. વાસ્તવિક દુનિયાના દૃશ્યોમાં, callback ડેટાબેઝ ક્વેરીઝ, API વિનંતીઓ અને અન્ય અસુમેળ કાર્યોને હેન્ડલ કરવા માટે સામાન્ય રીતે s નો ઉપયોગ થાય છે.

 

s નો ઉપયોગ કરવો Promise અને અસમકાલીનતાને હેન્ડલ કરવા async/await

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

ઉપયોગ કરીને Promise અને, અમે અસુમેળ કોડ વધુ સરળતાથી અને સાહજિક રીતે લખી શકીએ છીએ. અસુમેળ કામગીરીને હેન્ડલ કરવા માટે આપણે હવે ફંક્શન્સનો ઉપયોગ કરવાની અને હેલ(નેસ્ટેડ ફંક્શન્સ) સાથે વ્યવહાર કરવાની જરૂર નથી. તેના બદલે, અમે a પૂર્ણ થવાની રાહ જોવા અને તેનું પરિણામ પરત કરવા માટે await કીવર્ડનો ઉપયોગ કરી શકીએ છીએ. 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 પ્લેટફોર્મ પર કાર્યક્ષમ, લવચીક અને વિશ્વસનીય એપ્લિકેશનો બનાવી શકો છો.