कॉफ़ीस्क्रिप्ट: कक्षाएं

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

सामग्री:

1. मूल अवधारणा
2. कक्षा के सदस्य
2.1। कंस्ट्रक्टर विधि
2.2। कक्षा सदस्यों को खोलें
2.3। निजी वर्ग के सदस्य
2.4। संरक्षित वर्ग के सदस्य
2.5। स्थिर वर्ग के सदस्य
2.6। ऑपरेटर => (मोटा तीर)
3. वंशानुक्रम
4. आगे पढना

मूल अवधारणाएँ

एक वर्ग एक विशेष वाक्य रचना है जो सामान्यीकृत तार्किक रूप से संबंधित संस्थाओं के एक समूह द्वारा प्रस्तुत किया जाता है।

एक वस्तु गुणों का एक अनियंत्रित सेट है जिसमें एक प्रोटोटाइप वस्तु होती है, जिसका मूल्य एक वस्तु या अशक्त हो सकता है।

एक कंस्ट्रक्टर टाइप फंक्शन का एक ऑब्जेक्ट है जो ऑब्जेक्ट्स बनाता और इनिशियलाइज़ करता है।

प्रोटोटाइप - संरचना, स्थिति और व्यवहार की विरासत को लागू करने के लिए उपयोग किया जाता है।
प्रत्येक फ़ंक्शन के लिए प्रोटोटाइप संपत्ति स्वचालित रूप से बनाई गई है ताकि यह सुनिश्चित किया जा सके कि फ़ंक्शन का उपयोग एक निर्माता के रूप में किया जा सकता है।

उदाहरण - एक वर्ग का एक उदाहरण बनाना।

सामान्य सिद्धांत

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

अधिक सटीक परिभाषा देने के लिए, कॉफ़ीस्क्रिप्ट में वर्ग एक सार डेटा प्रकार है जो वस्तुओं के साथ काम करने का एक वैकल्पिक तरीका परिभाषित करता है।

किसी वर्ग को परिभाषित करने के लिए, आपको वर्ग विशेष का उपयोग करने की आवश्यकता है:

class 

प्रसारण परिणाम:

 (function() { function Class() {}; return Class; })(); 

जैसा कि आप देख सकते हैं, एक क्लास एक रैपर ( सिंटैक्टिक शुगर ) है जो एक कंस्ट्रक्टर फ़ंक्शन द्वारा दर्शाया गया है:

 Object::toString.call class # [object Function] 

नए ऑपरेटर का उपयोग करके एक कक्षा (तात्कालिकता) का एक उदाहरण बनाया जाता है

 class A instance = new A 

नए ऑपरेटर को कंस्ट्रक्टर फ़ंक्शन पर लागू करने के बाद, आंतरिक [[निर्माण]] विधि सक्रिय हो जाती है, जो ऑब्जेक्ट बनाने के लिए ज़िम्मेदार है:

 class A Object::toString.call new A # [object Object] 

दूसरे शब्दों में, एक वर्ग की परिभाषा एक वस्तु का निर्माण नहीं है जब तक कि एक तात्कालिकता नहीं होती है:

 class A constructor: (@variable) -> A 1 variable # 1 

ध्यान दें कि वैरिएबल वैरिएबल ग्लोबल नेमस्पेस में उपलब्ध हो गया है।
तात्कालिकता के बिना, वर्ग परिभाषा निम्नलिखित कोड के समान है:

 A = (variable) -> @variable = variable A 1 variable # 1 

जब हम ऑब्जेक्ट के निर्माण को इनिशियलाइज़ करते हैं, तो कंस्ट्रक्टर के अंदर यह निर्मित ऑब्जेक्ट को इंगित करेगा:

 class A constructor: (@property) -> object = new A 1 object.property # 1 property # undefined 

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

 A = (@property) -> object = new A 1 object.property # 1 property # undefined 

