इसे करने के लिए एक से अधिक तरीके हैं

#!/usr/bin/perl -c Please, listen to, my $words; seek love, joy, happiness for everything; study hard and sleep longer if able; # Perl Poetry, The Sentiment # (c) http://www.perlmonks.org/?node_id=882536 

रेगिस्तान ...

गर्व और राजसी Perl रेगिस्तान द्वारा खड़ा है। उन्होंने 1987 में अपनी यात्रा शुरू की, कई गर्मियों में हजारों रेगिस्तानों को दरकिनार करते हुए, उन्होंने यहां देखा और वहां अद्भुत, नखलिस्तान पानी से भरा हुआ, जैसे कि बारिश का मौसम शुरू हुआ, लंबे समय तक सूखे के साथ बारी-बारी से। रेगिस्तान अलग-अलग हैं, एक से अधिक बार दुर्भाग्य उसके साथ हुआ, जब एक आसन्न सवार ने उसे गहरे और गहरे शुष्क रेगिस्तान में ले गया जहां कोई उम्मीद भी नहीं थी। इसके विपरीत, ऐसे मामले थे जब रेगिस्तान के बीच में पूरे शहर जीवन और लोगों से भरे हुए दिखाई देते थे, यह मृगतृष्णा की तरह प्रतीत होता था, लेकिन नहीं - यह एक वास्तविकता थी। पर्ल लोगों की रचनात्मक प्रतिभा को देखकर कभी आश्चर्यचकित नहीं हुआ। उसने अपनी इच्छा पर भरोसा करते हुए मनुष्य पर कोई रास्ता नहीं निकाला, वह रेगिस्तान की गहराई में अज्ञात में चला गया। वह ¹ "जंगली" सवारों से निराश था - बड़े शहरों के लोग जटिल कारों में यात्रा करते थे। यहाँ, रेगिस्तान में, यहां तक ​​कि सबसे आकर्षक रीढ़ भी उन्हें कम से कम एक मीटर आगे नहीं बढ़ा सकती है। आदत से बाहर, वे उनके साथ बहुत सारे कूड़ेदान लेते हैं, और उन्हें लगातार धक्का देते हैं, जिससे वे तेजी से और तेजी से चलते हैं। रेगिस्तान की सुंदरता, इसके दर्शन, उन्हें अतीत में ले जाते हैं, लेकिन उनमें से कई पूरे बेजान रेगिस्तान को पीछे छोड़ते हुए, लक्ष्य तक नहीं पहुंचते हैं। इसके विपरीत, ऐसे अन्य लोग थे जो रेगिस्तान को रचनात्मकता के लिए कुछ नया, मुफ्त, असीमित स्थान मानते थे। ऐसे साथियों के साथ यात्रा करना हमेशा एक बहुत खुशी की बात रही है। निशान ने उन्हें रेगिस्तान के जीवन द्वीपों से भरे विचित्र के माध्यम से आगे बढ़ाया। कभी-कभी ऐसे लोगों का एक समूह ऊंटों के पूरे कारवां को इकट्ठा कर सकता था, जो धीरे-धीरे रेगिस्तान से भटक रहा था। रेगिस्तान नशे में था, और किसी तरह एक विशेष तरीके से, जादुई रूप से सवारों के मजबूत युवा दिमाग पर काम नहीं किया। पर्ल ने अक्सर देखा कि रेत के महल बनाने के लिए गरीबों को पागल होना शुरू हो गया था जो कि कुछ और बनने के लिए किस्मत में नहीं थे। दूसरों ने रेत में उसे भी साफ नहीं किया था। वे मृगतृष्णा से भी बर्बाद हो गए थे जो वास्तव में कभी अस्तित्व में नहीं थे। दुर्भाग्य से, पर्ल इन गरीब साथियों की मदद नहीं कर सकता था, न ही वह यात्रा करने से इनकार कर सकता था, क्योंकि पर्ल को यात्रा के दौरान बहुत अच्छा लगा, इसके लिए वह पैदा हुआ था।

और यहाँ वह आपके सामने है, ख़ुशी से उसे लात मारते हुए इस बेजान रेगिस्तान के माध्यम से एक आकर्षक सैर करने की पेशकश करते हुए, उस दूरी में जहाँ आपको लगता है कि आपको जाना चाहिए।

... ऊँट ^२

