Node.js गाइड, भाग 6: इवेंट लूप, कॉल स्टैक, टाइमर

आज, Node.js मैनुअल के अनुवाद के छठे भाग में, हम ईवेंट लूप, कॉल स्टैक, process.nextTick() फ़ंक्शन और टाइमर के बारे में बात करेंगे। इन और अन्य Node.js तंत्र को समझना इस प्लेटफ़ॉर्म के लिए सफल अनुप्रयोग विकास के कोनेस्टोन में से एक है।

घटना पाश

यदि आप समझना चाहते हैं कि जावास्क्रिप्ट कोड कैसे निष्पादित किया जाता है, तो इवेंट लूप सबसे महत्वपूर्ण अवधारणाओं में से एक है जिसे आपको समझने की आवश्यकता है। यहां हम बात करेंगे कि जावास्क्रिप्ट एकल-थ्रेडेड मोड में कैसे काम करता है, और अतुल्यकालिक कार्यों को कैसे संभाला जाता है।

मैं कई वर्षों से जावास्क्रिप्ट विकसित कर रहा हूं, लेकिन मैं यह नहीं कह सकता कि मैं पूरी तरह से समझ गया हूं कि सब कुछ कैसे काम करता है, इसलिए बोलने के लिए, "हुड के नीचे"। प्रोग्रामर को पर्यावरण के आंतरिक उपतंत्रों के उपकरण की पेचीदगियों के बारे में पता नहीं हो सकता है जिसमें वह काम करता है। लेकिन आमतौर पर ऐसी चीजों का कम से कम एक सामान्य विचार होना उपयोगी होता है।

आपके द्वारा लिखा गया जावास्क्रिप्ट कोड सिंगल-थ्रेडेड मोड में चलता है। एक निश्चित समय पर, केवल एक क्रिया की जाती है। यह सीमा, वास्तव में, बहुत उपयोगी है। यह प्रोग्राम के काम करने के तरीके को बहुत सरल करता है, जो प्रोग्रामर को बहु-थ्रेडेड वातावरण के लिए विशिष्ट समस्याओं को हल करने की आवश्यकता को समाप्त करता है।

वास्तव में, एक जेएस प्रोग्रामर को केवल यह ध्यान देने की आवश्यकता है कि उसका कोड क्या कार्य करता है, और उन स्थितियों से बचने की कोशिश करें जो मुख्य धागे को अवरुद्ध करने का कारण बनती हैं। उदाहरण के लिए - तुल्यकालिक मोड और अंतहीन चक्र में नेटवर्क कॉल करना।

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

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

इवेंट लूप लॉक

कोई भी जावास्क्रिप्ट कोड, जिसे निष्पादित करने में बहुत अधिक समय लगता है, यानी वह कोड जो बहुत लंबे समय तक ईवेंट लूप का नियंत्रण नहीं लेता है, किसी अन्य पेज कोड के निष्पादन को रोकता है। यह भी उपयोगकर्ता इंटरफ़ेस घटनाओं के प्रसंस्करण को अवरुद्ध करने की ओर जाता है, जो इस तथ्य में परिलक्षित होता है कि उपयोगकर्ता पृष्ठ तत्वों के साथ बातचीत नहीं कर सकता है और सामान्य रूप से इसके साथ काम कर सकता है, उदाहरण के लिए, स्क्रॉल करना।

लगभग सभी मूल जावास्क्रिप्ट I / O तंत्र गैर-अवरुद्ध हैं। यह ब्राउज़र और Node.js. दोनों पर लागू होता है इस तरह के तंत्रों के बीच, उदाहरण के लिए, हम क्लाइंट और सर्वर वातावरण दोनों में उपयोग किए जाने वाले नेटवर्क अनुरोधों और Node.js फ़ाइलों के साथ काम करने के लिए उपकरणों का उल्लेख कर सकते हैं। ऐसे ऑपरेशन करने के लिए समकालिक तरीके हैं, लेकिन उनका उपयोग केवल विशेष मामलों में किया जाता है। यही कारण है कि पारंपरिक कॉलबैक और नए तंत्र - वादे और async / प्रतीक्षा निर्माण - का जावास्क्रिप्ट में बहुत महत्व है।

