Node.js
अतुल्यकालिक प्रोग्रामिंग

परिचय

वाक्य - विन्यास

• doSomething ([args], function ([argsCB]) {/ * जब कुछ किया जाए * /});
• doSomething ([args], ([argsCB]) => {/ * जब किया कुछ करो * /});

कॉलबैक फ़ंक्शन

जावास्क्रिप्ट में कॉलबैक फ़ंक्शन

कॉलबैक फ़ंक्शंस जावास्क्रिप्ट में आम हैं। कॉलबैक फ़ंक्शन जावास्क्रिप्ट में संभव हैं क्योंकि फ़ंक्शन प्रथम श्रेणी के नागरिक हैं ।

तुल्यकालिक कॉलबैक।

कॉलबैक फ़ंक्शन सिंक्रोनस या एसिंक्रोनस हो सकते हैं। चूंकि एसिंक्रोनस कॉलबैक फ़ंक्शन अधिक जटिल हो सकते हैं, यहां एक सिंक्रोनस कॉलबैक फ़ंक्शन का एक सरल उदाहरण है।

// a function that uses a callback named `cb` as a parameter
function getSyncMessage(cb) {
    cb("Hello World!");
}

console.log("Before getSyncMessage call");
// calling a function and sending in a callback function as an argument.
getSyncMessage(function(message) {
    console.log(message);
});
console.log("After getSyncMessage call");

उपरोक्त कोड के लिए आउटपुट है:

> Before getSyncMessage call
> Hello World!
> After getSyncMessage call

पहले हम ऊपर दिए गए कोड को कैसे निष्पादित करते हैं, के माध्यम से कदम उठाएंगे। यह उन लोगों के लिए अधिक है जो पहले से ही कॉलबैक की अवधारणा को नहीं समझते हैं यदि आप पहले से ही समझते हैं कि इस पैराग्राफ को छोड़ने के लिए स्वतंत्र महसूस हो रहा है। पहले कोड को पार्स किया जाता है और फिर होने वाली पहली दिलचस्प बात है लाइन 6 को निष्पादित किया जाता है जो कि कंसोल से Before getSyncMessage call को आउटपुट करता है। फिर लाइन 8 को निष्पादित किया जाता है जो फ़ंक्शन getSyncMessage को एक अनाम फ़ंक्शन में एक पैरामीटर के लिए एक तर्क के रूप में भेजता है, जिसका नाम getSyncMessage फ़ंक्शन में cb है। निष्पादन अब लाइन 3 पर getSyncMessage फ़ंक्शन के अंदर किया जाता है जो फ़ंक्शन cb निष्पादित करता है जो कि अभी पारित किया गया था, यह कॉल अनाम फ़ंक्शन में पारित message लिए परम नाम message लिए एक तर्क स्ट्रिंग "हैलो वर्ल्ड" भेजता है। निष्पादन फिर 9 पंक्ति में जाता है जो Hello World! सांत्वना देने के लिए। फिर निष्पादन कॉलस्टैक से बाहर निकलने की प्रक्रिया से गुजरता है ( यह भी देखें ) लाइन 10 को मार रहा है तो लाइन 4 फिर अंत में वापस लाइन 11 तक।

सामान्य रूप से कॉलबैक के बारे में जानने के लिए कुछ जानकारी:

• एक कॉलबैक के रूप में एक फ़ंक्शन को आपके द्वारा भेजे जाने वाले फ़ंक्शन को शून्य बार, एक बार या कई बार कहा जा सकता है। यह सब कार्यान्वयन पर निर्भर करता है।
• कॉलबैक फ़ंक्शन को सिंक्रोनस या एसिंक्रोनसली कहा जा सकता है और संभवतः सिंक्रोनस और एसिंक्रोनस दोनों।
• सामान्य कार्यों की तरह ही, आपके द्वारा अपने फ़ंक्शन के लिए दिए गए नाम महत्वपूर्ण नहीं हैं, लेकिन आदेश है। उदाहरण के लिए लाइन 8 पर पैरामीटर message को statement , msg , या यदि आप jellybean तरह jellybean कर रहे हैं, तो नाम दिया जा सकता है। इसलिए आपको पता होना चाहिए कि आपके कॉलबैक में क्या पैरामीटर भेजे गए हैं ताकि आप उन्हें उचित नामों के साथ सही क्रम में प्राप्त कर सकें।