(*) पर्ल का दर्शन यह है कि कठिन समस्याओं को हल करने की क्षमता बनाए रखते हुए सरल समस्याओं को हल करना आसान होगा। ये ऐसे कार्य हैं जिन्हें हम दिन-प्रतिदिन हल करते हैं। आप क्या करने जा रहे हैं, यह कहने से पहले बहुत सारे प्रारंभिक शब्दों को कहने की आवश्यकता नहीं है। पर्ल को पारंपरिक रूप से लगभग सभी * निक्स वितरण के वितरण में शामिल किया गया है, जो विशेष रूप से शुरू करना आसान बनाता है। वास्तव में, ऑपरेटिंग सिस्टम स्थापित करने के बाद, पर्ल काम करने के लिए तैयार है (निश्चित रूप से हम * निक्स के बारे में बात कर रहे हैं)।

(*) पर्ल के प्रत्येक नए संस्करण को विकसित करते समय, पिछड़े संगतता को बनाए रखने के लिए विशेष ध्यान दिया जाता है। जो बहुत महत्वपूर्ण है, यह देखते हुए कि पर्ल में कितना लिखा गया है।

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

(*) पर्ल ने व्याख्या करने से पहले एक मध्यवर्ती प्रतिनिधित्व में पाठ कार्यक्रमों को संकलित किया। यह अनुमति देता है, यद्यपि अक्सर नहीं, संकलन चरण में कार्यक्रम में त्रुटियों का पता लगाने के लिए। सबसे पहले, इसमें वाक्य रचना के निर्माण की शुद्धता की जांच करना, उपप्रोग्राम के नामों और तर्कों की शुद्धता की जांच करना (केवल अगर कोई प्रोटोटाइप है), तो कक्षा के क्षेत्रों में कॉल की शुद्धता की जांच करना। बेशक यह सी ++ संकलक नहीं है, लेकिन एक गतिशील भाषा के लिए यह बिल्कुल भी बुरा नहीं है। यह दिलचस्प है, लेकिन यहां तक ​​कि सी ++ कंपाइलर कुछ पीछे छोड़ सकता है, इसलिए पर्ल कंपाइलर गणितीय कार्यों के लिए गलत कॉल का पता लगा सकता है (उदाहरण के लिए: एक नकारात्मक संख्या से एक रूट एक संकलन त्रुटि का कारण बनता है)। यहाँ कुछ उदाहरण हैं:

 #!/usr/bin/perl -w use strict; my Dog $aDog = new Dog; # :   Dog $aDog->{wings} = '?'; #  (. ):     feed $aDog; # :     sqrt -2; # :     

पर्ल हमेशा अपने सिद्धांत का पालन करता है , और इसमें से अधिकांश चेक को बंद करने के लिए कुछ भी नहीं खर्च होता है, लेकिन बाद में उस पर अधिक।

(*) फंक्शन प्रोटोटाइप आपको उपप्रोग्राम और उनके तर्कों की एक सूची घोषित करने की अनुमति देता है, सी ++ में फॉरवर्ड डिक्लेरेशन के समान कुछ है, यदि कोई प्रोटोटाइप है, तो कंपाइलर सबप्रोग्राम को कॉल करने की शुद्धता की जांच करता है, और इसके अलावा, उपप्रोग्राम को कॉल करते समय जोड़ी कोष्ठक की आवश्यकता नहीं होती है।

 sub feed($$); feed 'Sharik', 'Fruit'; # Ok feed 'Sharik'; # :    feed 'Sharik', 'Apple', 'Fruit'; #:   sub feed($$) { print shift, ' eat ', shift, "\n"; } 

