एक एसिंक्रोनस फ़ंक्शन और एक फ़ंक्शन के बीच का अंतर जो एक वादा लौटाता है

एक फ़ंक्शन के बीच एक छोटा लेकिन बल्कि महत्वपूर्ण अंतर है जो बस एक वादा और एक फ़ंक्शन देता है जिसे async का उपयोग करके घोषित किया गया था।

निम्नलिखित कोड स्निपेट पर एक नज़र डालें:

 function fn(obj) { const someProp = obj.someProp return Promise.resolve(someProp) } async function asyncFn(obj) { const someProp = obj.someProp return Promise.resolve(someProp) } asyncFn().catch(err => console.error('Catched')) // => 'Catched' fn().catch(err => console.error('Catched')) // => TypeError: Cannot read property 'someProp' of undefined 

जैसा कि आप देख सकते हैं, दोनों कार्यों में एक ही शरीर है जिसमें हम एक तर्क की संपत्ति का उपयोग करने की कोशिश कर रहे हैं जो दोनों मामलों में परिभाषित नहीं है। दोनों कार्यों के बीच एकमात्र अंतर यह है कि asyncFn async का उपयोग करके घोषित किया asyncFn ।

इसका मतलब यह है कि जावास्क्रिप्ट यह सुनिश्चित करता है कि asnycFn फ़ंक्शन एक वादा लौटाता है (या तो सफल होता है या विफल), भले ही इसमें कोई त्रुटि होती है, हमारे मामले में .catch() ब्लॉक इसे पकड़ लेगा।

हालाँकि, fn फ़ंक्शन के मामले में, इंजन को अभी तक नहीं पता है कि फ़ंक्शन एक वादा वापस करेगा, और इसलिए कोड .catch() ब्लॉक तक नहीं पहुंचेगा, त्रुटि पकड़ में नहीं आएगी और कंसोल पर गिर जाएगी।

अधिक जीवन उदाहरण

मुझे पता है कि तुम अब क्या सोच रहे हो:

"जब नरक मैं ऐसी गलती करूंगा?"

अनुमान लगाया?

ठीक है, चलो एक साधारण एप्लिकेशन बनाएं जो बस ऐसा करता है।

मान लीजिए कि हमारे पास एक्सप्रेस और मोंगोडीबी का उपयोग करके बनाया गया एक आवेदन है जो मोंगोडीबी नोड.जेएस चालक का उपयोग करता है। यदि आप मुझ पर विश्वास नहीं करते हैं, तो मैंने इस गीथूब भंडार में सभी स्रोत कोड को रखा है , जिससे आप इसे क्लोन कर सकते हैं और इसे स्थानीय रूप से चला सकते हैं, लेकिन मैं यहां सभी कोड की नकल भी करूंगा।

यहाँ हमारे app.js फ़ाइल है:

 // app.js 'use strict' const express = require('express') const db = require('./db') const userModel = require('./models/user-model') const app = express() db.connect() app.get('/users/:id', (req, res) => { return userModel .getUserById(req.params.id) .then(user => res.json(user)) .catch(err => res.status(400).json({ error: 'An error occured' })) // <===  ! }) app.listen(3000, () => console.log('Server is listening')) 

.catch() ब्लॉक पर करीब से नज़र डालें! यह वह जगह है जहां जादू होगा (नहीं होगा)।

db.js डेटाबेस से कनेक्ट करने के लिए db.js फ़ाइल db.js उपयोग किया जाता है:

 'use strict' const MongoClient = require('mongodb').MongoClient const url = 'mongodb://localhost:27017' const dbName = 'async-promise-test' const client = new MongoClient(url) let db module.exports = { connect() { return new Promise((resolve, reject) => { client.connect(err => { if (err) return reject(err) console.log('Connected successfully to server') db = client.db(dbName) resolve(db) }) }) }, getDb() { return db } } 

और अंत में, हमारे पास एक user-model.js फ़ाइल है जिसमें केवल एक getUserById फ़ंक्शन वर्तमान में परिभाषित किया गया है:

 // models/user-model.js 'use strict' const ObjectId = require('mongodb').ObjectId const db = require('../db') const collectionName = 'users' module.exports = { /** * Get's a user by it's ID * @param {string} id The id of the user * @returns {Promise<Object>} The user object */ getUserById(id) { return db .getDb() .collection(collectionName) .findOne({ _id: new ObjectId(id) }) } } 

यदि आप app.js फ़ाइल को app.js से देखते हैं, तो आप देखेंगे कि जब हम localhost:3000/users/<id> हम getUserById फ़ंक्शन को user-model.js में परिभाषित करते हैं, id पैरामीटर को अनुरोध के रूप में पास करते हैं।