वास्तव में, इन विकल्पों में कोई अंतर नहीं है।
हालांकि, यह ध्यान देने योग्य है कि ऐसी वस्तुओं को बनाने के लिए वर्ग विनिर्देशक के साथ वाक्यविन्यास अधिक बेहतर है और अब मैं आपको बताऊंगा ...

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

 A = (variable) -> method = -> variable 

यह पूरी तरह से हानिरहित कोड लगता है?
ठीक है, चलो एक वस्तु बनाने की कोशिश करते हैं:

 A = (param) -> method = -> param object = new A 1 object.method() # TypeError: has no method 'method' 

क्या हो रहा है?
ऐसा क्यों होता है यह समझने के लिए, बस प्रसारण परिणाम को देखें:

 var A = function(param) { return this.method = function() { return param; }; }; 

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

 A = (@method, @param) -> object = new A (-> @param), 1 do object.method # 1 

यह समाधान इस तथ्य के कारण संभव है कि यह उस समय परिभाषित किया जाता है जब ऑब्जेक्ट बनाया जाता है।

अनुवाद परिणाम पर नजर डालते हैं:

 var A, object; A = function(method, param) { this.method = method; this.param = param; }; object = new A((function() { return this.param; }), 1); object.method(); //1 

नोट: ऐसे कार्य जो पैरामीटर के रूप में अन्य कार्यों को लेते हैं या परिणाम के रूप में अन्य कार्यों को वापस करते हैं, प्रथम श्रेणी के कार्य कहलाते हैं। इस स्थिति में, एक फ़ंक्शन पैरामीटर को फंक्शन पैरामीटर या फ़ारग कहा जाता है।

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

 A = (@param) -> A::method = -> @param object = new A 1 object.method() # 1 

यह ध्यान देने योग्य है कि एक वस्तु के गुणों को सीधे और एक प्रोटोटाइप वस्तु के माध्यम से परिभाषित करना, एक ही बात नहीं है:

 A = (@param) -> A::param = 0 object = new A 1 object.param # 1 

स्वयं के गुणों की एक उच्च प्राथमिकता है, इसलिए उन्हें पहले विश्लेषण किया जाता है, और फिर प्रोटोटाइप श्रृंखला में खोज की जाती है।

आपको याद दिला दूं कि अब हम निर्माण कार्यों और इस समस्या को हल करने के तरीकों में एक वापसी बयान को जोड़ने के मुद्दे पर विचार कर रहे हैं।

 A = (@param) -> @method = -> @param @ object = new A 1 object.method() # 1 

यह नव निर्मित वस्तु को इंगित करेगा।
यह विचार करने योग्य है कि यदि लौटाया गया मूल्य एक वस्तु है, तो यह नई अभिव्यक्ति का परिणाम होगा:

 A = (@param) -> @method = -> @param [] object = new A 1 object # [] Object::toString.call(object) # [object Array] object.method() # TypeError: Object has no method 'method' 

तदनुसार, विधि संपत्ति तक पहुंचने के लिए, आपको स्पष्ट रूप से उस वस्तु को वापस करना होगा, जिसमें यह संपत्ति है:

 A = (param) -> object = {} object.method = -> param object object = new A 1 object.method() #1 

बेशक, इससे कोई फर्क नहीं पड़ता कि वस्तु का संदर्भ कैसे वापस किया जाता है:

 A = (param) -> method: -> param object = new A 1 object.method() #1 

इस स्थिति में, एक अनाम ऑब्जेक्ट का संदर्भ निर्माता फ़ंक्शन ए में वापस आ जाता है ।

सभी एक ही रिटर्निंग फंक्शन्स पर लागू होते हैं:

 A = (one) -> (two) -> one + two object = new A 1 object 2 # 3 

जैसा कि आप समझते हैं, इस मामले में नए ऑपरेटर का उपयोग वैकल्पिक है। और नेस्टेड फ़ंक्शन के अंदर यह वैश्विक ऑब्जेक्ट को इंगित करेगा:

 A = -> -> @ new A()() # global 

यह ध्यान देने योग्य है कि सख्त मोड का उपयोग करते समय ( सख्त उपयोग करें ), यह अपरिभाषित को इंगित करेगा:

 A = -> 'use strict' -> @ new A()() # undefined 

