🐆 👇🏻 🌸 मैंने विम में कक्षाएं कैसे लिखीं 😏 🤜🏻 🖇️

प्रस्तावना

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

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

आपको कहां से शुरुआत करनी थी

शुरुआत के लिए, कुछ शब्द जो विम के पास "बॉक्स से बाहर" है और हम काम के लिए क्या उपयोग करेंगे।
टाइपिंग - जहां इसके बिना, इसमें 6 डेटा प्रकार हैं: इंटेगर, फ्रैक्शनल नंबर, स्ट्रिंग्स, पॉइंटर टू फंक्शंस, एरे, एसोसिएटिव एरे। यहां हमारे लिए सबसे दिलचस्प अंतिम प्रकार है। जेएस की तरह ही सहयोगी सरणियाँ बनाई जाती हैं:

''  «»      let Obj = {'foo': 'bar'}

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

चर - महत्वपूर्ण कुछ भी नहीं, सिवाय महत्वपूर्ण "सिंटैक्टिक शुगर" के - एक डॉट के माध्यम से साहचर्य सरणी के तत्वों तक पहुंचने की क्षमता:

 ''      foo echo Obj.foo

सुविधापूर्वक, वह शब्द नहीं!

कार्य - एक महत्वपूर्ण विशेषता यह है कि आप एक फ़ंक्शन को एक "ऑब्जेक्ट" पर असाइन कर सकते हैं, अर्थात, जब आप किसी फ़ंक्शन को किसी सहयोगी सरणी से कॉल करते हैं, तो आप इसे स्वयं चर के माध्यम से एक्सेस कर सकते हैं:

 function! Obj.getFoo() dict return self.foo endfunction

इसके अलावा, आपको वस्तुओं को सीधे कार्यों को जोड़ने की क्षमता की दृष्टि नहीं खोनी चाहिए।

मानक संरचनाएं, जैसे कि, यदि और इसके लिए - उनके बिना कौन सी लिपि भाषा!

सिद्धांत

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

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

आदर्श रूप में, सब कुछ इस तरह से देखा जाना चाहिए:

 use foo\bar\Class as Class ''   MyClass    Class     foo  bar let MyClass = Class.expand({'foo': '', 'bar': Class}) let obj = new MyClass() call obj.set('prop', 'val') echo obj.get('prop') call obj.set('bar', obj)

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

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

 let obj = new MyClass('val')

हम यहां तरीकों और उनके पुनर्निर्धारण को परिभाषित करने की क्षमता को जोड़ते हैं, और एक वास्तविक प्रोटोटाइप ऑब्जेक्ट ओरिएंटेशन प्राप्त करते हैं।

पहला कदम

बेशक, व्यवहार में, सब कुछ सिद्धांत के समान नहीं है, भाषा की विशिष्टताओं के कारण विम में बहुत कुछ महसूस नहीं किया जा सकता है, मुझे उच्च थोकता के कारण कुछ छोड़ना पड़ा, परिणामस्वरूप मुझे निम्नलिखित प्राप्त हुआ:

 Use D/base/Object "   A     Object let A = Object.expand('A', {'x': 1}) "    A  . function! A.new(x) dict let obj = self._construct() call obj.set('x', a:x) return obj endfunction "   B    A let B = A.expand('B', {'y': Object}) "    B   function! B.new(x, y) dict let obj = self._construct() " ,      call obj.set('x', a:x) call obj.set('y', a:y) return obj endfunction "   let s:a = A.new(2) let s:b = B.new(3, s:a) echo s:b.get('x') "       Object,       echo s:b.get('y') "         echo s:b.get('y').instancedown('A').get('x')