(*) $ @% । पर्ल अपने उद्देश्य के अनुसार चर को अलग करता है: ' $ ' स्केलर (संख्या, रेखा, लिंक), ' @ ' सरणी (स्केलर्स का अनुक्रम), ' % ' हैश (स्केलर्स का सहयोगी सरणी)। जैसा कि आप देख सकते हैं, क्लासिक आदिम प्रकार एक स्केलर द्वारा दर्शाए गए हैं। हालांकि, वे कड़ाई से कंटेनरों से अलग हो जाते हैं, जो कंपाइलर को अतिरिक्त जांच करने की अनुमति देता है, जिससे हम परेशानी से बच जाते हैं। पर्ल अपने प्रकारों को दर्ज करने की अनुमति नहीं देता है (ओओपी के लिए, रियायतें पेश की गई हैं - किसी भी निर्मित प्रकार को वर्ग में आशीर्वाद दिया जा सकता है)। इस तरह के स्पष्ट अलगाव के कारण, एक ही क्षेत्र में आपके पास सभी प्रकार के गैर-परस्पर विरोधी चर हो सकते हैं:

 #!/usr/bin/perl -w use strict; my $solarSystem = 'Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune'; my @solarSystem = qw(Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune); my %solarSystem = (haveLife => 1, havePerl => 1); sub solarSystem() { print 'Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune'; } 

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

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

 #!/usr/bin/perl -w use strict; sub upper { my $value = $_[0]; #    $value $value = uc $value; #    $_[0] = $value; #      } my $bigLetters = 'big-letters'; upper $bigLetters; print $bigLetters, "\n"; #  BIG-LETTERS 

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

 #  BigMath.pm package BigMath; use overload; use Math::BigInt; sub import { overload::constant integer => sub { Math::BigInt->new(shift) }; } 1; #  BigMath.pl { use BigMath; my $bigInt = 2123; #  BigInt print $bigInt->as_bin(); # 0b100001001011 } { my $int = 2123; print $int->as_bin(); #   as_bin() } 

पर्ल आपको मानक भाषा रूटीन अधिभार देता है।

(*) नियमित अभिव्यक्ति पर्ल में गहराई से एकीकृत हैं । सामान्य नियमित अभिव्यक्ति पैटर्न के अलावा, पर्ल अपने एक्सटेंशन का समर्थन करता है। उदाहरण के लिए, पर्ल आपको खोज पैटर्न और प्रतिस्थापन पैटर्न में सीधे पर्ल कोड का उपयोग करने की अनुमति देता है:

 my $math = '100 + 200 = 300'; $math =~ s/(\d+)/$1 * 2/ge; #       2 print $math, "\n"; # 200 + 400 = 600 

नियमित अभिव्यक्ति यूनिकोड गुणों का समर्थन करती हैं और यहां तक ​​कि उन्हें अपने स्वयं के चरित्र गुणों में प्रवेश करने की अनुमति है। आप जटिल पैटर्न (जैसे \ s, \ w, आदि) के लिए अपने स्वयं के संक्षिप्तीकरण दर्ज कर सकते हैं। स्वाभाविक रूप से, पर्ल में नियमित अभिव्यक्ति लालची और गैर-लालची दोनों खोजों का समर्थन करती है।

(*) पर्ल, सबरूटीन में रिटर्न कीवर्ड की अनुपस्थिति में, अंतिम मूल्यांकित अभिव्यक्ति देता है (यह अब फैशनेबल लगता है)। इसके अलावा, जब सबरूटीन्स बुलाते हैं, तो आप कोष्ठकों को छोड़ सकते हैं यदि आप समझते हैं कि आप क्या कर रहे हैं।

(*) ब्लॉक पर्ल में। एक ब्लॉक घुंघराले ब्रेसिज़ {...} की एक जोड़ी है, एक ब्लॉक को स्वीकार करने के लिए , जबकि , जैसे निर्माण करता है, हालांकि एक ब्लॉक स्वयं द्वारा मौजूद हो सकता है। सबसे दिलचस्प बात यह है कि कोई भी ब्लॉक अगले , अंतिम और रीडो ऑपरेटरों का समर्थन करता है। यानी प्रविष्टि काफी कानूनी है:

 { print "Yeah\n"; last; print "Unreachable code\n"; } { print "Forever loop\n"; redo; } 

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

 use strict; #sub transaction(&$); #sub update($$$); #sub set(+); #sub where(+); #sub rollback(&); #sub throw($$); transaction { update 'user', set { name => 'caiiiycuk' }, where { id => '1' }; } rollback { throw 500, "rollback exception"; } 

पर्ल कोशिश / पकड़ने / अंत में ब्लॉक का समर्थन नहीं करता है; हालांकि, इसे आसानी से ब्लॉक रूटीन प्राप्त करने के माध्यम से लागू किया जाता है। सटीक रूप से क्योंकि यदि / अन्यथा किसी ब्लॉक को स्वीकार करता है, तो / / और अगर / तो पर्ल में मौजूद नहीं हो सकता है, का सिंटैक्स यदि / elsif / अन्यथा के बजाय प्रयोग किया जाता है। इसी तरह, कोई स्विच / मामला नहीं है , इसे तुच्छ रूप से लागू किया जाता है।