इसके लिए एक नई बनाई गई वस्तु को इंगित करने के लिए, आपको नए ऑपरेटर को स्पष्ट रूप से जोड़ना होगा:

 A = -> new -> @ new A() # object 

फिर आपके पास एक काउंटर प्रश्न होना चाहिए, नेस्टेड फ़ंक्शन के मापदंडों को कैसे पारित किया जाए:

 A = (one) -> new (two) -> one + two object = new A 1 object.constructor 2 # 3 

कृपया आंतरिक कॉफीस्क्रिप्ट कंस्ट्रक्टर () विधि और कंस्ट्रक्टर फ़ंक्शन के लिंक को भ्रमित न करें, जिसके माध्यम से आप ऑब्जेक्ट प्रोटोटाइप के लिए लिंक प्राप्त कर सकते हैं:

 A = -> new -> object = new A object.constructor:: # object object.constructor::constructor 2 # 3 

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

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

 @..:: # this.constructor.prototype 

कक्षा के सदस्य

कंस्ट्रक्टर () विधि

एक क्लास कंस्ट्रक्टर एक विशेष कंस्ट्रक्टर () विधि है जिसे क्लास बॉडी में परिभाषित किया गया है और एक ऑब्जेक्ट के सदस्यों को इनिशियलाइज़ करने के लिए डिज़ाइन किया गया है।

 class A A::property = 1 object = new A object.property # 1 

इस उदाहरण में, हमने ए नामक एक वर्ग के निर्माण की शुरुआत की ।
वर्ग का एकमात्र सदस्य संपत्ति गुण है , जो औपचारिक रूप से ऑब्जेक्ट ए के प्रोटोटाइप में स्थित है ।

क्योंकि यह हमेशा A को इंगित करेगा (और अनुवादित भी), यह वर्ग परिभाषा को फिर से लिखने के लिए समझ में आता है:

 class A @::property = 1 

रिकॉर्ड की कॉम्पैक्टनेस के बावजूद, CoffeScript में क्लास के सदस्यों की ऐसी परिभाषा स्वीकार नहीं की जाती है । इसके अलावा, एक और अधिक सुंदर समाधान है:

 class A property: 1 

इसके बाहर एक वर्ग के सदस्यों को निर्धारित करने के लिए, आपको पहले स्वरूप का उपयोग करना चाहिए:

 class A A::property = 1 

जैसा कि पहले उल्लेख किया गया है, वर्ग के प्रत्येक उदाहरण में अपने स्वयं के निर्माता के लिए एक लिंक है, जिसके पास प्रोटोटाइप संपत्ति उपलब्ध है।
इस प्रकार ऑब्जेक्ट के प्रारंभिक प्रोटोटाइप का लिंक प्राप्त करने के बाद, आप कक्षा के नए सदस्यों को परिभाषित कर सकते हैं:

 class A object1 = new A object1.constructor::property = 1 object2 = new A object2.property # 1 object2.constructor is A # true 

यदि आपको प्रोटोटाइप में कई गुण जोड़ने की आवश्यकता है, तो यह "थोक में" बनाने के लिए समझ में आता है:

 class A A:: = property: 1 method: -> @property object2 = new A object2.method() # 1 

हालाँकि, इस मामले में, निर्माणकर्ता संपत्ति किसी अन्य वस्तु की ओर संकेत करेगी:

 class A A:: = {} object = new A object.constructor is A # false 

इस तथ्य के बावजूद कि मूल प्रोटोटाइप का लिंक खो जाएगा, कुछ इसे नोटिस करेंगे:

 class A A:: = {} object = new A object.constructor::property = 1 # ! object.property # 1 

आपको ऐसी स्थितियों में विशेष रूप से सावधान रहने की आवश्यकता है, क्योंकि वर्ग की एक आवृत्ति के माध्यम से एक नई संपत्ति जोड़ना, हम इस संपत्ति को सभी वस्तुओं में जोड़ देंगे!