बात निम्नलिखित विचार से शुरू हुई: आपको सभी वस्तुओं को दो प्रकारों में विभाजित करने की आवश्यकता है, जो कि कक्षाओं का प्रतिनिधित्व करते हैं और उनके उदाहरणों की संरचना और विरासत और निर्माणकर्ता जैसे विशेष तरीकों और वस्तुओं का प्रतिनिधित्व करने वाले लोगों के बारे में जानकारी रखते हैं। मुझे यह विचार पसंद आया और इसे लागू करना शुरू कर दिया, और बेस क्लास ऑब्जेक्ट के साथ शुरू हुआ और दो मुख्य तरीकों का विस्तार और _construct:

 let Object = {'class': 'Object'} function! Object.expand(className, properties) dict endfunction function! Object._construct() dict endfunction

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

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

 function! Object.expand(className, properties) dict let obj = {'class': a:className} "  . "           parent. let obj.parent = self "  . "             . for k in keys(self) let t = type(self[k]) "      if t == 2 let obj[k] = self[k] endif endfor "  . "          . for k in keys(a:properties) "          class  parent,    if k == 'class' || k == 'parent' continue endif let t = type(a:properties[k]) "     ,     if t == 0 || t == 1 || t == 5 let obj[k] = {'value': a:properties[k], 'type': t} "   ,     elseif t == 3 let obj[k] = {'value': deepcopy(a:properties[k]), 'type': t} "   ,        elseif t == 4 "     if has_key(a:properties[k], 'class') let obj[k] = {'value': '', 'type': a:properties[k].class} "     elseif let obj[k] = {'value': a:properties[k], 'type': 4} endif endif endfor return obj endfunction

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

अब बात करते हैं कंस्ट्रक्टर की। _Construct विधि क्लास गुण के मान को ऑब्जेक्ट में कॉपी करके क्लास के आधार पर ऑब्जेक्ट बनाता है और वापस करता है। नकल के तरीकों का कोई मतलब नहीं है, क्योंकि वे सभी वस्तुओं के लिए समान हैं, इसलिए, सुविधा के लिए, हम वस्तुओं से कक्षा के तरीकों के लिए केवल लिंक जोड़ते हैं:

 function! Object._construct() dict let obj = {} "     let obj.class = self if has_key(self, 'parent') "            let obj.parent = self.parent._construct() "       ,       let obj.parent.child = obj endif for property in keys(self) let type = type(self[property]) "          ,     if type == 2 && property != 'expand' && property != '_construct' && property != 'new' let obj[property] = self[property] "    elseif type == 4 && has_key(self[property], 'type') let propertyType = self[property].type if propertyType == 0 || propertyType == 1 || propertyType == 5 let obj[property] = self[property].value elseif propertyType == 3 let obj[property] = deepcopy(self[property].value) elseif propertyType == 4 if has_key(self[property].value, 'class') let obj[property] = self[property].value._construct() else let obj[property] = deepcopy(self[property].value) endif endif endif endfor return obj endfunction

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

का विस्तार

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

नए - मापदंडों के साथ निर्माता;
मिल - संपत्ति मूल्य प्राप्त करना;
सेट - प्रकार की जाँच के साथ संपत्ति का मूल्य निर्धारित करना;
है - क्या वस्तु में विरासत की पदानुक्रम को ध्यान में रखते हुए निर्दिष्ट संपत्ति है;
Instup - वंशानुक्रम पदानुक्रम (प्रतिगमन) तक एक सबोबेज प्राप्त करना;
instancedown - वंशानुक्रम पदानुक्रम (प्रगति) के नीचे एक सबोबेक्ट प्राप्त करना;
Instof - चाहे वह वस्तु निर्दिष्ट वर्ग की हो या उसके उपवर्गों की।

इन विधियों के कार्यान्वयन का वर्णन करने से पहले (मुझे लगता है कि आप खुद को पहले से ही जानते हैं कि उन्हें कैसे लागू किया जा सकता है), मैं दिखाऊंगा कि उनके साथ कैसे काम करना है:

 let A = Object.expand('A', {'a': 1}) let B = Object.expand('B', {'b': A}) ''    function! B.new(b) dict let obj = self._construct() obj.set('b', b) return obj endfunction let s:a = A.new() call s:a.set('a', 2) let s:b = B.new(s:a) ''   ,     echo s:b.class.class '' B ''   ,      b echo s:b.get('b').class.class '' A ''    b   B.  ,    B       A.     call s:b.set('b', s:b) ''   ,     A echo s:b.get('b').class.class '' A ''    s:a,     a   2 (   ),  1 (   s:b) echo s:b.get('b').get('a') '' 1 ''  ,      b ,       B echo s:b.get('b').instancedown('B').class.class '' B