मान लीजिए कि आप निम्नलिखित पते पर जाते हैं: localhost:3000/users/1 । आपको क्या लगता है कि आगे क्या होगा?

ठीक है, अगर आपने उत्तर दिया: "मैं MongoClient से बहुत बड़ी गलती देखूंगा" - आप सही थे। अधिक सटीक होने के लिए, आपको निम्न त्रुटि दिखाई देगी: Error: Argument passed in must be a single String of 12 bytes or a string of 24 hex characters ।

और क्या आपको लगता है कि .catch() ब्लॉक को अगले कोड स्निपेट में कहा जाएगा?

 // app.js // ...  ... app.get('/users/:id', (req, res) => { return userModel .getUserById(req.params.id) .then(user => res.json(user)) .catch(err => res.status(400).json({ error: 'An error occured' })) // <===  ! }) // ...  ... 

नहीं। उसे नहीं बुलाया जाएगा।

और अगर आप एक फ़ंक्शन घोषणा को इस में बदलते हैं तो क्या होता है?

 module.exports = { //  ,    async    ! async findById(id) { return db .getDb() .collection(collectionName) .findOne({ _id: new ObjectId(id) }) } } 

हाँ, आप समझने लगते हैं कि क्या है। हमारा .catch() ब्लॉक कहा जाएगा, और हम पकड़े गए त्रुटि को संसाधित करने और उपयोगकर्ता को दिखाने में सक्षम होंगे।

एक निष्कर्ष के बजाय

मुझे उम्मीद है कि यह जानकारी आप में से कुछ के लिए उपयोगी रही होगी। कृपया ध्यान दें कि यह लेख आपको हमेशा अतुल्यकालिक कार्यों का उपयोग करने के लिए मजबूर करने की कोशिश नहीं कर रहा है - हालांकि वे बहुत अच्छे हैं। उनके पास अपने उपयोग के मामले हैं, लेकिन वे अभी भी वादों पर चीनी की मात्रा में हैं।

मैं सिर्फ यह जानना चाहता था कि कभी-कभी वादे बहुत बड़ा बदलाव ला सकते हैं, और जब (हाँ, "नहीं तो") आप इस लेख में चर्चा की गई त्रुटि का सामना करते हैं, तो आपको इसकी घटना का संभावित कारण पता चल जाएगा।

पीएस नोट perev।: मूल लेख के लिए, उपयोगकर्ता क्रेग पी हिक्स से एक उपयोगी टिप्पणी छोड़ दी गई थी, जो (टिप्पणियों में टिप्पणियों के बाद) मैंने यहां उद्धृत करने का फैसला किया:

मैं एक विवरण (मेरे विकास के माहौल में) पर ध्यान आकर्षित करना चाहूंगा जो Promise.resolve({<body>}) , "पकड़े नहीं" जाते हैं:

 Promise.resolve((()=>{throw "oops"; })()) .catch(e=>console("Catched ",e)); //  .catch()      "" 

लेकिन new Promise() ( लगभग अनुवाद।: मूल "उचित वादा" ) के शरीर में होने वाली त्रुटियों को "पकड़ा" जाता है:

 (new Promise((resolve,reject)=>{ resolve((()=>{throw "oops"})()) })) .catch(e=>console.log("Catched ",e)); // Catched oops 

इस कथन के बारे में कैसे:

 async function fn() { <body> } 

शब्दार्थ, यह विकल्प इस के बराबर है:

 function fn() { return new Promise((resolve,reject)=>{ resolve({ <body> }) }) } 

नतीजतन, नीचे दिए गए कोड के टुकड़े त्रुटियों को पकड़ लेंगे यदि <body> में new Promise() ( लगभग। अनुवाद। मूल: "उचित वादा" ):

 function fn() { return Promise.resolve({<body}); } 

इस प्रकार, उदाहरण के लिए दोनों मामलों में त्रुटियों को "पकड़ने" के लिए लेख की शुरुआत से, यह आवश्यक नहीं है कि Promise.resolve() , लेकिन new Promise() कार्यों में शामिल हों:

 function fn(obj) { return new Promise((resolve, reject) => { const someProp = obj.someProp; resolve(someProp); }); } async function asyncFn(obj) { return new Promise((resolve, reject) => { const someProp = obj.someProp; resolve(someProp); }); } asyncFn().catch(err => console.error("Catched")); // => 'Catched' fn().catch(err => console.error("Catched")); // => 'Catched'