Perl6 - चर, बेनामी ब्लाकों पर संचालन

1. Perl6 में चर और शाब्दिक के साथ काम करने की विशेषताएं
पिछले लेख में, मैंने चर के साथ काम करने की विशेषताओं का वर्णन किया, और संदर्भों पर भी छुआ। इस लेख में, मैं चर के उपयोग पर अपने प्रयोगों और खोजों के परिणामों को साझा करना चाहता हूं, और गुमनाम रूप से ब्लॉक की विशेषताओं का भी संक्षेप में वर्णन करता हूं।
चलिए शुरू करते हैं


Perl6 में, घोषित करते समय एक चर के प्रकार को निर्दिष्ट करना संभव है।
उदाहरण के लिए:

my Int $var; 

इस घोषणा के साथ, केवल एक संख्या को $ var चर को सौंपा जा सकता है। यदि आप एक स्ट्रिंग या किसी अन्य प्रकार को एक चर में असाइन करने का प्रयास करते हैं, तो कोई भी स्वचालित प्रकार रूपांतरण नहीं किया जाएगा - स्क्रिप्ट को प्रकार की जाँच के बारे में एक त्रुटि के साथ रोका जाएगा। प्रकार किसी भी मौजूदा डेटा प्रकार, यहां तक ​​कि उपयोगकर्ता वर्ग भी हो सकते हैं।
आप बिना किसी विशेष प्रतिबंध के निर्दिष्ट प्रकार से दूसरों में परिवर्तित कर सकते हैं।
वैरिएबल की ऐसी घोषणा के साथ, इसका प्रारंभिक मान Int () होगा, और इस मान का उपयोग नहीं किया जा सकता है - ऐसा इसलिए होता है क्योंकि निर्माता स्वचालित रूप से कॉल नहीं करता है, और चर निर्दिष्ट प्रकार का अपरिभाषित मान प्राप्त करता है। चर घोषित करते समय किसी वस्तु का नया उदाहरण बनाने के लिए, आप निर्माण का उपयोग कर सकते हैं

 my SomeClass $x .= new(a,r,g,s); my $x = SomeClass.new(a,r,g,s); 

आप यह पता लगा सकते हैं कि किसी चर का परिभाषित विधि के उपयोग से कोई मूल्य है या नहीं:

 my Int $x; say $x.defined; #False 

प्रकार को निर्दिष्ट करने का दूसरा तरीका निर्माण करना है

 my $x is Int; 

हालांकि, आखिरी में, इस समय (12.09), रकुडो-स्टार का संस्करण, यह विधि अभी तक काम नहीं करती है।
प्रकार निर्दिष्ट करने की निम्न विधि भी संभव है:

 my Array of Array of Int @x; 

हालाँकि, (12.09) में यह भी काम नहीं करता है, इसलिए मैं इस पद्धति की विशेषताओं के बारे में कुछ नहीं कह सकता।

चलिए मुख्य ऑपरेशन की ओर बढ़ते हैं - स्वाभाविक रूप से यह सूची पूरी नहीं है, लेकिन मैं उन मुख्य ऑपरेशनों की सूची दूंगा जिनका हम उपयोग करेंगे:

• संख्याओं के साथ संचालन:
  
  • विशिष्ट बाइनरी और एकरी संचालन
    ये ऑपरेशन +, -, *, / हैं
    उपरोक्त के अलावा, आप डिवीजन के शेष (%, mod), पावर (**) को बढ़ाने, वेतन वृद्धि और गिरावट (++, -) के विभाजन के पूर्णांक भाग (div) को लेने के लिए उपयोग कर सकते हैं।
    
  • बिटवाइज़ ऑपरेशन: बिटवाइज़ "और" (+ &), बिटवाइज़ "या" (+)।, बिटवाइज़ शिफ्ट (+ <, +>), बिटवाइज़ "XOR" (+ ^)
    
  • तुलना संचालन: ==; =; <,>,> =, <=।
    
  
  
• स्ट्रिंग ऑपरेशन:
  दो पंक्तियों का संबंध
  

   ('a'~'b') 

  
  बार-बार एक पंक्ति को दोहराते हुए

   ('a' x 10) 

  
  स्ट्रिंग्स की तुलना: स्ट्रिंग्स बराबर (eq), असमान (ne), वर्णानुक्रम में, लाइन 1 पंक्ति 2 (lt, इससे पहले), बाद में (gt, बाद), पहले या मैच (le), बाद या मैच (gt) से पहले आती है
  
• बूलियन प्रकार के संचालन:
  और (?), या (?;), XOR (? ^), नहीं (!)
  
