मैश, भाषा की मूल बातें

प्रस्तावना

यह भाषा मेरे द्वारा शैक्षिक उद्देश्यों के लिए विकसित की गई थी। मैं इसे (फिलहाल) पूरी तरह से विकसित भाषा नहीं मानता, लेकिन शायद भविष्य में यह प्रतियोगियों के साथ प्रतिस्पर्धा करने में सक्षम होगा।

यदि आपके पास खुद को एक्शन में आज़माने की इच्छा है - प्रोजेक्ट रिपॉजिटरी डाउनलोड करें , तो आप प्रोजेक्ट के असेंबल्ड वर्जन को पा सकते हैं या अपने ओएस के लिए खुद इसे असेंबल कर सकते हैं।

यह लेख एक छोटे प्रोजेक्ट मैनुअल का वर्णन करेगा और भाषा के वाक्य विन्यास पर विचार करेगा।

चर और प्रभाव सूचक

मैश में, प्रत्येक चर एक पॉइंटर को मेमोरी में किसी ऑब्जेक्ट में संग्रहीत करता है। जब चर को विधियों में स्थानांतरित करते हैं, तो परिणाम प्राप्त करना, या उनके साथ सरल जोड़तोड़ के साथ, उन्हें संकेत द्वारा स्मृति में वस्तुओं के साथ काम किया जाता है।

यानी निम्नलिखित कोड में, एक सरणी को पहले से बनाई गई किसी वस्तु के लिए सूचक के रूप में पी (गिरफ्तार) विधि से पारित किया जाएगा।

proc p(arr): ... end proc main(): arr ?= [1, 2, 3, 4, 5] p(arr) end 

भाषा में संकेतकर्ताओं की उपस्थिति, मेरी राय में स्पष्ट और अंतर्निहित दोनों है, यह अतिरिक्त लचीलापन और कार्यक्षमता देता है, हालांकि कुछ मामलों में यह त्रुटियों की पीढ़ी में योगदान देता है।

अस्थायी चर और कचरा संग्रहकर्ता

इसी तरह की प्रोग्रामिंग भाषाओं के विपरीत, मैश में एक सेमी-ऑटोमैटिक कचरा संग्राहक होता है, जो गिनती के संकेत के बजाय टाइम वैल्यू लेबल के तंत्र पर आधारित होता है।

यानी डेवलपर खुद तय करता है कि कचरा कब साफ करना है और कुछ मामलों के लिए मैन्युअल रूप से भी कर सकता है।

कचरा संग्रह जीसी () का उपयोग करके कहा जाता है और सभी अस्थायी वस्तुओं के तहत मेमोरी को मुक्त करता है।

चर के साथ कई सरल क्रियाएं स्मृति में अस्थायी वस्तुओं के निर्माण के साथ होती हैं।

डेवलपर स्पष्ट रूप से इसके साथ आगे के काम के लिए मेमोरी आवंटन की घोषणा कर सकता है, अर्थात्। दीर्घकालिक उपयोग के लिए चर घोषित करें।

एक अस्थायी चर बनाने के उदाहरण:

 x ?= 10 

और चर कलेक्टर के लिए चिह्नित नहीं हैं:

 x ?= new(10) var x2 = 20 

Gc () का उपयोग करने का एक उदाहरण:

 while a > b: doSomething(a, b) gc() end 

मेमोरी को मैन्युअल रूप से मुक्त किया जा सकता है:

 var a = 10, b = 20, c = 30 ... Free(a, b, c) 

चर दृश्यता क्षेत्र

मैश में चर को स्थानीय और विश्व स्तर पर घोषित किया जा सकता है।

ग्लोबल वेरिएबल्स को वेरिएंट स्टेटमेंट के जरिए तरीकों के बीच घोषित किया जाता है। स्थानीय - किसी भी तरह से अंदर के तरीके।

डेटा प्रकार

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

कोड उदाहरण:

 x ?= 10 x += 3.14 x *= "3" x /= "2,45" x ?= [1, 2, 3.33, func1(1, 2, 3), "String", ["Enum type", 1, 2, 3], "3,14"] 

