जावास्क्रिप्ट: किसी कार्य के निष्पादन की आवृत्ति को सीमित करना

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



प्रारंभिक डेटा: एक संसाधन-गहन फ़ंक्शन जो कुछ घटनाओं (उदाहरण के लिए माउस आंदोलन) की घटना पर स्क्रीन पर कुछ तत्वों को अपडेट करता है।

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

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



आइए कुछ शुरुआती धारणाएँ बनाते हैं।

1. चूंकि फ़ंक्शन को हमेशा निष्पादित नहीं किया जाना चाहिए, लेकिन चुनिंदा रूप से, एक ध्वज चर की आवश्यकता होती है, एक विशेष तरीके से सेटिंग और चेकिंग जिसमें आप एक विकल्प बना सकते हैं।
2. यदि फ़ंक्शन को कॉल किया जाता है, लेकिन निष्पादित नहीं किया जा सकता है (पिछले निष्पादन के बाद से निर्दिष्ट अंतराल पास नहीं हुआ है), तो आप इसे छोड़ नहीं सकते - इसे अंतराल समाप्त होने के बाद निष्पादित किया जाना चाहिए, अन्यथा स्क्रीन घटनाओं की एक श्रृंखला के बाद नवीनतम स्थिति प्रदर्शित नहीं कर सकती है ( अगर अंतिम कॉल पूरा नहीं हुआ है)। ऐसा करने के लिए, हमें एक ध्वज चर की आवश्यकता होती है जो ऐसी कॉल के बारे में बात करता है, जिसे अंतराल के अंत में जांचा जाएगा।
3. यदि एक पंक्ति में कई अधूरी कॉल हैं, तो यह केवल अंतराल के अंत तक अंतिम रूप से स्थगित करने के लिए पर्याप्त होगा। ऐसा करने के लिए, हमें चर में अंतिम फ़ंक्शन कॉल के तर्कों को संग्रहीत करने की आवश्यकता है।
4. ऊपर वर्णित तरीके से काम करना, प्रतिबंध के बाद, फ़ंक्शन को मूल गुंजाइश और स्वीकृत तर्क को संरक्षित करना चाहिए - जाहिर है।

कोड पर चलते हैं। हम बाद में क्रम में इसका विश्लेषण करेंगे।

  var limitExecByInterval = function (fn, time) {	
	 var lock, execOnUnlock, args;
	 वापसी समारोह () {
		 आर्ग = तर्क;
		 अगर (ताला) {				
			 ताला = सच्चा;
			 var गुंजाइश = यह;
			 setTimeout (फ़ंक्शन () {
				 ताला = असत्य;
				 अगर (निष्पादित करें)
					 args.callee.apply (गुंजाइश, args);
					 execOnUnlock = false;
				 }
			 }, समय);
			 वापसी fn.apply (यह, args);
		 } और निष्पादित करेंOnlock = true;
	 }
 } 

limitExecByInterval



इनपुट फ़ंक्शन और इनपुट के रूप में मिलीसेकंड में अंतराल को संशोधित फ़ंक्शन लौटाता है जिसे ऊपर वर्णित के रूप में निष्पादित किया जाएगा। (सादगी के लिए, मैंने इसे Function.prototype



विधि से नहीं बनाया, हालांकि यह संभव है)। उपयोग उदाहरण:



var myFunc = function(...) { ... }

var myLimitedFunc = limitExecByInterval(myFunc, 150);







यदि वांछित है, तो आप इसे फ़ंक्शन.प्रोटोटाइप के माध्यम से किसी भी फ़ंक्शन की विधि बना सकते हैं। ऐसा करने के लिए, पहले दो पंक्तियों को निम्नानुसार बदलें:

  फ़ंक्शन .prototype.limitExecByInterval = फ़ंक्शन (समय) {
	 var lock, execOnUnlock, args, fn = यह;
	 ... 

तो आप इसे इस तरह से कॉल कर सकते हैं:



var myLimitedFunc = myFunc.limitExecByInterval(150);







अब देखते हैं कि कोड में क्या होता है।



सबसे पहले, हमें जिन वेरिएबल्स की आवश्यकता होती है वे घोषित किए जाते हैं - नोटिस, फ़ंक्शन के बाहर लौटाया जा रहा है - वे इसके सभी कॉल्स के लिए सामान्य होंगे। वापसी समारोह में:

1. कॉल तर्क सहेजना (मान्यताओं के खंड 3 देखें)
2. अगर ताला झंडा सेट नहीं है
   
   
   1. लॉक फ्लैग सेट करें (आइटम 1)
   2. अगले चरण के लिए फ़ंक्शन का दायरा सहेजें (आइटम 4)
   3. निम्नलिखित अंतराल सेट करें:
      
      
      • ताला झंडा साफ़ करें (पृष्ठ 1)
      • यदि निष्पादन ध्वज अंतराल (खंड 2) के अंत में सेट किया गया है, तो इसे हटा दें और संपूर्ण संशोधित फ़ंक्शन करें।
      
      
      
   4. हम दिए गए तर्कों के साथ मूल कार्य को निष्पादित करते हैं, समान गुंजाइश और लौटाए गए मान। (पृष्ठ ४)
   
   
   

यहाँ काम कोड के साथ सबसे सरल उदाहरण है । (एक दिलचस्प बिंदु: एफएफ और आईई में प्रतिबंध का उपयोग करने में अंतर स्पष्ट रूप से दिखाई देता है, लेकिन ओपेरा और सफारी में दोनों संस्करणों में सब कुछ तेजी से चमक रहा है)।

मुझे उम्मीद है कि उन्होंने खुद को स्पष्ट कर दिया है। :) बात जटिल है, लेकिन मैंने वास्तव में वास्तविक समस्या को हल करने के लिए वास्तव में अभ्यास में मदद की है। अब टिप्पणियों में समझें कि कौन और क्या टिप्पणी करता है। :)