कॉल स्टैक

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

यदि इससे पहले भी आप "कॉल स्टैक" की अवधारणा में रुचि नहीं रखते थे, तो यदि आपको त्रुटि संदेश मिला है जिसमें स्टैक ट्रेस शामिल है, तो आप पहले से ही कल्पना करते हैं कि यह कैसा दिखता है। उदाहरण के लिए, एक ब्राउज़र में ऐसा दिखता है।


ब्राउज़र त्रुटि संदेश

ब्राउज़र, जब कोई त्रुटि होती है, तो कॉल टू फंक्शन के अनुक्रम में रिपोर्ट करता है, जिसके बारे में जानकारी कॉल स्टैक में संग्रहीत होती है, जो आपको त्रुटि के स्रोत को खोजने और समझने का मौका देती है कि किन कार्यों के लिए कॉल किया गया।

अब जब हमने ईवेंट लूप और कॉल स्टैक के बारे में सामान्य शब्दों में बात की है, तो एक उदाहरण पर विचार करें जो एक कोड टुकड़ा के निष्पादन को दिखाता है और ईवेंट लूप और कॉल स्टैक के संदर्भ में यह प्रक्रिया कैसे दिखती है।

इवेंट लूप और कॉल स्टैक

यहां वह कोड है जिसे हम प्रयोग करेंगे:

 const bar = () => console.log('bar') const baz = () => console.log('baz') const foo = () => { console.log('foo') bar() baz() } foo() 

यदि इस कोड को निष्पादित किया जाता है, तो निम्नलिखित को कंसोल मिलेगा:

 foo bar baz 

ऐसा परिणाम काफी अपेक्षित है। अर्थात्, जब यह कोड चलाया जाता है, तो foo() फ़ंक्शन को पहले बुलाया जाता है। इस फ़ंक्शन के अंदर, हम पहले bar() फ़ंक्शन, और फिर baz() फ़ंक्शन कहते हैं। उसी समय, इस कोड के निष्पादन के दौरान कॉल स्टैक निम्न आकृति में दिखाए गए परिवर्तनों से गुजरता है।


कोड निष्पादित करते समय कॉल स्टैक की स्थिति बदलना

ईवेंट लूप, प्रत्येक पुनरावृत्ति पर, यह देखने के लिए जाँच करता है कि कॉल स्टैक में कुछ है या नहीं, और यदि ऐसा है, तो कॉल स्टैक खाली होने तक ऐसा करता है।


इवेंट लूप पुनरावृत्तियों

एक समारोह में भाग लेना

उपरोक्त उदाहरण काफी सामान्य लग रहा है, इसके बारे में कुछ खास नहीं है: जावास्क्रिप्ट कोड को ढूंढता है जिसे निष्पादित करने और इसे क्रम में निष्पादित करने की आवश्यकता होती है। हम कॉल स्टैक साफ़ होने तक फ़ंक्शन निष्पादन को स्थगित करने के बारे में बात करेंगे। ऐसा करने के लिए, निम्नलिखित निर्माण का उपयोग किया जाता है:

 setTimeout(() => {}), 0) 

यह आपको setTimeout() फ़ंक्शन को दिए गए फ़ंक्शन को निष्पादित करने की अनुमति देता है, जब प्रोग्राम कोड में सभी अन्य फ़ंक्शन निष्पादित किए जाते हैं।

एक उदाहरण पर विचार करें:

 const bar = () => console.log('bar') const baz = () => console.log('baz') const foo = () => { console.log('foo') setTimeout(bar, 0) baz() } foo() 

यह कोड प्रिंट अनपेक्षित प्रतीत हो सकता है:

 foo baz bar 