(*) जबकि लूप जारी खंड को परिभाषित कर सकता है, जिसे अगले , अंतिम या फिर से कहा जाता है, भले ही निष्पादित किया गया हो (यानी, यह हमेशा निष्पादित होता है) (जैसा कि एलिनेटर ने ठीक कहा है , रीडो कॉल जारी अनुभाग को छोड़ देता है)।

 while (1) { next; } continue { print "Yet another loop done \n"; } 

(*) चर के लिए तीन स्कोप: वैश्विक, शाब्दिक और स्थानीय। स्थानीय स्कोप वैरिएबल के मान को वर्तमान ब्लॉक तक और इस ब्लॉक के सभी सबरूटीन कॉल्स तक बढ़ाता है, जो एक विशिष्ट ब्लॉक में वैश्विक वेरिएबल्स के मूल्यों को ओवरराइड करने के लिए उपयोगी है। स्थानीय स्कोप को रन टाइम पर और लेक्ज़िकल को कंप्लीशन स्टेज पर निर्धारित किया जाता है (यह ब्लॉक के भीतर सबसे आम स्कोप है)।

 use strict; our $a = 'global scope'; #   sub printLocal { local $a = 'local scope'; #   (    ) printGlobal(); } sub printGlobal { print $a, "\n"; } printGlobal(); # 'global scope' printLocal(); # 'local scope' printGlobal(); # 'global scope' 

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

(*) पहले से ही 2002 के बाद से, पर्ल ने निरंतर सबप्रोग्राम की गणना करने के लिए तंत्र का समर्थन किया है, और गणना स्थिरांक ( कॉन्स्ट्रेप ) के मूल्यों के साथ कॉल के अपने स्थानों को प्रतिस्थापित किया है।

(*) सुविधाजनक फ़ाइल सत्यापन ऑपरेटर (- rwxoRWXOezsfdlpSbctugkTBMAC )।

 use strict; if (-e '/tmp' and -d '/tmp') { print '/tmp is directory', "\n"; } 

(*) ऑपरेटर <> । यह कई कार्य करता है। सबसे पहले, इसका उपयोग वर्तमान निर्देशिका में टेम्पलेट द्वारा फ़ाइलों की खोज के लिए किया जा सकता है (वैसे, खोज विधि को बदला जा सकता है, ग्लोब डिफ़ॉल्ट रूप से उपयोग किया जाता है)।

 print join ',', <*.pl>, "\n"; #   *.pl 

दूसरे, यह फ़ाइल डिस्क्रिप्टर से डेटा पढ़ने के लिए एक ऑपरेटर है। इसके अलावा, एक स्केलर संदर्भ में, यह लाइन द्वारा डेटा लाइन पढ़ता है, और एक सूची संदर्भ में, यह फ़ाइल की पंक्तियों को एक सरणी में पूरी तरह से पढ़ता है।

 open F, '<somefile' or die; my @random = <F>; #      close F; 

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

 print while (<>); 

(*) उपयोगी डिफ़ॉल्ट चर $ _ । अधिकांश मानक पर्ल रूटीन और ऑपरेटर इसके साथ काम कर सकते हैं, इसके उपयोग का सुझाव दें यदि फ़ंक्शन का इनपुट तर्क छोड़ दिया गया है। कभी-कभी यह आपको अधिक संक्षिप्त कोड लिखने की अनुमति देता है।

 use strict; while (<>) { print if (s/^print\s*(.*)/$1/); } #  while ($_ = <>) { print $_ if ($_ =~ s/^print\s*(.*)/$1/); } 

(*) पर्ल में, एक असाइनमेंट परिणाम एक अंतराल है । इसलिए, पर्ल में असाइनमेंट के दौरान मूल्य को बदलना संभव है।

 ($new = $old) =~ s/bad/good/g; ## chomp($answer = <STDIN>); ## if ( ($k, $v) = $string =~ m/(\w+)=(\w+)/ ) { print "key: $k value: $v", "\n"; } 

(*) स्ट्रिंग के लिए लागू किया गया इन्क्रीमेंट ऑपरेटर चरित्र सेट से अगला क्रमपरिवर्तन लौटाता है।

 my $a = 'aa'; print ++$a, "\n"; #  ab 

