जावास्क्रिप्ट में AOP सिंटैक्टिक शुगर

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

जावास्क्रिप्ट में, ऐसे बहुत सारे फ्रेमवर्क नहीं हैं, और जिन्हें मैं फ़ंक्शंस का विस्तार करते समय खोजने में कामयाब रहा, वे एक सामान्य ईवेंट सदस्यता की तरह थे। सामान्य तौर पर, मैं वाक्य रचना की तरह बिल्कुल नहीं था, मैं कुछ सरल चाहता था, और .NET और जावा के "उच्च मामलों" के करीब।

हम अपने आप को विशिष्ट कार्य निर्धारित करते हैं। तर्क जोड़ने की जरूरत है:
• एक समारोह प्रदर्शन करने से पहले
• एक कार्य करने के बाद
• अपवाद के मामले में

.NET विशेषताएँ मेरे करीब हैं, और इस तरह के सिंटैक्स का कार्यान्वयन स्वयं का सुझाव देता है, इसलिए हम C # में एक छोटे से उदाहरण से शुरू करेंगे

[AttributeName(Params)] [AttributeName(Params), AttributeName(Params)] public void Foo() { … } 

जावास्क्रिप्ट के लिए मान्य होने के लिए कोड को थोड़ा संशोधित करें

 AOP( [AttributeName(Params)], [AttributeName(Params) , AttributeName(Params)], function Foo() { … } ); 

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

 function AOP() { var advices = []; //    for (var i = 0; i < arguments.length; i++) { var arg = arguments[i]; //     ,    , //      if (Object.prototype.toString.call( arg ) === "[object Array]") { for (var j = 0, advice = arg[j]; j < arg.length; j++) { advices.push(advice); } } else { if (typeof arg === "function") { name = getFunctionName(arg); //    // ..    for (var j = 0; j < advices.length; j++) { var advice = advices[j]; arg = advice.apply(arg); } //      , //   ,    //   .    .    //  FunctionName window[name] = arg; } //     advices.length = 0; } } } function getFunctionName(fn) { var source = fn.toString(); var head = source.split("(")[0]; var fnName = head.split(" ")[1]; return fnName; } 

हम कार्यक्षमता के विस्तार को व्यवस्थित करते हैं

 function Advice(implementation) { this.implementation = implementation; } // fn -      Advice.prototype.apply = function(fn) { if (typeof fn !== "function") { throw "You can apply an advice only to a function"; } //    return this.implementation(fn); } 

और हमारे द्वारा आवश्यक विशेषताएँ जोड़ें

 function OnBeforeAdvice(onBeforeHandler) { return new Advice(function(fn) { return function() { onBeforeHandler(fn, arguments); return fn.apply(this, arguments); } }); } function OnAfterAdvice(onAfterHandler) { return new Advice(function(fn) { return function() { var result = fn.apply(this, arguments); onAfterHandler(fn, arguments, result); return result; } }); } function OnErrorAdvice(onErrorHandler) { return new Advice(function(fn) { return function() { try { return fn.apply(this, arguments); } catch (e) { onErrorHandler(fn, arguments, e); } } }); } //        //  "Pet.prototype.getName" function FunctionName(fnName) { return new Advice(function(fn) { var root = window, objs = fnName.split("."), i, oName; for (i = 0; i < objs.length - 1; i++) { oName = objs[i]; if (!root.oName) { root[oName] = {}; } root = root[oName]; } oName = objs[i]; root[oName] = fn; return fn; }); } 

सब कुछ तैयार है, आप तरीके बना सकते हैं और उनका विस्तार कर सकते हैं

  <script type="text/javascript"> AOP( [OnBeforeAdvice(onBeforeHandler)], [OnAfterAdvice(onAfterHandler)], function sqr(x) { return x * x; }, [OnAfterAdvice(onBeforeHandler)], [FunctionName("AliasA")], function A() { }, [OnErrorAdvice(onErrorHandler)], function throwsException() { throw "Exception"; } ); function onBeforeHandler(fn, args) { console.log("I know that somebody calls " + fn.toString().split("(")[0]); } function onAfterHandler(fn, args, result) { console.log("Returns " + result + " from " + args[0]); } function onErrorHandler(fn, args, e) { console.log(e + " was thrown"); } onload = function () { sqr(10); A(); AliasA(); throwsException(); } </script> 

और अब आप एक पंक्ति के साथ चिह्नित करते हुए, "सुरुचिपूर्ण ढंग से" कार्यों का पालन कर सकते हैं। आप एओपी () फ़ंक्शन को परिष्कृत कर सकते हैं और ऑब्जेक्ट्स पर भी विशेषताओं को लागू कर सकते हैं, लेकिन यह थोड़ा अलग काम होगा।

विकिपीडिया लेख में जावास्क्रिप्ट के लिए एओपी कार्यान्वयन के लिंक हैं, आप तुलना कर सकते हैं। और एक अन्य पहलू जेएस परियोजना

पुनश्च: eval के बारे में एक उचित बिंदु बनाया। उन्होंने एक कोड का टुकड़ा वापस किया जिसे उन्होंने इस लेख में बेमानी माना।