आत्मनिरीक्षण आपको चर के प्रकार को निर्धारित करने की अनुमति देता है:

 if typeof(x) == TypeInt: ... end 

Arrays और Enums

दुर्लभ कार्य डेवलपर को कोड में अगले सरणी को घोषित करने के लिए मजबूर नहीं करते हैं।
मैश सरणियों का समर्थन करता है जिसमें एक मनमानी संख्या होती है, + सरणियाँ पेड़ों की तरह कुछ हो सकती हैं, अर्थात्। sublevels के आकार एक sublevel पर भिन्न हो सकते हैं।

सरणियों और गणना की घोषणाओं के उदाहरण:

 a ?= new[10][20] var b = new[10][20] c ?= [1, [], 3, 3.14, "Test", [1, 2, 3, 4, 5], 7.7, a, b, ["77", func1()]] var d = [1, 2, 3] 

नए ऑपरेटर के माध्यम से घोषित कोई भी वस्तु कचरा कलेक्टर के लिए चिह्नित नहीं है।

Arrays, स्मृति में नियमित वस्तुओं की तरह, मुफ्त () कॉल करके मुक्त हो जाते हैं

स्थानान्तरण के साथ ऐसा काम काफी सुविधाजनक है।

उदाहरण के लिए, आप विधियों को पास कर सकते हैं या उनमें से एक चर के कई मान लौटा सकते हैं:

 func doSomething(a, b, c): return [a+c, b+c] end 

असाइनमेंट ऑपरेटर्स

मैश में 3 असाइनमेंट ऑपरेटर के रूप में कई हैं।

• ? =
  किसी ऑब्जेक्ट के लिए एक पॉइंटर के लिए एक वैरिएबल असाइन करता है (यदि एक वैरिएबल घोषित किया गया है, लेकिन एक पॉइंटर को मेमोरी में ऑब्जेक्ट में स्टोर नहीं करता है, तो इस ऑपरेटर को इसका मान असाइन करने के लिए उपयोग किया जाना चाहिए)।
• =
  सामान्य असाइनमेंट। एक चर में एक वस्तु को किसी अन्य वस्तु के मूल्य में सूचक द्वारा निर्दिष्ट करता है।
• @ =
  इस ऑब्जेक्ट के लिए एक स्पष्ट पॉइंटर द्वारा किसी ऑब्जेक्ट का मान असाइन किया गया है (यह बाद में चर्चा की जाएगी)।

गणितीय और तार्किक संचालन

वर्तमान में समर्थित गणितीय और तार्किक कार्यों की सूची:

• + , - , * , /
  कोई टिप्पणी की जरूरत है।
• \
  पूरी तरह से विभाजन।
• %
  विभाजन के शेष।
• और
  तार्किक "और।"
• |
  तार्किक "या"।
• ^
  तार्किक "अनन्य या।"
• ~
  तार्किक "नहीं।"
• ++ , -
  वेतन वृद्धि और गिरावट।
• << >>
  बिटवाइज़ बाएँ और दाएँ शिफ़्ट।
• == , <> , > = , <=
  तार्किक तुलना संचालक।
• में
  जाँचता है कि कोई वस्तु किसी संसेचन से संबंधित है या किसी सरणी में।
  एक उदाहरण:

   if Flag in [1, 3, 5, 8]: ... 

स्पष्ट संकेत

ऐसा लगता है, अगर कोई स्पष्ट संकेत नहीं हैं तो उनकी आवश्यकता क्यों है? उदाहरण के लिए, यह जाँचने के लिए कि क्या ए और बी स्टोरेज को एक ही ऑब्जेक्ट में मेमोरी में रखते हैं।

• @ - एक ऑब्जेक्ट को एक पॉइंटर मिलता है और इसे एक ऑब्जेक्ट की तरह वेरिएबल में रखा जाता है।
• ? - चर में ऑब्जेक्ट से पॉइंटर द्वारा ऑब्जेक्ट प्राप्त करें।
  एक उदाहरण:

   a ?= ?b 

कार्यविधियाँ और कार्य