(*) मनमाने ढंग से गहराई तक स्वचालित रूप से हैश और सरणियों का विस्तार करें। यानी जब एक हैश को उस कुंजी तक पहुंचाना जो अभी तक जोड़ा नहीं गया है, तो यह तत्व स्वचालित रूप से निर्मित होता है। और पर्ल अनुमान लगाता है कि आप किस प्रकार का तत्व बनाना चाहते हैं, उदाहरण के लिए, यह एक अनाम हैश, एक अनाम सरणी या एक स्केलर बना सकता है।

 my $hash = {}; $hash->{first}->{second}->{third} = 5; print $hash->{first}->{second}->{third}, "\n"; # 5 

एक दिलचस्प विशेषता सरणियों में नकारात्मक सूचकांकों का व्यवहार है। एक नकारात्मक सूचकांक सरणी के अंत से तत्वों का चयन करता है।

(*) स्ट्रिंग्स और उद्धरण चिह्न। यह अच्छा है कि पर्ल एक असाइनमेंट में मल्टी-लाइन इनपुट का समर्थन करता है:

 my $doc1 = 'There's More Than One Way To Do It -- 2012'; my $doc2 =<<"_DOC2_"; There's More Than One Way To Do It -- 2012 _DOC2_ print<<"_DOC3_"; There's More Than One Way To Do It -- 2012 _DOC3_ 

ऑपरेटर = << का उपयोग आपको असाइनमेंट के समान लाइन पर मल्टी-लाइन दस्तावेज़ के साथ आसानी से संचालन करने की अनुमति देता है। दस्तावेज़ों को फ़ंक्शन में स्थानांतरित करने के लिए इस ऑपरेटर का उपयोग करना भी सुविधाजनक है।

 use strict; sub printAll(@) { print join '', @_; } (my $quote =<<'__QUOTE__')=~s/^\s+//gm; The Road goes ever on and on, down from the door where it began. __QUOTE__ printAll(<<'__GOOD__',<<'__BAD__', $quote); There's More Than One Way To Do It __GOOD__ TIMTOWTDI __BAD__ 

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

 use strict; my $car = { brend => 'Lada', name => 'Kalina', drive => sub { "WEEEEEE!\n"; } }; #  Do you want to drive on $car->{brend} $car->{name}?\n print 'Do you want to drive on $car->{brend} $car->{name}?\n', "\n"; #  Do you want to drive on Lada Kalina? print "Do you want to drive on $car->{brend} $car->{name}?\n"; #  WEEEEEE! print "@{[ $car->{drive}->() ]}"; #  print "@{[ exit ]}"; 