अतुल्यकालिक कॉलबैक।

जावास्क्रिप्ट के बारे में ध्यान देने वाली एक बात यह डिफ़ॉल्ट रूप से तुल्यकालिक है, लेकिन पर्यावरण में दिए गए एपीआई (ब्राउज़र, नोड.जेएस, आदि) हैं जो इसे अतुल्यकालिक बना सकते हैं ( यहां इसके बारे में अधिक है )।

कुछ सामान्य चीजें जो जावास्क्रिप्ट वातावरण में अतुल्यकालिक हैं जो कॉलबैक स्वीकार करते हैं:

• आयोजन
• setTimeout
• setInterval
• लाने की एपीआई
• वादे

उपरोक्त फ़ंक्शन में से एक का उपयोग करने वाले किसी भी फ़ंक्शन को एक कॉलबैक लेने वाले फ़ंक्शन के साथ लपेटा जा सकता है और कॉलबैक तब एक अतुल्यकालिक कॉलबैक होगा (हालांकि एक कॉलबैक लेने वाले फ़ंक्शन के साथ वादों को लपेटना संभवतः एक एंटी-पैटर्न माना जाएगा। वादों को संभालने के अधिक पसंदीदा तरीके हैं)।

इसलिए यह जानकारी दी गई है कि हम उपरोक्त सिंक्रोनस के समान एक अतुल्यकालिक फ़ंक्शन का निर्माण कर सकते हैं।

// a function that uses a callback named `cb` as a parameter
function getAsyncMessage(cb) {
    setTimeout(function () { cb("Hello World!") }, 1000);
}

console.log("Before getSyncMessage call");
// calling a function and sending in a callback function as an argument.
getAsyncMessage(function(message) {
    console.log(message);
});
console.log("After getSyncMessage call");

जो सांत्वना के लिए निम्नलिखित प्रिंट करता है:

> Before getSyncMessage call
> After getSyncMessage call
// pauses for 1000 ms with no output
> Hello World!

लाइन निष्पादन 6 लॉग्स पर जाता है "getSyncMessage कॉल से पहले"। तब निष्पादन परम के लिए एक कॉलबैक साथ getAsyncMessage बुला 8 लाइन को जाता है cb । लाइन 3 को तब निष्पादित किया जाता है जो कॉलबैक के साथ सेटबैकआउट को पहले तर्क के रूप में कहता है और संख्या 300 को दूसरे तर्क के रूप में। setTimeout जो कुछ भी करता है और उस कॉलबैक पर रखता है ताकि वह इसे 1000 मिलीसेकंड में बाद में कॉल कर सके, लेकिन टाइमआउट सेट करने के बाद और 1000 मिलीसेकंड से पहले इसे हाथ लगाने पर वापस उसी स्थान पर ले जाता है जहां से इसे छोड़ा गया था, यह पंक्ति 4 में जाती है , फिर लाइन 11, और फिर 1 सेकंड के लिए रुक जाता है और फिर getAsyncMessages करता है, फिर कॉलबैक फ़ंक्शन को कॉल करता है, जो कि 3 लाइन पर वापस आ जाता है, जहां getAsyncMessages कॉलबैक को इसके पैरामीटर message लिए मान "हैलो वर्ल्ड" कहा जाता है, जो तब लाइन 9 पर कंसोल में लॉग इन होता है। ।

Node.js में कॉलबैक फ़ंक्शन