हम उदाहरण को ध्यान से देखते हैं:

 class A A:: = property: 1 method: -> @property object = new A object.constructor::property = 'Oh my god!' object.method() # 1 object.property # 1 list = [] list.property # 'Oh my god!' 

यह व्यवहार इस तथ्य के कारण संभव हुआ कि अब निर्माणकर्ता वस्तु को इंगित करता है:

 class A A:: = {} object = new A object.constructor # [Function: Object] object.constructor is Object # true 

दूसरे शब्दों में, इसे जाने बिना, हमें निम्नलिखित मिला:

 Object::property = 'Oh my god!' 

बेशक, कुछ लोग अपनी वस्तुओं में तीसरे पक्ष के तरीकों को देखना पसंद करेंगे।
मूल निर्माता के लिए सही संदर्भ रखने के लिए, आपको इसे स्पष्ट रूप से फिर से बनाना होगा:

 class A A:: = constructor: A object = new A object.constructor::property = 1 object.property # 1 object.constructor is A # true 

अब प्रोटोटाइप ऑब्जेक्ट का संदर्भ सही है।

यदि आपको याद है, तो हम कंस्ट्रक्टर () वर्ग विधि पर विचार करने लगे। इसलिए, इस विधि का एकमात्र उद्देश्य मापदंडों को शुरू करना है:

 class A constructor: (param) -> @param = param object = new A 1 object.param # 1 

इसके अनुसार, अगर क्लास कंस्ट्रक्टर को पैरामीटर पास करने की आवश्यकता नहीं है, तो कंस्ट्रक्टर () विधि को छोड़ना बुद्धिमान होगा।

यह वैचारिक रूप से इतना था कि कंस्ट्रक्टर को किसी भी मूल्य को वापस नहीं करना चाहिए और इसे अधिभारित नहीं किया जा सकता है ( CoffeeScipt ऑपरेटरों और कार्यों को अधिभार नहीं देता है)।

चूंकि कंस्ट्रक्टर फ़ंक्शन में पैरामीटर पास करना काफी सामान्य ऑपरेशन है, कॉफीस्क्रिप्ट में एक विशेष सिंटैक्स है:

 class A constructor: (@param) -> object = new A 1 object.param # 1 

आइए प्रसारण के परिणाम को देखें:

 var A, object; A = (function() { function A(param) { this.param = param; } return A; })(); object = new A(1); object.param; //1 

जैसा कि आप देख सकते हैं, परम वस्तु ए की प्रत्यक्ष संपत्ति है, अर्थात। किसी भी समय इसे संशोधित किया जा सकता है और हटाया भी जा सकता है।

 class A constructor: (@param) -> object = new A 1 object.param = 2 object.param # 2 

इस मामले में, हमने वर्ग के एक विशिष्ट उदाहरण की संपत्ति के मूल्य को फिर से परिभाषित किया, जो अन्य उदाहरणों को प्रभावित नहीं करेगा।

अगला, हम एक्सेस स्तर संशोधक के कार्यान्वयन को देखते हैं जो कॉफ़ीसर्पिट भाषा का हिस्सा नहीं हैं (हालाँकि बहुत से लोग ऐसा सोचते हैं)।

वर्ग के सार्वजनिक सदस्य (सार्वजनिक)

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

वर्ग के सभी सार्वजनिक सदस्यों को साहचर्य संकेतन में लिखा जाता है, प्रमुख चरित्र के बिना @ और / या यह :

 class A constructor: (@param) -> method: -> @param object = new A 1 object.method() # 1 

प्रसारण परिणाम:

 var A, object; A = (function() { function A(param) { this.param = param; } A.prototype.method = function() { return this.param; }; return A; })(); object = new A(1); object.method(); //1 

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

 class A property: 1 method: -> @property object = new A object.method() # 1 

निजी वर्ग के सदस्य (निजी)

किसी वर्ग के निजी सदस्यों में, उस सदस्य की पहुँच केवल उस वर्ग के तरीकों से होती है जिसमें यह सदस्य परिभाषित होता है। वर्ग उत्तराधिकारियों की निजी सदस्यों तक पहुंच नहीं है।

