दुमियों के लिए जावास्क्रिप्ट अशुद्धियाँ

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

1. अशुद्धता, वास्तव में, क्या हैं?

एक मिश्रण (मिक्सचर) एक ऐसा कार्य है, जो ऐसे कार्यों के समूह के साथ होता है, जिसका उपयोग स्वयं (अन्य वस्तुओं से अलग) नहीं किया जाता है।

यहाँ, उदाहरण के लिए, एक अद्भुत प्रवेश है:

var Mixin_Babbler = { say: function () { console.log("My name is " + this.name + " and i think:'" + this.THOUGHTS + "'"); }, argue: function() { console.log("You're totally wrong"); } }; 

जब उक्त विधि को ठीक उसी तरह से कॉल करने की कोशिश की जा रही है, तो एक bummer हमारी प्रतीक्षा कर रहा है, क्योंकि न तो यह.नहीं और न ही यह । किसी भी कारण से, किसी भी कारण से, हमारे पास यह मौजूद नहीं है।
वास्तव में, सब कुछ सही है, अपने इच्छित उद्देश्य के लिए अशुद्धता का उपयोग करने के लिए, हमें एक और ऑब्जेक्ट की आवश्यकता है, और एक विधि जो इसे अशुद्धता वस्तुओं के सभी गुणों को कॉपी करती है जो कि कंस्ट्रक्टर फ़ंक्शन के प्रोटोटाइप में स्थानांतरित होती है - आमतौर पर इस विधि को विस्तार, या मिश्रण, या ऐसा कुछ कहा जाता है:

 function extend(object) { var mixins = Array.prototype.slice.call(arguments, 1); for (var i = 0; i < mixins.length; ++i) { for (var prop in mixins[i]) { if (typeof object.prototype[prop] === "undefined") { object.prototype[prop] = mixins[i][prop]; } } } } 

2. खैर, इसका उपयोग कैसे करें?

आसान और बिना तनाव के - मान लें कि हमारे पास कुछ अशुद्धियाँ हैं:

 var Mixin_Babbler = { say: function () { console.log("My name is " + this.name + " and i think:'" + this.THOUGHTS + "'"); }, argue: function() { console.log("You're totally wrong"); } }; var Mixin_BeverageLover = { drink: function () { console.log("* drinking " + this.FAVORITE_BEVERAGE + " *"); } }; 

और, किसी को, शायद पहले से ही परिचित, विकासवादी श्रृंखला:

 function Man(name) { this.name = name; } Man.prototype = { constructor: Man, THOUGHTS: "I like soccer" } extend(Man, Mixin_Babbler); function Gentleman(name) { this.name = name; } Gentleman.prototype = { constructor: Gentleman, THOUGHTS: "I like Earl Grey", FAVORITE_BEVERAGE: "Tea" } extend(Gentleman, Mixin_Babbler, Mixin_BeverageLover); function Programmer(name) { this.name = name; } Programmer.prototype = { constructor: Programmer, THOUGHTS: "MVC, MVVM, MVP *___* like it!", FAVORITE_BEVERAGE: "Cofee", write_good_code: function () { console.log("*writing best code ever*"); this.drink(); } } extend(Programmer, Mixin_Babbler, Mixin_BeverageLover); 

प्रत्येक "वर्ग" अब दूसरे से स्वतंत्र है, और सभी दोहराई जाने वाली कार्यक्षमता अशुद्धियों का उपयोग करके कार्यान्वित की जाती है।

अब यह सब कुछ जांचने के लायक है - यह अचानक काम करेगा:

 var man = new Man("Bob"); var gentleman = new Gentleman("Bill"); var programmer = new Programmer("Benjamin"); man.say(); man.argue(); gentleman.say(); gentleman.drink(); programmer.say(); programmer.write_good_code(); 

और कंसोल का कहना है कि हाँ, सब कुछ वैसा ही होना चाहिए:

 My name is Bob and i think:'I like soccer' *You're totally wrong* My name is Bill and i think:'I like Earl Grey' *drinking Tea* My name is Benjamin and i think:'MVC, MVVM, MVP like *__* it!' *writing best code ever* *drinking Cofee* 

वास्तव में सब कुछ। "शास्त्रीय" विरासत के विपरीत, अशुद्धियों का कार्यान्वयन बहुत सरल और सीधा है। बेशक, कुछ विविधताएं हैं, लेकिन एक तरह से या किसी अन्य, कर्नेल बिल्कुल वैसा ही दिखता है।

युपीडी। जैसा कि उपनाम ललाकी के साथ एक बहुत अच्छे व्यक्ति ने सुझाव दिया , विस्तार विधि को थोड़ा अलग तरीके से लागू किया जा सकता है:

 function extend_2(object) { var mixins = Array.prototype.slice.call(arguments, 1); for (var i = 0; i < mixins.length; ++i) { for (var prop in mixins[i]) { if (typeof object.prototype[prop] === "undefined") { bindMethod = function (mixin, prop) { return function () { mixin[prop].apply(this, arguments) } } object.prototype[prop] = bindMethod(mixins[i], prop); } } } } 

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

सभी कोड और उदाहरण शांति से यहीं हैं।