दिलचस्प है, है ना? मैं तरीकों की विस्तृत सूची नहीं दूंगा, वे विस्तृत टिप्पणियों के साथ गिटहब पर हैं, मैं केवल प्रत्येक के ऑपरेशन एल्गोरिदम का वर्णन करूंगा:

नया - एक अतिरिक्त निर्माता क्यों? तथ्य यह है कि जब मानक निर्माता को ओवरराइड करते हैं, तो इस वर्ग के स्तर के गुणों की प्रतिलिपि बनाने का तंत्र तथाकथित वर्ग में काम नहीं करेगा, लेकिन हमें इसकी आवश्यकता नहीं है;
प्राप्त करें - कहीं भी सरल नहीं है यदि संपत्ति दी गई वस्तु में है या विरासत पदानुक्रम में उच्चतर है, हम वापस लौटते हैं, अन्यथा हम एक त्रुटि की रिपोर्ट करते हैं;
सेट - कुछ भी जटिल नहीं है, प्रकार की जांच करें और वर्तमान ऑब्जेक्ट या सबोबिज को लिखें। केवल हमारी कक्षाओं की वस्तुओं की पहचान करना और यदि आवश्यक हो तो प्रतिगमन करना महत्वपूर्ण है;
है - सब कुछ भी काफी सरल है, हम वर्तमान वस्तु और उप-विषय में एक संपत्ति की तलाश कर रहे हैं;
उदाहरण - मूल संपत्ति का उपयोग करते हुए उप-वर्गों के पदानुक्रम को ऊपर जाएं और अनुरोध किए गए वर्ग के नाम की तुलना करें; यदि पाया गया है, तो वस्तु वापस करें;
instancedown - पिछले एक के समान, केवल बाल संपत्ति का उपयोग करें;
Instof - कॉल Instup और यदि ऑब्जेक्ट वापस आ गया है, तो सही लौटें।

उपयोग और नाम स्थान

दुर्भाग्य से, अभी तक एक समझदार नाम स्थान को लागू करना संभव नहीं था। मैंने YUI 3 में नाम स्थान के साथ सादृश्य द्वारा कोशिश की, लेकिन यह बहुत सुंदर नहीं निकला। लागू किया गया काफी सरल:

 comm! -nargs=1 Use so $HOME/.vim/ftplugin/vim/<args>.vim

हम उपयोग कमांड को परिभाषित करते हैं, जिसमें फ़ाइल .vim / ftplugin / vim / file address.vim शामिल है, प्रत्येक वर्ग एक अलग फ़ाइल में स्थित है, जो है:

 Use D/base/Object

यह .vim / ftplugin / vim / D / base निर्देशिका में स्थित Object.vim फ़ाइल है।
उदाहरण का उपयोग करें

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

 if exists('Stack') finish endif Use D/base/Object let Stack = Object.expand('Stack', {'_val': [], '_index': 0}) function! Stack.push(el) dict … endfunction function! Stack.pop() dict … endfunction function! Stack.length() dict … endfunction let s:stack = Stack.new() call s:stack.push(1) call s:stack.push(2) call s:stack.push(3) echo s:stack.length() '' 3 echo s:stack.pop() '' 3 echo s:stack.pop() '' 2 echo s:stack.pop() '' 1 echo s:stack.pop() '' ERROR

मेरी राय में, बहुत सुंदर, और सबसे महत्वपूर्ण रूप से कार्यात्मक। Vim में केवल 4 किलो वजन वाले प्रोटोटाइप के आधार पर पूर्ण विकसित (मुझे आशा है) ऑब्जेक्ट ओरिएंटेशन।

मैंने विम में कक्षाएं कैसे लिखीं