जब हम इस उदाहरण को चलाते हैं, तो foo() फ़ंक्शन को पहले कहा जाता है। इसमें, हम setTimeout() , इस फ़ंक्शन को पास करते हुए, पहले तर्क के रूप में, bar । इसे दूसरे तर्क के रूप में पारित करके, हम सिस्टम को सूचित करते हैं कि इस फ़ंक्शन को जल्द से जल्द निष्पादित किया जाना चाहिए। तब हम baz() फ़ंक्शन को कहते हैं।

इस तरह से कॉल स्टैक अब दिखेगा।


कोड निष्पादित करते समय कॉल स्टैक की स्थिति बदलना

यहां वह क्रम दिया गया है जिसमें हमारे कार्यक्रम के कार्यों को अब निष्पादित किया जाएगा।


इवेंट लूप पुनरावृत्तियों

ऐसा क्यों हो रहा है?

घटना कतार

जब setTimeout() फ़ंक्शन कहा जाता है, तो ब्राउज़र या Node.js प्लेटफ़ॉर्म एक टाइमर शुरू करता है। टाइमर काम करने के बाद (हमारे मामले में, यह तुरंत होता है, क्योंकि हम इसे 0 पर सेट करते हैं), कॉलबैक फ़ंक्शन setTimeout() जाता है, इवेंट क्यू में जाता है।

घटना की कतार, जब यह ब्राउज़र की बात आती है, तो इसमें उपयोगकर्ता द्वारा शुरू की गई घटनाएँ शामिल होती हैं - पृष्ठ तत्वों पर माउस क्लिक के कारण होने वाली घटनाएँ, जब कीबोर्ड से डेटा दर्ज किया जाता है तो ऐसी घटनाएं होती हैं। डॉम onload हैंडलर जैसे onload , डेटा लोड करने के अतुल्यकालिक अनुरोधों के उत्तर प्राप्त करते समय किए जाने वाले फ़ंक्शन तुरंत होते हैं। यहां वे प्रक्रिया के लिए अपनी बारी का इंतजार कर रहे हैं।

इवेंट लूप कॉल स्टैक पर क्या है को प्राथमिकता देता है। सबसे पहले, यह सब कुछ करता है जो इसे स्टैक पर ढूंढने का प्रबंधन करता है, और स्टैक खाली होने के बाद, यह घटना कतार में क्या है यह संसाधित करने के लिए आगे बढ़ता है।

हमें तब तक इंतजार करने की आवश्यकता नहीं है जब तक कि setTimeout() जैसे फ़ंक्शन को पूरा नहीं किया जाता है, क्योंकि ब्राउज़र द्वारा समान कार्य प्रदान किए जाते हैं और वे अपनी धाराओं का उपयोग करते हैं। इसलिए, उदाहरण के लिए, setTimeout() फ़ंक्शन का उपयोग करके टाइमर को 2 सेकंड के लिए सेट करना, आपको दूसरे कोड के निष्पादन को रोकना नहीं चाहिए, इन 2 सेकंड की प्रतीक्षा करें, क्योंकि टाइमर आपके कोड के बाहर काम करता है।

ES6 नौकरी कतार

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

यदि वर्तमान फ़ंक्शन के अंत से पहले एक वादा हल किया जाता है, तो वर्तमान फ़ंक्शन के पूरा होने के तुरंत बाद संबंधित कोड निष्पादित किया जाएगा।

हम जिस बारे में बात कर रहे हैं उसके लिए मुझे एक दिलचस्प सादृश्य मिला। इसकी तुलना एक मनोरंजन पार्क में एक रोलर कोस्टर से की जा सकती है। जब आप पहाड़ी की सवारी करते हैं और इसे फिर से करना चाहते हैं, तो आप टिकट लेते हैं और लाइन की पूंछ में लग जाते हैं। इस तरह से घटना कतार काम करती है। लेकिन नौकरी की कतार अलग दिखती है। यह अवधारणा डिस्काउंट टिकट के समान है, जो आपको पिछली यात्रा समाप्त करने के तुरंत बाद अगली यात्रा करने का अधिकार देता है।