NodeJS में अतुल्यकालिक कॉलबैक हैं और आमतौर पर पारंपरिक रूप से err और data कहे जाने वाले आपके कार्यों के लिए दो मापदंडों की आपूर्ति data । फ़ाइल पाठ पढ़ने के साथ एक उदाहरण।

const fs = require("fs");

fs.readFile("./test.txt", "utf8", function(err, data) {
    if(err) {
        // handle the error 
    } else {
        // process the file text given with data
    }
});

यह एक कॉलबैक का एक उदाहरण है जिसे एकल समय कहा जाता है।

यह किसी भी तरह त्रुटि को संभालने के लिए अच्छा है, भले ही आपका इसे लॉगिंग या फेंक रहा हो। यदि आप फेंकते हैं या लौटते हैं तो अन्य आवश्यक नहीं है और जब तक आप फेंकने या वापस आने जैसे कुछ करके वर्तमान फ़ंक्शन के निष्पादन को रोकते हैं, तो इंडेंटेशन को कम करने के लिए हटाया जा सकता है।

यद्यपि यह err से देखा जा सकता है, data यह हमेशा ऐसा नहीं हो सकता है कि आपके कॉलबैक उस पैटर्न का उपयोग करेंगे जो प्रलेखन को देखने के लिए सबसे अच्छा है।

एक अन्य उदाहरण कॉलबैक एक्सप्रेस लाइब्रेरी (एक्सप्रेस 4.x) से आता है:

// this code snippet was on http://expressjs.com/en/4x/api.html
const express = require('express');
const app = express();

// this app.get method takes a url route to watch for and a callback
// to call whenever that route is requested by a user.
app.get('/', function(req, res){
  res.send('hello world');
});

app.listen(3000);

यह उदाहरण एक कॉलबैक दिखाता है जिसे कई बार कहा जाता है। कॉलबैक के रूप में यहाँ नामित पैरामीटर के रूप में दो वस्तुओं के साथ प्रदान की जाती है req और res इन नामों क्रमशः अनुरोध और प्रतिक्रिया के अनुरूप है, और वे में आने वाले अनुरोध देखने और प्रतिक्रिया है कि उपयोगकर्ता के लिए भेजा जाएगा स्थापित करने के लिए तरीके प्रदान करते हैं।

जैसा कि आप देख सकते हैं कि विभिन्न तरीकों से कॉलबैक को सिंक में निष्पादित करने के लिए इस्तेमाल किया जा सकता है और जावास्क्रिप्ट में async कोड और कॉलबैक पूरे जावास्क्रिप्ट में बहुत सर्वव्यापी हैं।

कोड उदाहरण

प्रश्न: नीचे दिए गए कोड का आउटपुट क्या है और क्यों है?

setTimeout(function() {
    console.log("A");
}, 1000);

setTimeout(function() {
    console.log("B");
}, 0);

getDataFromDatabase(function(err, data) {
    console.log("C");
    setTimeout(function() {
        console.log("D");
    }, 1000);
});

console.log("E");

आउटपुट: यह सुनिश्चित करने के लिए जाना जाता है: EBAD । C अज्ञात है जब इसे लॉग किया जाएगा।

स्पष्टीकरण: कंपाइलर setTimeout और getDataFromDatabase मेथोड पर नहीं रुकेगा। तो वह जो पहली लाइन लॉग करेगा वह E । कॉलबैक फ़ंक्शंस ( setTimeout का पहला तर्क) सेट अपआउट के बाद एसिंक्रोनस तरीके से चलेगा!

अधिक जानकारी:

1. E का कोई setTimeout नहीं है
2. B में 0 मिलीसेकंड का एक सेट टाइमआउट है
3. A में 1000 मिलीसेकंड का एक सेट टाइमआउट है
4. D को एक डेटाबेस का अनुरोध करना चाहिए, इसके बाद D 1000 मिलीसेकंड इंतजार करना होगा ताकि यह A बाद आए।
5. C अज्ञात है क्योंकि यह अज्ञात है जब डेटाबेस का डेटा अनुरोध किया जाता है। यह A से पहले या बाद में हो सकता है।