मैंने प्रक्रियाओं और कार्यों में मूल्यों को वापस करने के लिए तरीकों को अलग करने का फैसला किया (जैसा कि पास्कल में है)।

विधि घोषणाएं निम्नलिखित उदाहरणों की तरह की जाती हैं:

 proc SayHello(arg1, arg2, argN): println("Hello, ", arg1, arg2, argN) end func SummIt(a, b): return a + b end 

भाषा निर्माण

एक उदाहरण if..else..end निर्माण।

 if <>: ... else: ... end 

पाश के लिए।

 for([]; <>; [  ]): ... end 

है। पुनरावृत्ति से पहले स्थिति की जांच की जाती है।

 whilst <>: ... end 

जबकि। एक लूप जो उस समय से भिन्न होता है जब पुनरावृत्ति के बाद स्थिति की जांच की जाती है।

 until <>: ... end 

switch..case..end..else..end ... तार्किक शाखाएँ बनाने के लिए एक परिचित निर्माण है।

 switch <>: case < 1>: ... end case < 2>: ... end else: ... end 

ओओपी भाषा के वर्ग और तत्व

मैश कक्षाओं, विरासत, गतिशील आत्मनिरीक्षण और प्रतिबिंब, बहुरूपता के लिए समर्थन का समर्थन करता है। यानी स्क्रिप्टिंग भाषाओं का एक मानक सेट समर्थित है।

एक साधारण वर्ग घोषणा पर विचार करें:

 class MyClass: var a, b proc Create, Free func SomeFunction end 

एक वर्ग घोषणा में उन विधियों का कार्यान्वयन शामिल नहीं है जो इसमें घोषित की गई हैं।
वर्ग का निर्माता बनाएँ विधि है। एक विध्वंसक के रूप में - नि: शुल्क।

कक्षा घोषित होने के बाद, आप इसके तरीकों के कार्यान्वयन का वर्णन कर सकते हैं:

 proc MyClass::Create(a, b): $a ?= new(a) $b ?= new(b) end proc MyClass::Free(): Free($a, $b, $) end func MyClass::SomeFunction(x): return ($a + $b) / x end 

आप कोड में कुछ स्थानों में $ प्रतीक को देख सकते हैं - इस प्रतीक के साथ मैंने बस लंबे समय तक इसे छोटा कर दिया->। यानी कोड:

 return ($a + $b) / x ... Free($a, $b, $) 

इस कोड के बराबर:

 return (this->a + this->b) / x ... Free(this->a, this->b, this) 

इसमें कक्षा के एक उदाहरण के लिए एक संकेतक होता है, जिसकी ओर से इस वर्ग की विधि को कहा जाता है।

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

 class MySecondClass(MyClass): func SomeFunction end func MySecondClass::SomeFunction(x): return ($a - $b) / x end 

MySecondClass - के पूर्वज + SomeFunction फ़ंक्शन से एक कंस्ट्रक्टर और विध्वंसक होगा, जो कि पूर्वज वर्ग के पास है, एक नए वर्ग से एक फ़ंक्शन द्वारा अधिलेखित है।

क्लास इंस्टेंसेस बनाने के लिए, नया ऑपरेटर मौजूद है।

कोड उदाहरण:

 a ?= new MyClass //     

 b ?= new MyClass(10, 20) //         

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

आत्मनिरीक्षण आपको वर्ग उदाहरण, कोड उदाहरण के प्रकार को निर्धारित करने की अनुमति देता है:

 x ?= new MyClass(10, 20) ... if x->type == MyClass: // -... end 

कभी-कभी आपको एक क्लास फ़ंक्शन को चालू करने और इसे एक नए के साथ अधिलेखित करने की आवश्यकता होती है। कोड उदाहरण:

 func class::NewSomeFunction(x): return $x * $y * x end ... x ?= new MyClass(10, 20) x->SomeFunction ?= class::NewSomeFunction x->SomeFunction(33) // NewSomeFunction,     . 

निष्कर्ष

इस लेख में, मैंने अपनी रचना के लिए संभावित इच्छुक लोगों से परिचय कराने की कोशिश की।

पढ़ने के लिए धन्यवाद। टिप्पणियों की प्रतीक्षा है।