फंक्शन कॉल इवेंट एमुलेशन

लगभग छह महीने पहले, उन्होंने मुझसे कुछ इस तरह पूछा: “मैं एक बड़े ढांचे का उपयोग करता हूं जो उपयोगकर्ता के कार्यों के अनुसार एक निश्चित फ़ंक्शन लॉन्च करता है। इस फ़ंक्शन के कोड को बदले बिना, मैं इस फ़ंक्शन को कॉल करने की स्थिति में अपने कोड को निष्पादित करना चाहता हूं। " अभ्यास सबसे अच्छा से दूर है, फ़ंक्शन कॉल इवेंट मौजूद नहीं है, मैंने सिर्फ मंदिर में अपनी उंगली घुमा दी और कहा कि यह एक भयानक बकवास था, यह ऐसा करने के लायक नहीं है, और यह, बस, असंभव है।

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

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

1. निष्पादन परिणाम
2. तर्क पारित किए
3. कॉल का संदर्भ (कॉल करते समय यह क्या है)
4. हैंडलर बनाने के बाद फ़ंक्शन कॉल की संख्या

(यह सूची पूरी तरह से हैंडलर को दिए गए तर्कों के अनुरूप है)

addCallListener = function(func, callback){ var callNumber = 0; return function(){ var args = [].slice.call(arguments); var result; try { result = func.apply(this, arguments); callNumber++; } catch (e) { callback(e, args, this, callNumber); throw e; } callback(result, args, this, callNumber); return result; } } 

बहुत सरल और संक्षिप्त, सही?

फिर, हम कुछ फ़ंक्शन को निम्न प्रकार से परिभाषित करते हैं:

 someFunct = addCallListener(someFunct, function(result, args, self, callNumber){ //Do Something }); //  Constructor.prototype.method = addCallListener(Constructor.prototype.method, function(result, args, self, callNumber){ //Do Something }); 

जाहिर है, यह कोड के उस हिस्से में "दृश्यमान" होना चाहिए जहां यह होता है।

कुछ उदाहरण

उदाहरणों को चलाने के लिए, आपके पास एक ओपन कंसोल होना चाहिए (क्रोम में इसे Ctrl + Shift + i) कहा जाता है।

एनीमेशन ट्रैकिंग:
jsfiddle.net/finom/DnRD8
सरणी में पुश विधि निष्पादन की घटना:
jsfiddle.net/finom/bbHhH/1
कुछ अन्य समारोह के निष्पादन की घटना:
jsfiddle.net/finom/ah5My/3

अंत।

आलोचना और परिवर्धन के लिए javascript.ru फोरम के साथियों के लिए धन्यवाद।

युपीडी
थोड़ा विस्तार से फ़ंक्शन: अब, एक कॉलबैक के बजाय, दूसरा तर्क एक ऑब्जेक्ट है

1. इससे पहले (समारोह चलने से पहले बुलाया गया)
2. सफलता (यदि फ़ंक्शन सफलतापूर्वक काम किया है)
3. त्रुटि (यदि कोई त्रुटि होती है)
4. के बाद (वैसे भी, सफलता की परवाह किए बिना)

प्रत्येक हैंडलर को एक ऑब्जेक्ट पास किया जाता है।

1. आर्ग
2. स्व (संदर्भ)
3. नाम (फ़ंक्शन नाम)
4. स्थिति ("त्रुटि" या "सफलता")
5. सक्सेस नम्बर (सफल कॉल की संख्या)
6. errorNumber (त्रुटि के साथ कॉल की संख्या)
7. परिणाम (परिणाम, यदि कोई हो)
8. त्रुटि (त्रुटि, यदि कोई हो)

इसके अलावा, addCallListener फ़ंक्शन अब फंक्शन कंस्ट्रक्टर ऑब्जेक्ट का एक हिस्सा है, एक विंडो या प्रक्रिया में आने से बचने के लिए।

आप यहां कांटा और परीक्षण कर सकते हैं: jsfiddle.net/finom/SGhzd/5