Async त्रुटि हैंडलिंग

पकड़ने की कोशिश

त्रुटियों को हमेशा संभाला जाना चाहिए। यदि आप तुल्यकालिक प्रोग्रामिंग का उपयोग कर रहे हैं, तो आप एक try catch उपयोग कर सकते हैं। लेकिन यह काम नहीं करता है यदि आप अतुल्यकालिक काम करते हैं! उदाहरण:

try {
    setTimeout(function() {
        throw new Error("I'm an uncaught error and will stop the server!");
    }, 100); 
}
catch (ex) {
    console.error("This error will not be work in an asynchronous situation: " + ex);
}

Async त्रुटियों को केवल कॉलबैक फ़ंक्शन के अंदर संभाला जाएगा!

काम करने की संभावनाएं

process.on("UncaughtException", function(err, data) { 
    if (err) {
        // error handling
    }
});

var domain = require("domain");
var d1 = domain.create();
var d2 = domain.create();

d1.run(function() {
    d2.add(setTimeout(function() {
        throw new Error("error on the timer of domain 2");
    }, 0));
});

d1.on("error", function(err) {
    console.log("error at domain 1: " + err);
});

d2.on("error", function(err) {
    console.log("error at domain 2: " + err);
});

कॉलबैक नरक

कॉलबैक नरक (कयामत या बूमरैंग प्रभाव का एक पिरामिड) भी उत्पन्न होता है जब आप कॉलबैक फ़ंक्शन के अंदर बहुत से कॉलबैक फ़ंक्शन को घोंसला देते हैं। यहाँ एक फ़ाइल (ES6 में) पढ़ने के लिए एक उदाहरण है।

const fs = require('fs');
let filename = `${__dirname}/myfile.txt`;

fs.exists(filename, exists => {
    if (exists) {
        fs.stat(filename, (err, stats) => {
            if (err) {
                throw err;
            }
            if (stats.isFile()) {
                fs.readFile(filename, null, (err, data) => {
                    if (err) {
                        throw err;
                    }
                    console.log(data);
                });
            }
            else {
                throw new Error("This location contains not a file");
            }
        });
    }
    else {
        throw new Error("404: file not found");
    }
}); 

"कॉलबैक हेल" से कैसे बचें

यह 2 से अधिक कॉलबैक फ़ंक्शन को घोंसला बनाने के लिए अनुशंसित है। इससे आपको कोड की पठनीयता बनाए रखने में मदद मिलेगी और भविष्य में बनाए रखने में मुझे बहुत आसानी होगी। यदि आपको 2 से अधिक कॉलबैक घोंसले बनाने की आवश्यकता है, तो इसके बजाय वितरित घटनाओं का उपयोग करने का प्रयास करें।

वहाँ भी एक पुस्तकालय async कहा जाता है कि कॉलबैक और उनके निष्पादन npm पर उपलब्ध प्रबंधन में मदद करता है मौजूद है। यह कॉलबैक कोड की पठनीयता को बढ़ाता है और आपको अपने कॉलबैक कोड प्रवाह पर अधिक नियंत्रण प्रदान करता है, जिसमें आपको उन्हें समानांतर या श्रृंखला में चलाने की अनुमति भी शामिल है।

देशी वचन

function timeout (ms) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve("It was resolved!");
    }, ms)
  });
}

timeout(1000).then(function (dataFromPromise) {
  // logs "It was resolved!"
  console.log(dataFromPromise);
})

console.log("waiting...");

waiting...
// << pauses for one second>>
It was resolved!

जावास्क्रिप्ट दस्तावेज में वादों के बारे में और अधिक पढ़ें वादे ।