हालांकि, पर्ल आपको तार और नियमित अभिव्यक्ति से बचने के लिए एक चरित्र चुनने का अधिकार देता है।

 print q {   ! }; (my $text = "ab c") =~ s{\s}{}g; 

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

 print `uptime`; #    print << `EOC`; #   pwd ls -l EOC 

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

 my $_name = '?'; sub name(;$): lvalue { $_name = shift || $_name } name = 'caiiiycuk'; print name(), "\n"; 

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

 use strict; sub AUTOLOAD { my $program = our $AUTOLOAD; $program =~ s/.*:://; system($program, @_); } sub uptime(); sub echo(@); uptime; echo "AUTOLOAD"; 

(*) टाई - स्केलर्स, सरणियों और हैश के आंतरिक कार्यान्वयन की जगह के लिए एक तंत्र। इस तंत्र का उपयोग करके, आप किसी सरणी या हैश को डेटाबेस से सीधे इस तरह से जोड़ सकते हैं कि किसी भी पढ़ने और लिखने / से इसे स्वचालित रूप से डेटाबेस पर प्रदर्शित किया जाएगा। इस तकनीक का एक अन्य संभावित अनुप्रयोग संसाधनों का आवंटन हो सकता है।

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

 use strict; use Proc::Fork; run_fork { child { print "Process 1\n" while 1; } parent { print "Process 2\n" while 1; } } 

प्रक्रिया मॉडल के विपरीत, थ्रेड मॉडल बाहर खड़ा है, इन धाराओं ने सभी डेटा संसाधनों तक पहुंच साझा की है, ऐसी धाराएं जावा स्ट्रीम के समान हैं। थ्रेड सपोर्ट मॉड्यूल को थ्रेड कहा जाता है, यह एक बहुत ही सुविधाजनक एसक्यूएन फ़ंक्शन प्रदान करता है जो आपको स्पष्ट कोड लिखने में मदद करता है।

 use Thread 'async'; my $thread1 = async { sleep 5; return 1; }; my $thread2 = async { sleep 2; return 2; }; print $thread1->join(), "\n"; print $thread2->join(), "\n"; 

थ्रेड्स को सिंक्रनाइज़ करने के लिए तंत्रों का समर्थन किया जाता है: म्यूटेक्स, सेमाफोरस, सोते हुए गिरना और स्थिति से थ्रेडिंग जागना।

(*) शक्तिशाली पैक / अनपैक फ़ंक्शन आपको पर्ल संरचनाओं को बाइट सरणी में बदलने और इसके विपरीत करने की अनुमति देते हैं। बाइनरी डेटा को पढ़ने और उनके मनमाने रूपांतरण के लिए एक बहुत ही उपयोगी चीज।

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

 { package Dog; sub new { my $class = shift; return bless { name => shift }, $class; } sub gav { my $self = shift; print "$self->{name}: gav\n"; } } { my $dog = Dog->new('Mona'); $dog->gav(); } { my $dog = new Dog 'Sharik'; gav $dog; } 

पर्ल में ओओपी कई विरासत का समर्थन करता है। उपयोग फ़ील्ड्स प्राग्मा का उपयोग करते समय, छद्म हैश का उपयोग करके संकलन चरण में क्लास फ़ील्ड पर कॉल की जांच करना संभव है, साथ ही साथ निजी क्लास डेटा को लागू करना।

 { package Foo; use fields qw(foo); sub new { my Foo $self = shift; $self = fields::new($self); $self->{foo} = 10; return $self; } } my Foo $var = Foo->new; $var->{foo} = 42; # :     $var->{zap} = 42; 

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

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

 use strict; my @content = <DATA>; print join '', @content; __DATA__ A B C 

(*) बड़ी संख्या में पर्ल कमांड के झंडे प्रसंस्करण फ़ाइलों के लिए यथासंभव कम-से-कम एकल-पंक्ति फ़ाइलों को लिखने की अनुमति देते हैं। उदाहरण के लिए, -n ध्वज थोड़ी देर (<>) लूप में स्क्रिप्ट लपेटता है , जिसकी हमने पहले जांच की थी। यही है, बिल्ली का एनालॉग इस तरह लिखा जा सकता है:

 perl -ne "print;" file1 file2 ... fileN 

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

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

 #!/usr/bin/perl -T use strict; print "Enter file/directory name to delete: \n"; my $file = <STDIN>; # :   ,    #    `rm -rf $file`; 

(*) PSGI / Plack एक विनिर्देश है जो वेब सर्वर वातावरण को वेब फ्रेमवर्क कोड से अलग करने के लिए डिज़ाइन किया गया है। सीधे शब्दों में कहें, यह जावा दुनिया से एक सर्वलेट कंटेनर की तरह है। हम इस विनिर्देशन का उपयोग करके एक वेब एप्लिकेशन लिखते हैं और इसे पीएसजीआई का समर्थन करने वाले किसी भी सर्वर पर चलाते हैं, जिनमें से कई बेहतरीन हैं। अधिक जानकारी ।

(*) और पर्ल सुखद भावनाओं का एक समुद्र है, जो ACME मॉड्यूल का एक सेट है। उदाहरण के लिए, ACME :: EyeDrops मॉड्यूल आपको पर्ल प्रोग्राम को ASCII कला में बदलने की अनुमति देता है जो काम करता है। एक बफी फैन मॉड्यूल है , जिसके उपयोग से प्रोग्राम केवल बफी शब्द का उपयोग करके लिखा जा सकता है। ठीक है, ACME :: ChuckNorris मॉड्यूल खुद के लिए बोलता है। इसके अलावा, पर्ल कविता है - यह पर्ल के दृष्टिकोण के लिए एक वैध वाक्यविन्यास है, और मानव दृष्टिकोण से कविता इस लेख के शीर्षक में से एक है।

बॉन यात्रा!

¹ इसलिए मेरा पर्ल सोचता है, आप अलग-अलग सोच सकते हैं TIMTOWTDI
² मेरी राय पर्ल सुविधाओं में दिलचस्प है