निम्नलिखित उदाहरण पर विचार करें:

 const bar = () => console.log('bar') const baz = () => console.log('baz') const foo = () => { console.log('foo') setTimeout(bar, 0) new Promise((resolve, reject) =>   resolve('should be right after baz, before bar') ).then(resolve => console.log(resolve)) baz() } foo() 

इसके निष्पादन के बाद आउटपुट क्या होगा:

 foo baz should be right after baz, before bar bar 

यहां आप जो देख सकते हैं वह वादों (और async / प्रतीक्षा निर्माण, जो उन पर आधारित है) और पारंपरिक अतुल्यकालिक कार्यों के बीच एक गंभीर अंतर को प्रदर्शित करता है, जिसका निष्पादन setTimeout() या मंच के अन्य एपीआई setTimeout() का उपयोग करके आयोजित किया जाता है।

process.nextTick ()

process.nextTick() विधि एक विशेष तरीके से इवेंट लूप के साथ इंटरैक्ट करती है। एक टिक घटनाओं का एक पूरा चक्र है। फ़ंक्शन को process.nextTick() विधि में पास करना, हम सिस्टम को सूचित करते हैं कि इस फ़ंक्शन को अगले लूप के पूरा होने से पहले इवेंट लूप की वर्तमान पुनरावृत्ति पूरी होने के बाद कॉल करने की आवश्यकता है। इस विधि का उपयोग इस तरह दिखता है:

 process.nextTick(() => { // -  }) 

मान लीजिए कि एक ईवेंट लूप वर्तमान फ़ंक्शन के लिए कोड निष्पादित करने में व्यस्त है। जब यह ऑपरेशन पूरा हो जाता है, तो जावास्क्रिप्ट इंजन पिछले ऑपरेशन के दौरान process.nextTick() पारित सभी कार्यों को निष्पादित करेगा। इस तंत्र का उपयोग करते हुए, हम यह सुनिश्चित करने का प्रयास करते हैं कि एक निश्चित फ़ंक्शन को असिंक्रोनस रूप से निष्पादित किया जाता है (वर्तमान फ़ंक्शन के बाद), लेकिन जितनी जल्दी हो सके, इसे कतार में रखे बिना।

उदाहरण के लिए, यदि आप setTimeout(() => {}, 0) निर्माण का उपयोग करते हैं, तो फ़ंक्शन को इवेंट लूप के अगले पुनरावृत्ति पर निष्पादित किया जाएगा, अर्थात, जब process.nextTick() तुलना में बहुत बाद में। उसी स्थिति में उपयोग किया जाता है। इस विधि का उपयोग तब किया जाना चाहिए जब इवेंट लूप के अगले पुनरावृत्ति की शुरुआत में कुछ कोड के निष्पादन को सुनिश्चित करना आवश्यक हो।

सेटमीडिएट ()

अतुल्यकालिक कोड निष्पादन के लिए Node.js द्वारा प्रदान किया गया एक अन्य कार्य setImmediate() । इसका उपयोग कैसे करें:

 setImmediate(() => { //   }) 

कॉलबैक फ़ंक्शन को setImmediate() पारित कर दिया गया है जो इवेंट लूप के अगले पुनरावृत्ति पर निष्पादित किया जाएगा।

setImmediate() , setTimeout(() => {}, 0) (जो कि टाइमर से जल्द से जल्द काम करना चाहिए) और process.nextTick() ?

फ़ंक्शन को संसाधित किया गया process.nextTick() इवेंट लूप की वर्तमान पुनरावृत्ति पूरी होने के बाद निष्पादित करेगा। अर्थात्, ऐसे फ़ंक्शन को हमेशा उस फ़ंक्शन से पहले निष्पादित किया जाएगा जिसका निष्पादन setImmediate() या setImmediate() का उपयोग करके निर्धारित किया गया है।

setTimeout() फ़ंक्शन को 0 एमएस के सेट विलंब के साथ कॉल करना कॉलिंग setImmediate() समान है। उन्हें स्थानांतरित किए गए कार्यों के निष्पादन का क्रम विभिन्न कारकों पर निर्भर करता है, लेकिन दोनों ही मामलों में ईवेंट लूप के अगले पुनरावृत्ति पर कॉलबैक कहा जाएगा।

टाइमर

हम पहले ही setTimeout() फ़ंक्शन के बारे में बात कर चुके हैं, जो आपको इसके पास दिए गए कॉलबैक पर कॉल शेड्यूल करने की अनुमति देता है। आइए हम इसकी विशेषताओं के बारे में अधिक विस्तार से वर्णन करने के लिए कुछ समय लेते हैं और इसके समान एक अन्य फ़ंक्शन, setInterval() विचार करते हैं। Node.js में टाइमर के साथ काम करने के लिए कार्य टाइमर मॉड्यूल में शामिल हैं, लेकिन आप इस मॉड्यूल को कोड में कनेक्ट किए बिना उनका उपयोग कर सकते हैं, क्योंकि वे वैश्विक हैं।

▍ फ़ंक्शन सेटटाइमआउट ()

याद रखें कि जब आप setTimeout() फ़ंक्शन को कॉल करते हैं, तो यह कॉलबैक और मिलिसेकंड में समय प्राप्त करता है, जिसके बाद कॉलबैक कहा जाएगा। एक उदाहरण पर विचार करें:

 setTimeout(() => { //   2  }, 2000) setTimeout(() => { //   50  }, 50) 

यहां हम तुरंत वर्णित setTimeout() नए फ़ंक्शन के setTimeout() पास करते हैं, लेकिन यहां हम setTimeout() इसका नाम और इसे चलाने के लिए मापदंडों का एक सेट पास करके मौजूदा फ़ंक्शन का उपयोग कर सकते हैं। यह इस तरह दिखता है:

 const myFunction = (firstParam, secondParam) => { //   } //   2  setTimeout(myFunction, 2000, firstParam, secondParam) 

setTimeout() फ़ंक्शन एक टाइमर पहचानकर्ता देता है। आमतौर पर इसका उपयोग नहीं किया जाता है, लेकिन आप इसे बचा सकते हैं और, यदि आवश्यक हो, तो टाइमर को हटा दें यदि निर्धारित कॉलबैक की अब आवश्यकता नहीं है:

 const id = setTimeout(() => { //      2  }, 2000) //  ,       clearTimeout(id) 

Delay शून्य विलंब

पिछले अनुभागों में, हमने इसे setTimeout() उपयोग किया, इसे पास करते हुए, जिस समय के बाद कॉलबैक कॉल करना आवश्यक है, 0 । इसका मतलब था कि कॉलबैक को जल्द से जल्द बुलाया जाएगा, लेकिन वर्तमान फ़ंक्शन के पूरा होने के बाद:

 setTimeout(() => { console.log('after ') }, 0) console.log(' before ') 

ऐसा कोड निम्नलिखित आउटपुट देगा:

 before after 

यह तकनीक स्थितियों में विशेष रूप से उपयोगी है जब, भारी कम्प्यूटेशनल कार्यों का प्रदर्शन करते समय, मैं मुख्य थ्रेड को ब्लॉक नहीं करना चाहूंगा, अन्य कार्यों को निष्पादित करने की अनुमति देता हूं, इन कार्यों को कई चरणों में तोड़कर, setTimeout() कॉल के रूप में निष्पादित किया जाता है।

यदि हम उपरोक्त setImmediate() फ़ंक्शन को याद करते हैं, तो यह Node.js में मानक है, जो ब्राउज़रों के बारे में नहीं कहा जा सकता है (यह IE और एज में लागू किया गया है, लेकिन अन्य में नहीं)।

Ter फ़ंक्शन सेटइंटरवल ()

setInterval() फ़ंक्शन setInterval() समान है, लेकिन उनके बीच अंतर हैं। कॉलबैक निष्पादित करने के बजाय इसे एक बार में सेट करें, setInterval() समय-समय पर, निर्दिष्ट अंतराल के साथ, इस कॉलबैक को कॉल करें। यह आदर्श रूप से जारी रहेगा, जब तक कि प्रोग्रामर स्पष्ट रूप से इस प्रक्रिया को रोक नहीं देता है। इस सुविधा का उपयोग कैसे करें:

 setInterval(() => { //   2  }, 2000) 

ऊपर दिखाए गए फ़ंक्शन के लिए पारित एक कॉलबैक को हर 2 सेकंड कहा जाएगा। इस प्रक्रिया को रोकने की संभावना प्रदान करने के लिए, आपको टाइमर पहचानकर्ता को setInterval() द्वारा वापस लाने और clearInterval() कमांड का उपयोग करने की clearInterval() :

 const id = setInterval(() => { //   2  }, 2000) clearInterval(id) 

एक सामान्य तकनीक स्पष्ट करने के लिए कॉल clearInterval() जब एक निश्चित शर्त पूरी हो जाती है तो कॉलबैक के अंदर कॉलबैक में भेज दिया जाता है setInterval() । उदाहरण के लिए, निम्न कोड समय-समय पर चलाया जाएगा जब तक कि App.somethingIWait संपत्ति arrived लिए App.somethingIWait हो:

 const interval = setInterval(function() { if (App.somethingIWait === 'arrived') {   clearInterval(interval)   //    -  ,   -    } }, 100) 

▍ पुनरावर्ती सेटिंग सेटटाइमआउट ()

setInterval() फ़ंक्शन कॉलबैक को हर n मिलीसेकंड पर कॉल करेगा, बिना इस चिंता के कि क्या यह कॉलबैक अपने पिछले कॉल के बाद पूरा हुआ है।

यदि इस कॉलबैक में प्रत्येक कॉल को हमेशा n से कम समय की आवश्यकता होती है, तो यहां कोई समस्या नहीं आती है।


समय-समय पर कॉलबैक कहा जाता है, जिनमें से प्रत्येक निष्पादन सत्र कॉल के बीच के अंतराल के भीतर गिरने, एक ही समय लेता है

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


समय-समय पर कॉलबैक कहा जाता है, जिनमें से प्रत्येक निष्पादन सत्र कॉल के बीच गिरने में एक अलग समय लेता है

setInterval() का उपयोग करते समय, कॉलबैक n से अधिक होने पर एक स्थिति उत्पन्न हो सकती है, जिसके कारण अगला कॉल पूरा होने से पहले पूरा हो जाता है।


समय-समय पर कॉलबैक कहा जाता है, जिनमें से प्रत्येक सत्र में एक अलग समय लगता है, जो कभी-कभी कॉल के बीच अंतराल में फिट नहीं होता है

इस स्थिति से बचने के लिए, आप setTimeout() का उपयोग करके पुनरावर्ती टाइमर सेटिंग तकनीक का उपयोग कर सकते हैं। मुद्दा यह है कि अगली कॉलबैक कॉल की योजना इसके पिछले कॉल के पूरा होने के बाद है:

 const myFunction = () => { //    setTimeout(myFunction, 1000) } setTimeout( myFunction() }, 1000) 

इस दृष्टिकोण के साथ, निम्नलिखित परिदृश्य को लागू किया जा सकता है:


कॉलबैक निष्पादन को शेड्यूल करने के लिए setTimeout () के लिए एक पुनरावर्ती कॉल

परिणाम

आज हमने Node.js के आंतरिक तंत्रों के बारे में बात की, जैसे कि इवेंट लूप, कॉल स्टैक, और टाइमर के साथ काम करने पर चर्चा की जो आपको कोड निष्पादन को शेड्यूल करने की अनुमति देते हैं। अगली बार हम अतुल्यकालिक प्रोग्रामिंग के विषय में तल्लीन करेंगे।

प्रिय पाठकों! क्या आपको ऐसी परिस्थितियों का सामना करना पड़ा है जब आपको process.nextTick () का उपयोग करना था?