बंद वर्ग के सदस्यों को शाब्दिक अंकन में लिखा गया है:

 class A constructor: (@param) -> property = 1 # private method: -> property + @param object = new A 1 object.method() # 2 object.property # undefined 

तकनीकी रूप से, किसी वर्ग के निजी सदस्य सामान्य स्थानीय चर होते हैं:

 var A, object; A = (function() { var property; function A(param) { this.param = param; } property = 1; A.prototype.method = function() { return property + this.param; }; return A; })(); object = new A(1); object.method(); object.property; # 2 

वर्तमान में, निजी सदस्यों का कार्यान्वयन बहुत सीमित है। विशेष रूप से, एक वर्ग के निजी सदस्य कक्षा के बाहर परिभाषित सदस्यों के लिए सुलभ नहीं हैं:

 class Foo __private = 1 Foo::method = -> try __private catch error 'undefined' object = new Foo object.method() #undefined 

ऐसा क्यों होता है यह समझने के लिए, प्रसारण के परिणाम पर एक नज़र डालें:

 var A; A = (function() { var __private; function A() {} __private = 1; return Foo; })(); A.prototype.method = function() { try { return __private; } catch (error) { return 'undefined'; } }; 

निश्चित रूप से आपके पास पहले से ही एक सवाल है: आप बाहरी सदस्यों की परिभाषा को एक रचनाकार फ़ंक्शन में क्यों नहीं डाल सकते हैं?
वास्तव में, यह समस्या को हल नहीं करेगा, क्योंकि कक्षा के सदस्यों की परिभाषा अलग-अलग फाइलों में हो सकती है!

आंशिक रूप से इस समस्या को हल करना बहुत सरल तरीके से किया जा सकता है:

 class A constructor: (@value) -> privated = (param) -> @value + param __private__: (name, param...) -> eval(name).apply @, param if !@constructor.__super__ A::method = -> @__private__ 'privated', 2 class B extends A B::method = -> @__private__ 'privated', 2 object = new A 1 object.method() # 3 object = new B 1 object.method() # undefuned object.privated # undefuned 

जैसा कि आप देख सकते हैं, निजी वर्ग का एक सदस्य केवल आधार वर्ग के सदस्यों के लिए उपलब्ध है।

आधार वर्ग में निम्नलिखित विधि को परिभाषित करने के लिए हम सभी की आवश्यकता थी:

 __private__: (name, param...) -> eval(name).apply @, param if !@constructor.__super__ 

लेकिन एक समस्या है, हमारी निजी संपत्ति सीधे __pirt__ विधि के माध्यम से उपलब्ध है:

 object.__private__ 'privated', 2 # 3 

मामूली सुधार को ध्यान में रखते हुए (इस पर ध्यान देने और समाधान का प्रस्ताव देने के लिए धन्यवाद), यह सवाल भी बंद हो सकता है:

 __private__: (name, param...) -> parent = @constructor.__super__ for key, value of @constructor:: allow = on if arguments.callee.caller is value and not parent eval(name).apply @, param if alllow 

इस कार्यान्वयन के लाभों में शामिल हैं:
+ सादगी और दक्षता
मौजूदा कोड में + आसान कार्यान्वयन

नुकसान की:
- eval फ़ंक्शन और तर्कों का उपयोग करना ।allee.caller
- अतिरिक्त "परत" __pirt__
- वास्तविक व्यावहारिक मूल्य की कमी
- विवरणक गुण इस पद्धति की गणना को नियंत्रित करते हैं, संशोधन और विलोपन __pirt__ विधि में सेट नहीं किए जाते हैं।