• -यूजिंग जंक्शन ()
  समूह तुलना के लिए जंक्शन एक विशेष प्रकार है - यदि आप लिखते हैं
  

   $a == any(1, 2, 3) 

  
  तब शर्त संतुष्ट हो जाएगी यदि चर $ a सूचीबद्ध मूल्यों में से कम से कम एक के बराबर है।
  संभव संचालक
  
  • कोई भी ( $a==1 or $a==2 or $a==3 )
  • सभी ( $a==1 and $a==2 and $a==3 )
  • एक ($ एक निर्दिष्ट मूल्यों में से केवल एक के बराबर है),
  • कोई नहीं ($ a! = 1 और $ a! = 2 और $ a! = 3)
  
  -अधिकतम (अधिकतम) या न्यूनतम (न्यूनतम) संख्या का निर्धारण
  

   $a = 10 min 4; $b = 20 max 99; 

  
  संचालन के रूप में स्ट्रिंग्स का उपयोग करते समय, तुलना वर्णमाला क्रम में होती है।
  
  -ट्रेनरी ऑपरेटर
  

   $ifValue ?? "yes" !! "no" 

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

   @a = (1, 2, 3); @b = @a X* 2; #     2,     @c = @a X** 2; #            

  
  
  -सभी आइटम का चयन करें
  सरणी के सभी तत्वों के लिए ऑपरेशन करने के लिए, >> ऑपरेटर >> निर्माण का उपयोग किया जाता है
  

   @a = 1, 2, 3; @b = @a>>**>>2, 100, 500; 

  
  इस अभिव्यक्ति में, @a सरणी के सभी तत्वों को चुकता किया गया है, एक नई सरणी बनाते हुए, परिणामी सरणी में दो नंबर जोड़े जाते हैं: 100 और 500
  परिणामस्वरूप, @ बी सरणी में (1, 4, 9, 100, 500)
  
  -जिप ऑपरेटर
  दो सरणियों से तत्वों के जोड़ीदार चयन के लिए उपयोग किया जाता है:
  

   @a = (1, 2, 3); @b = (4, 5, 6); @c = @a Z @b; #(1, 4, 2, 5, 3, 6) 

  
  
  ऑपरेटर रिकॉर्ड का संक्षिप्त रूप
  सभी संख्याओं को जोड़ने के लिए, आप प्रविष्टि का उपयोग कर सकते हैं [+]
  

   @a = 1, 2, 3; $a = [+] @a; 

  
  परिणाम $ a = 1 + 2 + 3 है;
  
  एक उपनाम बनाएँ
  एक चर के लिए, आप एक उपनाम बना सकते हैं जिसे चर का दूसरा नाम माना जाएगा। चर स्मृति में एक ही क्षेत्र को इंगित करते हैं, इसलिए एक चर नाम के माध्यम से परिवर्तन दूसरे चर नाम के माध्यम से भी दिखाई देगा। एक उपनाम बनाना ': =' के रूप में इंगित किया गया है
  

   $a = 1; $b := $a; 

  
  
  एक अपरिवर्तनीय चर बनाना
  एक अपरिवर्तनीय चर बनाने के लिए, उदाहरण के लिए ऑपरेटर ':: =' का उपयोग करें
  

   my $a ::= "aaa"; 

  
  हालांकि, वर्तमान संस्करण (12.09) में इस तरह की घोषणा संकलन त्रुटि देती है
  
  एक चर संदर्भ प्राप्त करना
  आप '\' का उपयोग करके किसी चर का लिंक प्राप्त कर सकते हैं:
  

   $a = 10; $b = \$a; 

  
  
  

अब ब्लॉक के बारे में:
पर्ल 6 में ब्लॉक डेटा के रूप में इस्तेमाल किया जा सकता है: व्यक्तिगत ब्लॉक स्केलर चर को सौंपा जा सकता है और फिर निष्पादित किया जा सकता है:

 $b = 10; $a = { $b = 1; }; $a(); say $b; # $b=1; 

जब किसी ब्लॉक को निष्पादन के लिए बुलाया जाता है, तो कॉल का परिणाम इस ब्लॉक में अंतिम गणना मूल्य होता है। इस उदाहरण में, परिकलित मान स्थिर है। 1. ब्लॉक के अंदर, ब्लॉक के संचालन को समाप्त करने के लिए रिटर्न स्टेटमेंट का उपयोग नहीं किया जा सकता है: यह उस फ़ंक्शन के निष्पादन को पूरा करेगा जिसमें ब्लॉक कहा जाता है।
फ़ंक्शन कॉल में तर्क के रूप में ब्लॉक का उपयोग किया जा सकता है:

 func($arg1, $arg2, { say 'this is a block'; }); 

वेरिएबल्स को ब्लॉक के अंदर घोषित किया जा सकता है, या मौजूदा वाले को फिर से परिभाषित किया जा सकता है: एक ब्लॉक वेरिएबल्स के अपने दायरे को निर्धारित करता है, और एक ब्लॉक के अंदर घोषित चर में परिवर्तन इस ब्लॉक के बाहर एक ही नाम के चर को प्रभावित नहीं करते हैं।
निम्नलिखित कोड में

 my $a = '  '; my $closure = { say $a; }; { my $a = '  '; $closure(); } 

लाइन 'वैरिएबल का प्रारंभिक मान' प्रदर्शित किया जाएगा, क्योंकि $ क्लोजर वैरिएबल बनाते समय, वैश्विक स्कोप में घोषित एक वैरिएबल का उपयोग किया गया था, और ब्लॉक के अंदर समान नाम $ के साथ एक वैरिएबल को परिभाषित करने के बाद भी, पहले वाले का उपयोग किया जाएगा।
निम्नलिखित कोड में, ब्लॉक के लिए $ एक स्थानीय चर का उपयोग किया जाएगा, भले ही यह उस स्थान से सुलभ नहीं हो जहां यह दिखाई देता है।

 my $a = '  '; my $closure; { my $a = '  '; $closure = { say $a; }; } $closure();