Node.js
Async / का इंतजार

परिचय

Async Functions with Try-Catch Error हैंडलिंग

एसिंक्स / वेट सिंटैक्स की सबसे अच्छी विशेषताओं में से एक यह है कि मानक कोशिश-कैच कोडिंग शैली संभव है, जैसे आप सिंक्रोनाइज़ कोड लिख रहे थे।

const myFunc = async (req, res) => {
  try {
    const result = await somePromise();
  } catch (err) {
    // handle errors here
  }
});

यहाँ एक उदाहरण है एक्सप्रेस और वादा- mysql:

router.get('/flags/:id', async (req, res) => {

  try {

    const connection = await pool.createConnection();

    try {
      const sql = `SELECT f.id, f.width, f.height, f.code, f.filename
                   FROM flags f
                   WHERE f.id = ?
                   LIMIT 1`;
      const flags = await connection.query(sql, req.params.id);
      if (flags.length === 0)
        return res.status(404).send({ message: 'flag not found' });

      return res.send({ flags[0] });

    } finally {
      pool.releaseConnection(connection);
    }

  } catch (err) {
    // handle errors here
  }
});

वादे और Async / Await के बीच तुलना

वादों का उपयोग कर समारोह:

function myAsyncFunction() {
    return aFunctionThatReturnsAPromise()
           // doSomething is a sync function
           .then(result => doSomething(result))
           .catch(handleError);
}

तो यहाँ है जब Async / Await हमारे फ़ंक्शन को साफ़ करने के लिए कार्रवाई में प्रवेश करता है:

async function myAsyncFunction() {
  let result;

  try {
      result = await aFunctionThatReturnsAPromise();
  } catch (error) {
      handleError(error);
  }

  // doSomething is a sync function
  return doSomething(result);
}

तो कीवर्ड async return new Promise((resolve, reject) => {...} लिखने के समान होगा।

और then कॉलबैक में अपना परिणाम प्राप्त करने के लिए इसी तरह की await करें।

यहाँ मैं एक बहुत संक्षिप्त gif छोड़ता हूँ जिसे देखने के बाद मन में कोई संदेह नहीं रह जाएगा:

GIF

कॉलबैक से प्रगति

शुरुआत में कॉलबैक थे, और कॉलबैक ठीक थे:

const getTemperature = (callback) => {
  http.get('www.temperature.com/current', (res) => {
    callback(res.data.temperature)
  })
}

const getAirPollution = (callback) => {
  http.get('www.pollution.com/current', (res) => {
    callback(res.data.pollution)
  });
}

getTemperature(function(temp) {
  getAirPollution(function(pollution) {
    console.log(`the temp is ${temp} and the pollution is ${pollution}.`)
    // The temp is 27 and the pollution is 0.5.
  })
})

लेकिन कॉलबैक के साथ कुछ वास्तव में निराशाजनक मुद्दे थे इसलिए हम सभी ने वादों का उपयोग करना शुरू कर दिया।

const getTemperature = () => {
  return new Promise((resolve, reject) => {
    http.get('www.temperature.com/current', (res) => {
      resolve(res.data.temperature)
    })
  })
}

const getAirPollution = () => {
  return new Promise((resolve, reject) => {
    http.get('www.pollution.com/current', (res) => {
      resolve(res.data.pollution)
    })
  })
}

getTemperature()
.then(temp => console.log(`the temp is ${temp}`))
.then(() => getAirPollution())
.then(pollution => console.log(`and the pollution is ${pollution}`))
// the temp is 32
// and the pollution is 0.5

यह थोड़ा बेहतर था। अंत में, हमें async / प्रतीक्षा मिली। जो अभी भी हुड के तहत वादों का उपयोग करता है।

const temp = await getTemperature()
const pollution = await getAirPollution()

प्रतीक्षा पर निष्पादन रोक देता है

यदि वादा कुछ भी वापस नहीं करता है, तो async कार्य को await का उपयोग करके पूरा किया जा सकता है।

try{
    await User.findByIdAndUpdate(user._id, {
        $push: {
            tokens: token
        }
    }).exec()
}catch(e){
    handleError(e)
}