कार्यान्वयन की खामियों के बारे में अंतिम पैराग्राफ निम्नानुसार तय किया जा सकता है:

 Object.defineProperty @::, '__private__' value: (name, param...) -> eval(name).apply @, param if !@constructor.__super__ 

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

 class A constructor: (@value) -> privated = (param) -> @value + param Object.defineProperty @::, '__private__' value: (name, param...) -> parent = @constructor.__super__ for key, value of @constructor:: allow = on if arguments.callee.caller is value and not parent eval(name).apply @, param if allow A::method = -> @__private__ 'privated', 2 class B extends A B::method = -> @__private__ 'privated', 2 object = new A 1 object.method() # 3 object = new B 1 object.method() # undefuned object.privated # undefuned i for i of object # 3, value, method 

संरक्षित वर्ग के सदस्य (संरक्षित)

संरक्षित वर्ग के सदस्य केवल आधार वर्ग और उसके वंशजों के तरीकों के भीतर उपलब्ध हैं।

औपचारिक रूप से, संरक्षित श्रेणी के सदस्यों को परिभाषित करने के लिए CoffeeScript के पास एक विशेष वाक्यविन्यास नहीं है। फिर भी, हम स्वतंत्र रूप से एक समान कार्यक्षमता लागू कर सकते हैं:

 class A constructor: (@value) -> protected = (param) -> @value + param __protected__: (name, param...) -> parent = @constructor.__super__ for key, value of @constructor:: allow = on if arguments.callee.caller is value eval(name).apply @, param if allow A::method = -> @__protected__ 'privated', 2 class B extends A B::method = -> @__protected__ 'privated', 2 object = new A 1 object.method() # 3 object = new B 1 object.method() # 3 object.protected # undefuned 

जैसा कि आप देख सकते हैं, इस समाधान की वास्तुकला लगभग वर्ग के निजी सदस्यों के साथ समस्या के समाधान के समान है, और इसलिए वर्णनकर्ता के गुणों के साथ भी यही समस्या है। अंतिम निर्णय इस प्रकार होगा:

 Object.defineProperty @::, '__private__' value: (name, param...) -> parent = @constructor.__super__ for key, value of @constructor:: allow = on if arguments.callee.caller is value eval(name).apply @, param if allow 

यह ध्यान देने योग्य है कि यह इस समस्या के एकमात्र समाधान से दूर है, यह कार्यान्वयन को समझने के लिए बस सबसे सार्वभौमिक है।

स्थिर वर्ग के सदस्य (स्थिर)

स्थिर वर्ग के सदस्य:
- @ या इससे पहले
- केवल एक ही कॉपी में मौजूद हो सकता है
- वर्ग के गैर-स्थैतिक सदस्यों के लिए केवल आधार वर्ग के प्रोटोटाइप ऑब्जेक्ट के माध्यम से उपलब्ध है

एक वर्ग के स्थिर सदस्य को परिभाषित करने के एक उदाहरण पर विचार करें:

 class A @method = (param) -> param A.method 1 # 1 

अब एक वर्ग के स्थिर सदस्य को लिखने के संभावित (सबसे उपयुक्त) रूप को देखें:

 @property: @ @property = @ this.property = @ this.constructor::property = 1 @constructor::property = 1 Class.constructor::property = 1 

यदि आप नोटिस करते हैं, तो @ प्रतीक का उपयोग करना अधिक सार्वभौमिक है।

आधार वर्ग के प्रोटोटाइप ऑब्जेक्ट के माध्यम से ही वर्ग के अन्य गैर-स्थैतिक सदस्यों तक पहुंच संभव है:

 class A property: 1 @method: -> @::property do A.method # 1 

वर्ग के अन्य स्थिर सदस्यों तक पहुंच @ प्रतीक या इस या वर्ग के नाम के माध्यम से उपलब्ध है:

 class A @property: 1 @method: -> @property + A.property do A.method # 2 

नए ऑपरेटर के उपयोग पर विशेष ध्यान देने के लायक एक और बिंदु है:

 class A @property: 1 @method: -> @property object = new A object.method() # TypeError: Object # <A> has no method 'method' 

जैसा कि आप देख सकते हैं, टाइप- एरर त्रुटि प्रकार के कारण किसी भी गैर-कॉल विधि के लिए कॉल नहीं हुआ!
अब, कक्षा के एक उदाहरण के माध्यम से किसी वर्ग के स्थिर सदस्य को कॉल करने का सही तरीका देखें:

 class A @property: 1 @method: -> @property object = new A object.constructor.method() # 1 

