Perl6 - कार्यों के साथ काम करें

1. Perl6 में चर और शाब्दिक के साथ काम करने की विशेषताएं
2. पर्ल 6 - चर, अनाम ब्लॉकों पर संचालन
3. पर्ल 6 - सशर्त कथन, लूप

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



Perl6 निर्माण के रूप में कार्यों की घोषणा करता है

sub SubName($a, $r, $g, $s) { //SomeWork } 

प्राप्त मापदंडों के प्रकारों को निर्दिष्ट करना संभव है

 sub SubName(Int $a) { SomeWork(); } 

हालाँकि, यदि फ़ंक्शन को भिन्न प्रकार के तर्क के साथ कहा जाता है, तो स्क्रिप्ट को एक त्रुटि के साथ बंद कर दिया जाएगा। साथ ही, किसी फ़ंक्शन की घोषणा करते समय पारित किए गए तर्कों की संख्या को तर्कों की संख्या से मेल खाना चाहिए।

एक फ़ंक्शन कॉल कंस्ट्रक्शन का उपयोग करके किया जाता है।

 f(10, True, "str", {say "closure";}); f 20, False, "aaa", 9.999; 

C ++ में, हम ओवरलोडिंग का कार्य कर सकते हैं, हालांकि, प्रत्येक फ़ंक्शन के लिए 'मल्टी' शब्द जोड़ना आवश्यक होगा:

 multi sub f(Int $a) {say 'Int';}; multi sub f(Str $a) {say 'Str';}; f("string"); f(100500); 

परिणामस्वरूप, इसे स्क्रीन पर प्रदर्शित किया जाएगा:

 Str Int 

कार्यों के दायरे को इंगित करने के लिए, मेरे और हमारे शब्दों का उपयोग किया जाता है - क्रमशः, उस क्षेत्र में दृश्यता जहां फ़ंक्शन घोषित किया गया था और वैश्विक गुंजाइश।
आप फ़ंक्शन द्वारा लौटाए गए मान का प्रकार निर्दिष्ट कर सकते हैं:

 my Int sub func($a) {return $a+1;} 

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

 sub f($a is rw) { $a*=10; } my $z = 5; f($z); say $z; 

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

 my $b = 10; sub f() is rw { return $b; } f() = 5; say $b; 

नतीजतन, नंबर 5 को स्क्रीन पर प्रदर्शित किया जाना चाहिए, हालांकि, नवीनतम संस्करण (12.09) में लैवल्यू मूल्यों का उपयोग करने की संभावना अभी तक तैयार नहीं है, और मेरे मामले में, संकलन करते समय एक त्रुटि हुई।
Perl6 नामित मापदंडों का उपयोग करने की क्षमता का परिचय देता है:

 my sub func(:$name1, :$name2, :$name3) { say $name1, ' ', $name2, ' ', $name3; } my $a = 10; func :name2<text2>, :name1<1+2+$a>, name3=>$a; my %hash = {name3=>'text3', name2=>'text2', name1=>'text1'}; func |%hash; 

परिणामस्वरूप, स्क्रीन प्रदर्शित होगी:

 1+2+$a text2 10 text1 text2 text3 

यदि आप पैरामीटर के रूप में% हैश नहीं करते हैं, लेकिन बस% हैश है, तो फ़ंक्शन इसे एक स्थिति तर्क के रूप में लेगा - हमारे मामले में, फ़ंक्शन में स्थितीय तत्व नहीं हैं, इसलिए स्क्रिप्ट विफल हो जाएगी।
नामित तर्क को निर्दिष्ट करने के लिए आप निर्माण का उपयोग भी कर सकते हैं: arg ($ मूल्य)। इस विकल्प और: arg <$ value> के बीच का अंतर यह है कि दूसरे मामले में वैरिएबल का मान प्रतिस्थापित नहीं किया जाएगा, और परिणामस्वरूप, पहले मामले में हमें वैरिएबल $ वैल्यू मिलता है, और दूसरे मामले में हमें स्ट्रिंग '$ वैल्यू' मिलता है।
इसके अलावा, आप वैकल्पिक मापदंडों का उपयोग कर सकते हैं:

 sub HaveArgument($arg?) { if $arg.defined { say 'yes'; } else { say 'no'; } } HaveArgument; HaveArgument 10; 

नतीजतन, हमें लाइनें मिलती हैं

 no yes 

Perl5 की तरह, तर्कों की एक चर संख्या के साथ कार्य बनाने के लिए, आप निर्माण का उपयोग कर सकते हैं:

 sub Counter(*@arg) { say @arg.elems; } Counter(1, 2, 3); Counter; 

नतीजतन, दो नंबर प्रदर्शित किए जाएंगे: 3 और 0
* @ Args से पहले आप स्थितीय तत्वों को निर्दिष्ट कर सकते हैं:

 sub Counter($a, *@arg) {...} 

मुख्य समारोह:
Perl6 ने CIN ++ के समान MAIN फ़ंक्शन बनाने की क्षमता पेश की, हालांकि, कई अंतर हैं। उदाहरण के लिए, किसी फ़ंक्शन के शरीर के बाहर, आप अन्य फ़ंक्शन के लिए कॉल कर सकते हैं, और ये कॉल MAIN फ़ंक्शन द्वारा निष्पादित होने से पहले किए जाएंगे:

 sub MAIN() { say "MAIN!"; say "Hello!"; } say "123!"; 

नतीजतन, हम स्क्रीन पर लाइनों को देखेंगे

 123! MAIN! Hello! 

इसके अलावा, MAIN फ़ंक्शन के लिए, आप इनपुट पैरामीटर निर्दिष्ट कर सकते हैं, जो निष्पादन के लिए स्क्रिप्ट को कॉल करते समय अनिवार्य पैरामीटर होंगे:
यदि स्क्रिप्ट की सामग्री:

 sub MAIN($arg1, $arg2) { say "MAIN!"; say $arg1, ' ', $arg2; } say "123!"; 

और स्क्रिप्ट को मापदंडों के बिना कॉल करें, फिर परिणामस्वरूप हमें स्क्रीन पर पाठ मिलता है:

 123! Usage: /home/warfair/ /script.p6 <arg1> <arg2> 

ध्यान दें कि "123!" फ़ंक्शन को कहा गया था, जो एक फ़ंक्शन के शरीर के बाहर है, और उसके बाद ही MAIN कॉल विफल हो गया।
फ़ंक्शन संदर्भ को निर्माण का उपयोग करके एक चर में सहेजा जा सकता है

 sub MySub() {...}; my $var = &MySub; 

आप अनाम फ़ंक्शंस बना सकते हैं और उन्हें स्केलर चर में संदर्भ स्टोर कर सकते हैं।

 my $r = sub ($a) { return $a*2; } say $r(2); 

नतीजतन, हम 4 देखेंगे