=> (वसा तीर)

वर्ग के सदस्यों के साथ काम करते समय एक और महत्वहीन क्षण नहीं है = = ऑपरेटर (वसा तीर) का उपयोग करने की क्षमता, जो आपको कॉल संदर्भ को नहीं खोने देता है।
उदाहरण के लिए, यह कॉलबैक फ़ंक्शंस बनाने के लिए उपयोगी हो सकता है।

 class A constructor: (@one, @two) -> method: (three) => @one + @two + three instance = new A 1, 2 object = (callback) -> callback 3 object instance.method # 6 

हम कॉल () विधि का उपयोग करके समान परिणाम प्राप्त कर सकते हैं:

 class A constructor: (@one, @two) -> method: (three) -> @one + @two + three instance = new A 1, 2 object = (callback) -> callback.call instance, 3 object instance.method # 6 

अब, विधेय का उपयोग करते हुए स्थिति को देखते हैं:

 class A constructor: (@splat...) -> method: (three) => @splat instance = new A 1, 2, 3, 4, 5 object = (callback, predicate) -> predicate callback() object instance.method, (callback) -> callback.filter (item) -> item % 2 # [1, 3, 5] 

इस उदाहरण में, हमने टाइप ए के मापदंडों की एनटी संख्या के साथ वर्ग ए के निर्माण को शुरू किया।
इसके बाद, विधि वर्ग के एक सदस्य ने एक सरणी को लौटा दिया, जिसमें निर्माणकर्ता को दिए गए पैरामीटर थे। उसके बाद, परिणामी सरणी को विधेय में पारित किया गया, जिसने सरणी मोडुलो 2 के मूल्यों को फ़िल्टर किया, जिसके परिणामस्वरूप एक नया सरणी बना।

विरासत

CoffeScript में वंशानुक्रम का विस्तार विवरण का उपयोग करके किया जाता है।

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

 class A constructor: (@property) -> method: -> @property class B extends A object = new B 1 object.method() # 1 

इस तथ्य के बावजूद कि क्लास बी अपने स्वयं के सदस्यों को परिभाषित नहीं करता है, यह उन्हें ए से विरासत में मिला है ।
अब, ध्यान दें कि संपत्ति गुण वर्ग B के अंदर भी उपलब्ध है:

 class A constructor: (@property) -> class B extends A method: -> @property object = new B 1 object.method() # 1 

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

 A = (@param) -> A::method = (x) -> @param * x B = (@param) -> B extends A (new B 2).method 2 # 4 

दुर्भाग्य से, आधिकारिक कॉफीस्क्रिप्ट प्रलेखन बल्कि उदाहरणों के साथ "विरल" है, हालांकि आप किसी विशेष कोड के कार्यान्वयन को देखने के लिए हमेशा अनुवादक का उपयोग कर सकते हैं:

कोड विश्लेषण के लिए सबसे महत्वपूर्ण विकल्प:

 coffee -c file.coffee #  .coffee   JavaScript     . coffee -p file.coffee #      coffee -e 'console.log i for i in [0..5]' #    coffee -t #   

एक प्रोग्राम की संरचना का विश्लेषण करने के लिए -n (--nodes) पैरामीटर का बहुत महत्वपूर्ण मूल्य है; यह एक सिंटैक्स ट्री देता है;

 class A @method: @ class B extends A do (new B).method 

 coffee -n 

 Block Class Value "A" Block Value Obj Assign Value "this" Access "method" Value "this" Class Value "B" Value "A" Block Call Value Parens Block Op new Value "B" Access "method" 

CoffeeScript के लिए सबसे पूर्ण सिंटैक्स के लिए , आधिकारिक दस्तावेज़ के नोड्स कोड को देखें।

यदि आप कक्षाओं में समान नाम के साथ तरीकों को परिभाषित करते हैं, तो मूल विधि विरासत में मिली एक को ओवरराइड करेगी:

 class A constructor: -> method: -> 'A' class B extends A method: -> 'B' object = new B object.method() # B 

इस तथ्य के बावजूद कि यह व्यवहार काफी अपेक्षित है, हमारे पास अभी भी बी से क्लास ए पद्धति को कॉल करने का अवसर है:

 class A A::method = -> 'A' class B extends A B::method = -> super object = new B object.method() # A 

यह कोड पिछले एक से बहुत अलग नहीं है, इस मामूली अपवाद के साथ कि एक सुपर ऑपरेटर को क्लास बी पद्धति में लौटाया जाता है।
सुपर ऑपरेटर का कार्य मूल वर्ग में परिभाषित गुणों को कॉल करना और कॉल पैरामीटर को इनिशियलाइज़ करना है।

इसी समय, वंशानुक्रम संरचना कोई फर्क नहीं पड़ता, वंशानुगत श्रृंखला के पदानुक्रमित श्रृंखला में निकटतम वर्ग की विधि को कहा जाता है:

 class A A::method = -> 'A' class B extends A B::method = -> 'B' class C extends B C::method = -> super object = new C object.method() # B,     method    B 

यदि विधि को प्रत्यक्ष अभिभावक में परिभाषित नहीं किया गया है, तो खोज प्रतिनिधि बिंदुओं की श्रृंखला का अनुसरण करके जारी है:

 class A A::method = -> 'A' class B extends A class C extends B C::method = -> super object = new C 1 object.method() # 'A',     method    A 

सुपर ऑपरेटर भी पैरामीटर ले सकता है:

 class A constructor: (@param) -> A::method = (x) -> x + @param class B extends A B::method = -> super 3 object = new B 1 object.method 2 # 4 (3 + 1) 

इस तथ्य के बावजूद कि पैरामीटर 2 के साथ विधि को बुलाया गया था, बाद में हमने इस मूल्य को 3 पर फिर से परिभाषित किया।

यदि आप कंस्ट्रक्टर विधि में सुपर ऑपरेटर को परिभाषित करते हैं, तो आप उन मापदंडों को ओवरराइड कर सकते हैं जिनके साथ क्लास कंस्ट्रक्टर को इनिशियलाइज़ किया गया है:

 class A constructor: (@param) -> A::method = (x) -> x + @param class B extends A constructor: (@param) -> super 3 object = new B 1 object.method 2 # 5 (2 + 3) 

बेशक, वर्ग सदस्यों और निर्माता में सुपर ऑपरेटर के एक साथ उपयोग की अनुमति है:

 class A constructor: (@param) -> A::method = (x) -> x + @param class B extends A constructor: (@param) -> super 3 B::method = (x) -> super 4 object = new B 1 object.method 2 # 7 (3 + 4) 

अब, मैं पैटर्न के आंतरिक कार्यान्वयन पर विस्तार से विचार करने का प्रस्ताव करता हूं, जो विरासत इंटरफ़ेस को लागू करता है:

 var A, B, object, //    hasOwnProperty __hasProp = {}.hasOwnProperty; //  __extends     , // , , .. child    parent __extends = function(child, parent) { //    parent for (var key in parent) { //    ( ) if (__hasProp.call(parent, key)) { //    child,   parent. //       , //   c   child[key] = parent[key]; } } //   - function ctor() { //    constructor    child this.constructor = child; } //   . //        parent ctor.prototype = parent.prototype; //        child.prototype = new ctor(); //      //     super child.__super__ = parent.prototype; //    return child; }; //   A = (function() { function A() {}; return A; })(); //   B = (function(_super) { //   __extends. //       B, //  -     A __extends(B, _super); function B() { //    A    B //  A.apply(this, arguments); return B.__super__.constructor.apply(this, arguments); } return B; })(A); 

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

आगे पढ़ रहे हैं

ECMA-262-3. 7.1. :
ECMA-262-3. 7.2. : ECMAScript

-
विरासत

PS: , , CoffeeScript — .