पर्ल ट्यूटोरियल
लुकास बेनेट
पर्ल क्या है?
पर्ल एक उच्च स्तरीय, सामान्य प्रयोजन, व्याख्या की गई, गतिशील प्रोग्रामिंग भाषा है। पर्ल एक शब्द है जिसका अर्थ है "प्रैक्टिकल एक्सट्रैक्शन एंड रिपोर्टिंग लैंग्वेज" भले ही पर्ल का कोई संक्षिप्त नाम न हो। इसे 1987 में लैरी वॉल ने पेश किया था। पर्ल भाषा को विशेष रूप से टेक्स्ट एडिटिंग के लिए डिज़ाइन किया गया था। लेकिन अब, इसका उपयोग लिनक्स सिस्टम एडमिनिस्ट्रेशन, नेटवर्क प्रोग्रामिंग, वेब डेवलपमेंट आदि सहित विभिन्न उद्देश्यों के लिए व्यापक रूप से किया जाता है।
आइए इसे सरल तरीके से समझें। जबकि कंप्यूटर केवल 0 और 1 (बाइनरी भाषा/मशीन भाषा/[निम्न-स्तरीय भाषा]) समझते हैं, हमारे लिए बाइनरी भाषा में प्रोग्राम करना बहुत मुश्किल है। पर्ल एक प्रोग्रामिंग भाषा है जो प्राकृतिक भाषा तत्वों, सामान्य अंग्रेजी भाषा में उपयोग किए जाने वाले शब्दों का उपयोग करती है और इसलिए, मनुष्यों द्वारा समझना आसान है [उच्च स्तरीय भाषा] अब एक समस्या है; कंप्यूटर उच्च-स्तरीय भाषाओं को नहीं समझ सकते, जिन्हें हम मनुष्य आसानी से समझ सकते हैं। इसके लिए हमें किसी ऐसी चीज़ की ज़रूरत है जो उच्च-स्तरीय भाषा को निम्न-स्तरीय भाषा में अनुवाद कर सके। यहाँ इंटरप्रेटर हमारी मदद के लिए आता है। इंटरप्रेटर एक ऐसा सॉफ़्टवेयर है जो उच्च-स्तरीय भाषा में लिखे गए प्रोग्राम को निम्न-स्तरीय भाषा में परिवर्तित करता है ताकि कंप्यूटर प्रोग्राम में लिखे निर्देशों को समझ सके और निष्पादित कर सके। इसलिए, पर्ल एक है व्याख्या की गई प्रोग्रामिंग भाषा.
पर्ल का प्रयोग कहां किया जाता है?
पर्ल स्क्रिप्टिंग भाषा की शक्ति को कई क्षेत्रों में लागू किया जा सकता है। पर्ल का सबसे लोकप्रिय उपयोग वेब डेवलपमेंट में है। पर्ल का उपयोग वेब सर्वर और अन्य प्रशासनिक कार्यों में कई कार्यों को स्वचालित करने के लिए भी किया जाता है, यह स्वचालित रूप से ईमेल उत्पन्न कर सकता है और सिस्टम को साफ कर सकता है। पर्ल का उपयोग अभी भी अपने मूल उद्देश्य यानी डेटा निकालने और रिपोर्ट बनाने के लिए किया जाता है। यह संसाधन उपयोग पर रिपोर्ट तैयार कर सकता है और नेटवर्क में सुरक्षा मुद्दों की जांच कर सकता है। इस कारण से, पर्ल वेब डेवलपमेंट, नेटवर्किंग और बायोइनफॉरमैटिक्स में भी इस्तेमाल की जाने वाली एक लोकप्रिय भाषा बन गई है। इन सबके अलावा पर्ल का इस्तेमाल CGI प्रोग्रामिंग के लिए भी किया जा सकता है।
पर्ल का उपयोग इमेज निर्माण और हेरफेर के लिए भी किया जा सकता है। इसके अलावा टेलनेट, एफ़टीपी आदि के माध्यम से नेटवर्किंग, ग्राफ़िकल यूज़र इंटरफ़ेस निर्माण, वीएलएसआई इलेक्ट्रॉनिक्स और स्पैमिंग प्रथाओं को कम करने के लिए मेल फ़िल्टर बनाने के लिए पर्ल के कुछ उपयोग मामले हैं।
पर्ल को OOP (ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग) प्रथाओं के कार्यान्वयन के लिए भी जाना जाता है और यह सभी प्रकार की विरासत (सरल, मल्टीपल और डायमंड), पॉलीमॉर्फिज्म और एनकैप्सुलेशन का समर्थन करता है। पर्ल इतना लचीला है कि वह प्रक्रियात्मक और OOP प्रथाओं का एक साथ समर्थन कर सकता है। पर्ल में अतिरिक्त मॉड्यूल भी हैं जो आपको लिखे गए कोड को लिखने या उपयोग/पुनः उपयोग करने की अनुमति देते हैं Python, PHP, पीडीएल, टीसीएल, ऑक्टेव, Java, सी, C++, बेसिक, रूबी और लुआ को अपनी पर्ल स्क्रिप्ट में शामिल करें। इसका मतलब है कि आप पर्ल को इन अतिरिक्त के साथ जोड़ सकते हैं प्रोग्रामिंग की भाषाएँ बल्कि मौजूदा कोड को फिर से लिखना होगा।
पर्ल प्रोग्रामिंग भाषा के अनुप्रयोग
पर्ल का उपयोग क्यों करें?
यह सच है कि अन्य प्रोग्रामिंग भाषाएं भी हैं जिनका उपयोग ऊपर बताए गए सभी कार्यों के लिए किया जा सकता है, फिर आपको विशेष रूप से पर्ल का उपयोग क्यों करना चाहिए? पर्ल सीखना बहुत आसान है, खासकर यदि आपके पास कंप्यूटर प्रोग्रामिंग की पृष्ठभूमि है। पर्ल को कंप्यूटर द्वारा प्रसंस्करण के लिए आसान बनाने के बजाय मनुष्यों के लिए लिखना और समझना आसान बनाने के लिए डिज़ाइन किया गया था। यह नियमित अभिव्यक्तियों का उपयोग करता है। इसकी भाषा की प्राकृतिक शैली अन्य प्रोग्रामिंग भाषाओं से अलग है जो विशिष्ट व्याकरण और वाक्यविन्यास का उपयोग करती हैं; इसलिए, पर्ल बहुत लचीला है और किसी समाधान या समस्या के बारे में सोचने का कोई विशेष तरीका आप पर नहीं थोपता है। पर्ल अत्यंत पोर्टेबल है। यह किसी भी ऑपरेटिंग सिस्टम पर चल सकता है जिसमें पर्ल इंटरप्रेटर स्थापित है, इसलिए यह प्लेटफ़ॉर्म स्वतंत्र है। सभी लिनक्स Operaटिंग सिस्टम पर्ल के साथ इंस्टॉल आते हैं, इसलिए आप लिनक्स में पर्ल कोडिंग शुरू कर सकते हैं। यह शेल स्क्रिप्ट से अलग है, जहां कोड लिनक्स वितरण के स्वाद के साथ बदलता है, जिससे यह कम और कम पोर्टेबल हो जाता है पर्ल में छोटे-छोटे विशिष्ट कार्य बहुत आसान और त्वरित हो जाते हैंशुरुआती लोगों के लिए इस पर्ल ट्यूटोरियल में, आप सीखेंगे कि आप विशिष्ट कार्यों के लिए छोटे, त्वरित प्रोग्राम कैसे कोड कर सकते हैं। आइए क्लासिक हैलो वर्ल्ड प्रोग्राम का एक सरल उदाहरण लेते हैं जिसका उपयोग किसी भी प्रोग्रामिंग भाषा को सीखने के लिए किया जाता है जिसकी जड़ें UNIX हैं:
उदाहरण: पर्ल हैलो वर्ल्ड
#!/usr/bin/perl print "Hello, world!";
आउटपुट:
नमस्ते दुनिया!
कोड की उपरोक्त दो पंक्तियाँ Hello, world! प्रिंट करेंगी। अब क्या यह बहुत सरल और त्वरित नहीं था? C के ज्ञान वाले छात्र, C++ यह पता चल जाएगा कि उन भाषाओं में समान आउटपुट प्राप्त करने के लिए कोड की कई और पंक्तियों की आवश्यकता होगी।
आप सोच रहे होंगे क्यों पर्ल वेब पर बहुत प्रसिद्ध हैयह सरल है क्योंकि वेब पर होने वाली अधिकांश चीजें टेक्स्ट की होती हैं और पर्ल टेक्स्ट प्रोसेसिंग में बहुत अच्छा है। अगर हम पर्ल की तुलना किसी भी भाषा से करें, तो पर्ल सबसे अच्छी भाषा होगी जो फ़ाइल हैंडलिंग, टेक्स्ट प्रोसेसिंग और आउटपुट रिपोर्टिंग में अच्छी है।
पर्ल का सबसे अच्छा लाभ यह है कि यह उपयोग करने के लिए स्वतंत्र
पर्ल समुदाय का दृढ़ विश्वास है कि सॉफ्टवेयर स्वतंत्र रूप से उपलब्ध होना चाहिए, स्वतंत्र रूप से संशोधित और स्वतंत्र रूप से वितरित किया जाना चाहिए। पर्ल समुदाय के कई स्वयंसेवक प्रोग्रामिंग भाषा को यथासंभव बेहतर बनाने का प्रयास करते हैं।
पर्ल के फायदे और नुकसान
| पेशेवरों: | विपक्ष: |
|---|---|
|
|
|
|
|
आएँ शुरू करें
पर्ल के इतिहास और पर्ल में कोडिंग के लिए आवश्यक कंप्यूटर प्रोग्रामिंग की बुनियादी अवधारणाओं के बारे में पर्याप्त जानकारी के साथ, अब समय आ गया है कि हम पर्ल के साथ शुरुआत करें। अगला अध्याय आपको सिखाएगा कि आप अपने सिस्टम पर पर्ल कैसे सेटअप कर सकते हैं और पर्ल में कोडिंग की यात्रा के लिए तैयार हो सकते हैं। यह पर्ल स्क्रिप्टिंग ट्यूटोरियल लिनक्स को ओएस के रूप में लेगा जिसका उपयोग छात्र पर्ल में कोडिंग के लिए करेंगे।
पर्ल डाउनलोड और इंस्टॉल करें – Windows, मैक और लिनक्स
पर्ल कैसे प्राप्त करें?
खुशखबरी संभवतः आपके पास यह है!
लेकिन यदि यह आपके सिस्टम पर पहले से उपलब्ध नहीं है, तो भी आप इसे निःशुल्क प्राप्त कर सकते हैं।
यह जानने के लिए कि क्या आपके पास पहले से Perl इंस्टॉल है, कमांड लाइन पर जाएं और टाइप करें: perl -v
यदि Perl इंस्टॉल है तो कमांड उसका संस्करण प्रदर्शित करेगा। इस मामले में, संस्करण v5.14.2 है। लेकिन यदि नहीं... घबराएँ नहीं...
यूनिक्स
|
पहले से स्थापित है यह पर्ल के साथ पहले से इंस्टॉल आता है, हालांकि आपको इसे नवीनतम संस्करण में अपडेट करने की आवश्यकता हो सकती है। |
मैक ओएस 
|
पहले से स्थापित है OSX में Perl पहले से इंस्टॉल आता है, हालाँकि आपको इसे नवीनतम संस्करण में अपडेट करने की आवश्यकता हो सकती है |
Windows
|
स्थापित करने की आवश्यकता है दो विकल्प उपलब्ध हैं
|
लिनक्स पर पर्ल को अद्यतन करना:
यदि आपको पर्ल संस्करण को अपडेट करने की आवश्यकता है तो बस कमांड की एक ही पंक्ति दर्ज करें
sudo apt-get install पर्ल
और आराम करें। बाकी सब ठीक हो जाएगा। बस सुनिश्चित करें कि आपके पास सक्रिय इंटरनेट कनेक्शन है।
के लिए perl स्थापित करें Windows:
सबसे पहले एक्टिव पर्ल को यहाँ से डाउनलोड करें संपर्कActivePerl को स्थापित करने के लिए इन चरणों का पालन करें Windows सिस्टम। इसके लिए नीचे स्क्रीनशॉट देखें।
चरण १: एक बार जब आप इंस्टॉलर डाउनलोड कर लेंगे और इंस्टॉलेशन शुरू कर देंगे तो आपको नीचे दी गई विंडो दिखाई देगी, आगे बढ़ने के लिए अगला पर क्लिक करें।
चरण १: स्थापना को आगे बढ़ाने के लिए लाइसेंसिंग समझौते को स्वीकार करें।
चरण १: नीचे अलग-अलग पैकेज दिए गए हैं जिन्हें इंस्टॉल किया जाएगा। डिफ़ॉल्ट रूप से, सभी चयनित होंगे। केवल एक चीज़ अलग है PPM (Perl पैकेज मैनेजर)। यह आपके सिस्टम में बाहरी Perl मॉड्यूल या लाइब्रेरी इंस्टॉल करने के लिए Active Perl द्वारा प्रदान की गई उपयोगिता है। आगे बढ़ने के लिए Next पर क्लिक करें।
चरण १: ये Perl एक्सटेंशन के विभिन्न प्रकार हैं जिनका उपयोग Perl के लिए किया जा सकता है। हम Perl के लिए अधिकतर .Pl, .Plx और .Pm का उपयोग करेंगे। Perl मॉड्यूल मूल रूप से लाइब्रेरी फ़ाइल को संदर्भित करने के लिए अपने फ़ाइल एक्सटेंशन के रूप में .Pm का उपयोग करते हैं। सभी विकल्पों का चयन करें और अगला बटन पर क्लिक करें।
चरण १: स्थापना के लिए आगे बढ़ने हेतु इंस्टॉल बटन पर क्लिक करें।
चरण १: एक बार इंस्टॉल हो जाने पर, यह जांचने के लिए कि क्या Perl आपके सिस्टम में सफलतापूर्वक इंस्टॉल हुआ है, 'Perl –v' कमांड निष्पादित करें।
लिनक्स और माइक्रोसॉफ्ट दोनों में पर्ल वातावरण स्थापित करने के लिए बहुत सी चीजों पर चर्चा की जरूरत है। Windows, क्योंकि इस इंस्टॉलेशन में बहुत सी लाइब्रेरी फ़ाइलें शामिल नहीं होंगी। आपको उन्हें मैन्युअल रूप से इंस्टॉल करना होगा। आप उन्हें CPAN(व्यापक पर्ल) का उपयोग करके मैन्युअल रूप से इंस्टॉल कर सकते हैं Archive Network) या तो PPM जो केवल perl विंडोज़ के लिए काम करता है। लेकिन Perl में कोडिंग शुरू करने के लिए ये फ़ाइलें अनिवार्य नहीं हैं।
इस विंडोज़ सेटअप के अलावा आप उपयोग कर सकते हैं Windows 10 की विंडोज़ पर लिनक्स सबसिस्टम की नई सुविधा और पर्ल कोड चलाने के लिए इसका उपयोग करें
पहला पर्ल प्रोग्राम
Hello world!
पर्ल उदाहरण: हैलो वर्ल्ड
#!/usr/bin/perl -w #this is just a comment… print "Hello World";
अगर आपको यह पाठ समझ में नहीं आया तो चिंता न करें। जल्द ही सब कुछ स्पष्ट हो जाएगा। आइए और इसे लाइन दर लाइन देखें:
#!/usr/bin/perl
ये बताता है Operaइस फ़ाइल को /usr/bin/perl पर स्थित प्रोग्राम के साथ निष्पादित करने के लिए सिस्टम को टिंग करें कुछ IDE को इस लाइन की आवश्यकता नहीं होती है। यदि यह आवश्यक है, तो आपको अपने इंटरप्रेटर के लिए एक पथ यहाँ लिखना होगा। याद रखें! यह विशेष लाइन आपके प्रोग्राम की शुरुआत में होनी चाहिए और #! use warnings से शुरू होनी चाहिए; यह एक और विशेष कमांड है जो इंटरप्रेटर को किसी भी चेतावनी को प्रदर्शित करने के लिए कहता है यानी -w जो वैश्विक स्तर पर चेतावनियों को सक्रिय करता है।
print "Hello World";
प्रिंट निर्देश स्क्रीन पर टेक्स्ट लिखता है। लाइन के अंत में अर्धविराम पर्ल इंटरप्रेटर को बताता है कि निर्देश समाप्त हो गया है। आपको पर्ल कोड में प्रत्येक निर्देश के अंत में अर्धविराम लगाना चाहिए। उद्धरण चिह्न(“) पर ध्यान दें। यह प्रिंट निर्देश के लिए आवश्यक है। उपरोक्त स्क्रिप्ट को firstprog.pl के रूप में सहेजें
On Windows
यदि आपके पास स्ट्रॉबेरी इंस्टॉल है, तो आप बस रन पर क्लिक कर सकते हैं। आप कमांड-लाइन इंटरफ़ेस भी चला सकते हैं और कंसोल पर लिख सकते हैं:
C:\> perl path\firstprog.pl
या, यदि perl.exe आपके पथ में नहीं है:
C:\> c:\perl\bin\perl.exe firstprog.pl
लिनक्स/यूनिक्स पर
आपको बस टर्मिनल खोलना है और लिखना है:
perl firstprog.pl
यदि आप प्रोग्राम नहीं चला पा रहे हैं, तो सुनिश्चित करें कि आपके पास इसे चलाने की पात्रता है। टर्मिनल में टाइप करें:
chmod +x firstprog.pl
आपका प्रोग्राम अब निष्पादन योग्य है और चलने के लिए तैयार है। निष्पादित करने के लिए, लिखें:
./firstprog
cpan माइनस मॉड्यूल स्थापित करें
मॉड्यूल कोड का एक सेट है जिसका उपयोग कई प्रोग्राम में सामान्य ऑपरेशन करने वाले कार्यों को करने के लिए किया जाता है। यदि आप पर्ल मॉड्यूल का उपयोग करते हैं, तो आपको उसी ऑपरेशन को करने के लिए कोड को फिर से लिखने की आवश्यकता नहीं है। पर्ल कोड की ऐसी बाहरी लाइब्रेरी का उपयोग कर सकता है। सबसे अच्छी लाइब्रेरी में से एक CPAN है। इसका मतलब है कॉम्प्रिहेंसिव पर्ल Archive Network और आपके उपयोग के लिए Perl मॉड्यूल की एक विशाल मात्रा शामिल है। यह बड़ी संख्या में डेवलपर्स का समुदाय या नेटवर्क है जो ऐसे मॉड्यूल का योगदान करते हैं। अपने perl मॉड्यूल में CPAN मॉड्यूल के लिए समर्थन स्थापित करके, आप CPAN मॉड्यूल का उपयोग कर सकते हैं और अपना काम आसान बना सकते हैं। अधिकांश Perl मॉड्यूल Perl में लिखे गए हैं, कुछ XS का उपयोग करते हैं (वे C में लिखे गए हैं) इसलिए C कंपाइलर की आवश्यकता होती है (यह सेटअप करना आसान है - घबराएं नहीं। मॉड्यूल में अन्य मॉड्यूल (लगभग हमेशा CPAN पर) पर निर्भरता हो सकती है और उनके बिना (या उनके किसी विशिष्ट संस्करण के बिना) स्थापित नहीं किया जा सकता है। नीचे दिए गए विकल्पों के लिए दस्तावेज़ को अच्छी तरह से पढ़ना उचित है। ऐप-cpanminus perl मॉड्यूल, कमांड लाइन में टाइप करें:
cpan App::cpanminus
cpan App::cpanminus सुनिश्चित करें कि पर्ल मॉड्यूल डाउनलोड और इंस्टॉल किए जाने के दौरान आपके पास इंटरनेट कनेक्शन हो।
अब कोई भी मॉड्यूल स्थापित करें:
cpan –i <Module_Name>.
आइए File::Data मॉड्यूल स्थापित करने का एक उदाहरण देखें (यह फ़ाइल डेटा तक पहुंचने के लिए एक इंटरफ़ेस है)।
पर्ल वेरिएबल
अब, हम चर के बारे में बात करेंगे। आप चर को एक कंटेनर की तरह समझ सकते हैं जो एक या अधिक मान रखता है। एक बार परिभाषित होने के बाद, चर का नाम वही रहता है, लेकिन मान या मान बार-बार बदलते रहते हैं।
चर के 3 प्रकार हैं:
पर्ल में चरों के प्रकार
सबसे आसान स्केलर हैं, और यह आज का हमारा विषय है
स्केलर चर
इस प्रकार का चर एकल मान रखता है।
इसका नाम डॉलर चिह्न और पर्ल पहचानकर्ता से शुरू होता है (यह हमारे वेरिएबल का नाम है)।
पर्ल में स्केलर चर
नामकरण परंपरा
यदि आप अन्य प्रोग्रामिंग भाषाओं से परिचित हैं, तो आपको पता होगा कि चरों के नामकरण के बारे में कुछ नियम हैं। इसी तरह, पर्ल में स्केलर के नामकरण के लिए तीन नियम हैं।
- सभी स्केलर नाम $ से शुरू होंगे। हर नाम के आगे $ लगाना याद रखना आसान है। इसे $ स्केलर के रूप में सोचें।
- PHP की तरह। पहले अक्षर $ के बाद, जो कि Perl में खास है, अल्फ़ान्यूमेरिक अक्षर यानी a से z, A से Z और 0 से 9 की अनुमति है। अंडरस्कोर कैरेक्टर की भी अनुमति है। वेरिएबल नामों को दो शब्दों में विभाजित करने के लिए अंडरस्कोर का उपयोग करें। 'लेकिन पहला अक्षर कोई संख्या नहीं हो सकता'
- भले ही संख्याएँ नाम का हिस्सा हो सकती हैं, लेकिन वे $ के तुरंत बाद नहीं आ सकतीं। इसका मतलब है कि $ के बाद पहला अक्षर या तो कोई अक्षर होगा या फिर अंडरस्कोर। C/ से आने वालेC++ पृष्ठभूमि को तुरंत समानता पहचानने में सक्षम होना चाहिए। उदाहरण
पर्ल उदाहरण:
$var; $Var32; $vaRRR43; $name_underscore_23;
हालाँकि, ये वैध स्केलर चर नाम नहीं हैं।
mohohoh # $ character is missing $ # must be at least one letter $47x # second character must be a letter $variable! # you can't have a ! in a variable name
सामान्य नियम कहता है, जब पर्ल में किसी चीज़ का सिर्फ़ एक ही भाग होता है, तो उसे स्केलर कहते हैं। स्केलर को डिवाइस से पढ़ा जा सकता है, और हम इसे अपने प्रोग्राम में इस्तेमाल कर सकते हैं।
स्केलर डेटा प्रकार के दो प्रकार
- Numbers
- स्ट्रिंग्स
Numbers:
इस प्रकार के स्केलर डेटा में हम निर्दिष्ट कर सकते हैं:
- पूर्णांक, बस यह पूर्ण संख्याएँ हैं, जैसे 2, 0, 534
- फ़्लोटिंग-पॉइंट संख्याएँ, ये वास्तविक संख्याएँ हैं, जैसे 3.14, 6.74, 0.333
ध्यान दें: सामान्य तौर पर, पर्ल इंटरप्रेटर पूर्णांकों को फ़्लोटिंग पॉइंट संख्याओं की तरह देखता है। उदाहरण के लिए, यदि आप अपने प्रोग्राम में 2 लिखते हैं, तो पर्ल इसे 2.0000 की तरह देखेगा
पूर्णांक अक्षर:
इसमें एक या अधिक अंक होते हैं, वैकल्पिक रूप से पहले प्लस या माइनस होता है और इसमें अंडरस्कोर होता है।
पर्ल उदाहरण:
0; -2542; 4865415484645 #this also can be written with underscores (for clarity) : 4_865_415_484_645
जैसा कि आप देख सकते हैं- इसमें कुछ खास नहीं है। लेकिन मेरा विश्वास करें, यह स्केलर का सबसे आम प्रकार है। वे हर जगह हैं।
फ़्लोटिंग-पॉइंट लिटरल:
इसमें अंक, वैकल्पिक रूप से ऋण, दशमलव बिंदु और घातांक शामिल होते हैं।
पर्ल उदाहरण:
3.14; 255.000; 3.6e20; # it's 3.6 times 10 to the 20th -3.6e20; # same as above, but negative -3.6e-20; #it's negative 3.6 times 10 to the -20th -3.6E-20; #we also can use E – this means the same the lowercase version -3.6e-20
अष्टाधारी, षोडशआधारी और बाइनरी प्रतिनिधित्व:
यह दशमलव प्रणाली का विकल्प है। मुझे आपको ऑक्टल, हेक्साडेसिमल और बाइनरी प्रतिनिधित्व दिखाने की अनुमति दें। एक छोटी तालिका इस अजीब शैली के बारे में सभी महत्वपूर्ण जानकारी प्रस्तुत करती है:
| प्रतिनिधित्व | आधार | आगे बढा |
|---|---|---|
| अष्टभुजाकार | 8 | 0 (शून्य) |
| षोडश आधारी | 16 | 0x |
| द्विचर | 2 | 0b |
पर्ल उदाहरण:
255; # 255 in decimal notation 0377; # 255 in octal notation 0xff; # 255 in hexadecimal notation 0b11111111; # 255 in binary notation
पर्ल के लिए इन सभी मानों का मतलब एक ही है। पर्ल इन मानों को एक ही प्रारूप में संग्रहीत नहीं करता है। यह आंतरिक रूप से इन हेक्साडेसिमल, बाइनरी, ऑक्टल को दशमलव मानों में परिवर्तित कर देगा।
असाइनमेंट स्केलर पर सबसे आम ऑपरेशन है, और यह बहुत सरल है। पर्ल इसके लिए बराबर चिह्न का उपयोग करता है। यह दाईं ओर से अभिव्यक्ति का मान लेता है और इस मान को हमारे चर में डाल देता है।
आइये कुछ उदाहरण देखें:
$size=15; # give $size value of 15 $y = -7.78; # give $y value of -7.78
इसके अलावा आप चर में न केवल एक संख्या, बल्कि एक अभिव्यक्ति भी डाल सकते हैं।
$z = 6 + 12 # give $z value of 18
स्ट्रिंग्स
स्ट्रिंग्स: यह भी बहुत सरल प्रकार का स्केलर है।
पर्ल में स्ट्रिंग की अधिकतम लंबाई कंप्यूटर में मौजूद मेमोरी की मात्रा पर निर्भर करती है। स्ट्रिंग के आकार की कोई सीमा नहीं है, किसी भी संख्या में वर्ण, प्रतीक या शब्द आपकी स्ट्रिंग बना सकते हैं। सबसे छोटी स्ट्रिंग में कोई वर्ण नहीं होता। सबसे लंबी स्ट्रिंग पूरी सिस्टम मेमोरी भर सकती है। पर्ल प्रोग्राम पूरी तरह से 7-बिट ASCII कैरेक्टर सेट में लिखे जा सकते हैं। पर्ल आपको स्ट्रिंग लिटरल के भीतर कोई भी 8-बिट या 16-बिट कैरेक्टर सेट उर्फ़ नॉन-ASCII कैरेक्टर जोड़ने की अनुमति देता है। पर्ल ने यूनिकोड UTF-8 के लिए समर्थन भी जोड़ा है।
संख्याओं की तरह स्ट्रिंग्स के भी दो अलग-अलग प्रकार हैं:
- सिंगल कोट्स स्ट्रिंग लिटरल
- Double उद्धरण स्ट्रिंग अक्षर
एकल-उद्धृत स्ट्रिंग लिटरल
एकल उद्धरण चिह्नों का उपयोग उस डेटा को शामिल करने के लिए किया जाता है जिसे आप शाब्दिक रूप से लेना चाहते हैं। एक छोटा सा उदाहरण और सब कुछ स्पष्ट हो जाना चाहिए:
पर्ल उदाहरण:
#!/usr/bin/perl $num = 7; $txt = 'it is $num'; print $txt;
आउटपुट:
यह $num है
यहाँ एकल उद्धरण चिह्नों के कारण $num का मान नहीं लिया गया है तथा अक्षर '$','n', 'u' और 'm' को $txt के मान में जोड़ दिया गया है।
Double-उद्धृत स्ट्रिंग लिटरल
Double उद्धरण चिह्नों का उपयोग उस डेटा को संलग्न करने के लिए किया जाता है जिसे प्रसंस्करण से पहले प्रक्षेपित करने की आवश्यकता होती है। इसका मतलब है कि एस्केप किए गए वर्ण और चर केवल बाद के ऑपरेशनों में शाब्दिक रूप से सम्मिलित नहीं किए जाते हैं, बल्कि उनका मौके पर ही मूल्यांकन किया जाता है। एस्केप वर्णों का उपयोग नई लाइनें, टैब आदि सम्मिलित करने के लिए किया जा सकता है।
पर्ल उदाहरण:
$num = 7; $txt = "it is $num"; print $txt;
आउटपुट:
यह 7 है
यहाँ दोहरे उद्धरण चिह्नों के कारण $num का मान $txt के मान में जोड़ दिया गया है
Double-कोट्स स्केलर और ऐरे वैरिएबल को इंटरपोल करते हैं, लेकिन हैश को नहीं। दूसरी ओर, आप ऐरे और हैश दोनों के स्लाइस को इंटरपोल करने के लिए डबल-कोट्स का उपयोग कर सकते हैं।
रहस्यमय \n
निम्नलिखित कार्यक्रम पर विचार करें
पर्ल उदाहरण:
print "hello \n";
आउटपुट:
नमस्ते
पर्ल सिर्फ़ 'hello\n' नहीं दिखाता, बल्कि सिर्फ़ 'hello' दिखाता है। क्यों? क्योंकि '\n' एक विशेष चिह्न है और इसका मतलब है कि आप अपने प्रोग्राम में टेक्स्ट दिखाते समय एक नई लाइन पर जाना चाहते हैं। print “hello\n new line”; अगला सवाल- क्या कोई और विशेष चिह्न है? हाँ, वे हैं! लेकिन चिंता न करें- बस कुछ ही हैं। नीचे दी गई तालिका देखें
| के निर्माण के | विवरण |
|---|---|
| \n | नई पंक्ति |
| \r | वापसी |
| \t | टैब |
| \f | फ़ीड बनाएं |
| \b | बैकस्पेस |
| \a | घंटी |
| \e | बच |
| \ 007 | कोई भी अष्टाधारी ASCII मान (यहाँ, 007 = घंटी) |
| \x7फ़ | कोई भी हेक्स मान (यहाँ, 7f = हटाएं) |
| \\ | बैकस्लैश |
| \ " | दोहरे उद्धरण |
| \l | अगला अक्षर छोटा करें |
| \L | \E तक सभी निम्न अक्षरों को लोअरकेस में लिखें |
| \u | अगला अक्षर बड़ा लिखें |
| \U | \E तक सभी अक्षरों को बड़े अक्षरों में लिखें |
| \E | \L, \U समाप्त करें |
मैं जानता हूँ, 'सिर्फ कुछ' नहीं हैं... लेकिन मेरा विश्वास करो, आपको बस यह जानना चाहिए
स्ट्रिंग्स चर
यह वही ऑपरेशन है, जिसे हम नंबर असाइनमेंट में देखते हैं। पर्ल हमारे स्ट्रिंग को बराबर चिह्न के दाईं ओर से प्राप्त करता है और इस स्ट्रिंग को एक चर में डालता है।
पर्ल उदाहरण:
$string = 'tutorial'; # give $string the eight-character string 'tutorial' print $string; $string = $size + 3 ; # give $string the current value of $size plus 3 print $string; $string = $ string * 5; # multiplied $string by 5 print $string;
आउटपुट:
ट्यूटोरियल 315
जैसा कि आप देख सकते हैं, आप संख्याओं और स्ट्रिंग्स को एक ही चर में रख सकते हैं। चरों का कोई वर्ग नहीं है।
स्ट्रिंग संयोजन (अवधि) :
संयोजन ऑपरेटर “.” दो या अधिक स्ट्रिंग को जोड़ता है। याद रखें! यदि स्ट्रिंग में उद्धरण चिह्न, कैरिज रिटर्न, बैकस्लैश शामिल हैं, तो इन सभी विशेष वर्णों को बैकस्लैश के साथ एस्केप करना होगा।
पर्ल ' ' चर उदाहरण:
#!/usr/bin/perl $a = "Tom is"; $b = "favorite cat"; $c = $a ." mother's ". $b; print $c;
आउटपुट:
टॉम माँ की पसंदीदा बिल्ली है
तार
“$a”, “$b”, को “.” ऑपरेटर का उपयोग करके “$c” में संयोजित और संग्रहीत किया जाता है।
अंततः…
के बीच रूपांतरण Numbers और स्ट्रिंग्स:
जैसा कि आप जानते हैं, पर्ल स्वचालित रूप से आवश्यकतानुसार संख्याओं को स्ट्रिंग में परिवर्तित करता है। पर्ल को कैसे पता चलता है कि हमें अभी क्या चाहिए? यह सरल है- सब कुछ ऑपरेटर पर निर्भर करता है (हम बाद में ऑपरेटरों के बारे में बात करेंगे, अभी, बस स्वीकार करें कि बहुत सारे ऑपरेटर हैं, संख्याओं और स्ट्रिंग के लिए अलग-अलग) यदि कोई ऑपरेटर किसी संख्या की अपेक्षा करता है, तो पर्ल उस मान को संख्या के रूप में उपयोग करेगा। यदि कोई ऑपरेटर किसी स्ट्रिंग की अपेक्षा करता है, तो पर्ल उस मान को स्ट्रिंग के रूप में उपयोग करेगा। दूसरे शब्दों में- आपको इस तरह के रूपांतरण के बारे में चिंता करने की आवश्यकता नहीं है। संक्षिप्त उदाहरण और सब कुछ स्पष्ट होना चाहिए:
पर्ल उदाहरण:
$string = "43"; $number = 28; $result = $string + $number; print $result;
आउटपुट:
71
$string का मान एक पूर्णांक में परिवर्तित किया जाता है और $number के मान में जोड़ा जाता है।
योग का परिणाम, 71, $result को सौंपा गया है।
चर का दायरा – एक्सेस संशोधक
हम प्रोग्राम में कहीं भी स्केलर घोषित कर सकते हैं। लेकिन आपको एक एक्सेस मॉडिफायर निर्दिष्ट करने की आवश्यकता है
संशोधक तीन प्रकार के होते हैं
- my
- स्थानीय
- हमारी
माई: इसका उपयोग करके आप किसी भी चर को घोषित कर सकते हैं जो ब्लॉक के भीतर विशिष्ट है। यानी घुंघराले ब्रेसिज़ के भीतर।
#!/usr/bin/perl
my $var=5;
if(1)
{
my $var_2 =$var;
}
print $var_2;
उत्पादन नही
कार्यक्रम का आउटपुट कुछ भी नहीं होगा!
उपरोक्त उदाहरण में, आप देखेंगे कि दो वैरिएबल घोषित किए गए हैं, एक if ब्लॉक ($var_2) के अंदर है और दूसरा If ब्लॉक ($var) के बाहर है। ब्लॉक के बाहर घोषित किया गया वैरिएबल if ब्लॉक के लिए सुलभ होगा, लेकिन if ब्लॉक के अंदर घोषित किया गया वैरिएबल बाहरी प्रोग्राम के लिए सुलभ नहीं होगा।
स्थानीय: इसका उपयोग करके हम वास्तव में चर के मूल मान को बदले बिना समान चर मानों को विभिन्न मानों में बदल सकते हैं, मान लीजिए हमारे पास एक चर $a है जिसके लिए मान 5 निर्दिष्ट किया गया है, आप वास्तव में उस चर के मूल मान को बदले बिना स्थानीय कीवर्ड का उपयोग करके उसी चर को फिर से घोषित करके उस चर के मान को बदल सकते हैं जो 5 है। आइए एक उदाहरण के साथ देखें कि यह कैसे काम करता है।
#!/usr/bin/perl
$var = 5;
{
local $var = 3;
print "local,\$var = $var \n";
}
print "global,\$var = $var \n";
उपरोक्त प्रोग्राम का आउटपुट इस प्रकार होगा।
स्थानीय, $var = 3
वैश्विक, $var = 5
इस तरह हम मूल मान को प्रभावित किये बिना चर का मान बदल सकते हैं।
हमारा: एक बार जब कोई वैरिएबल एक्सेस मॉडिफ़ायर “हमारा” के साथ घोषित हो जाता है, तो उसे पूरे पैकेज में इस्तेमाल किया जा सकता है। मान लीजिए, आपके पास Perl मॉड्यूल या पैकेज test.pm है, जिसमें स्कोप our के साथ एक वैरिएबल घोषित किया गया है। इस वैरिएबल को किसी भी स्क्रिप्ट में एक्सेस किया जा सकता है जो उस पैकेज का उपयोग करेगी।
यदि आप पर्ल में प्रोग्रामिंग के बारे में गंभीर हैं, तो आपको अपना प्रोग्राम इस प्रकार से शुरू करना चाहिए
#!/usr/local/bin/perl
सख्त उपयोग करें;
इससे आपको बेहतर और स्वच्छ कोड लिखने में मदद मिलेगी। 'use strict' स्ट्रिक्ट प्रैग्मा को चालू करता है, जो आपको अपने वेरिएबल्स को my कीवर्ड के साथ घोषित करने में सक्षम करेगा।
यह एक अच्छा प्रोग्रामिंग अभ्यास है
#!/usr/local/bin/perl use strict; $var = 10; print "$var";
परिणाम: त्रुटि
#!/usr/local/bin/perl use strict; my $var = 10; print "$var";
आउटपुट:
10
पर्ल ऐरे
पर्ल ऐरे क्या है?
ऐरे एक विशेष प्रकार का वैरिएबल है जो डेटा को सूची के रूप में संग्रहीत करता है; प्रत्येक तत्व को इंडेक्स नंबर का उपयोग करके एक्सेस किया जा सकता है जो प्रत्येक तत्व के लिए अद्वितीय होगा। आप अपने ऐरे में नंबर, स्ट्रिंग, फ्लोटिंग वैल्यू आदि स्टोर कर सकते हैं। यह बहुत बढ़िया लगता है, तो हम पर्ल में ऐरे कैसे बनाते हैं? पर्ल में, आप '@' वर्ण का उपयोग करके एक ऐरे को परिभाषित कर सकते हैं, उसके बाद वह नाम जो आप देना चाहते हैं। आइए पर्ल में एक ऐरे को परिभाषित करने पर विचार करें।
मेरा @array;
इस तरह हम पर्ल में ऐरे को परिभाषित करते हैं; आप सोच रहे होंगे कि हमें इसमें डेटा कैसे स्टोर करना चाहिए। ऐरे में डेटा स्टोर करने के अलग-अलग तरीके हैं। यह इस बात पर निर्भर करता है कि आप इसका इस्तेमाल कैसे करने जा रहे हैं।
my @array=(a,b,c,d); print @array;
आउटपुट:
ABCD
यह एक सारणी है जिसमें 4 तत्व हैं।
सरणी सूचकांक 0 से शुरू होता है और अपने अधिकतम घोषित आकार पर समाप्त होता है, इस मामले में, अधिकतम सूचकांक आकार 3 है।
पर्ल ऐरे उदाहरण
आप उपरोक्त तरीके से भी एक सारणी घोषित कर सकते हैं; एकमात्र अंतर यह है कि, यह रिक्त स्थान को सीमांकक मानकर डेटा को सारणी में संग्रहीत करता है। यहाँ, qw() का अर्थ है उद्धरण शब्द। इस फ़ंक्शन का महत्व शब्दों की सूची तैयार करना है। आप qw का उपयोग कई तरीकों से एक सरणी घोषित करने के लिए कर सकते हैं।
@array1=qw/a b c d/;
@array2= qw' p q r s';
@array3=qw { v x y z};
print @array1;
print @array2;
print @array3;
आउटपुट:
abcdpqrsvxyz
मान लीजिए आप 5 को एक मान निर्दिष्ट करना चाहते हैंth एक सरणी का तत्व, हम ऐसा कैसे करने जा रहे हैं।
$array [4] ='ई';
अनुक्रमिक सरणी
अनुक्रमिक सरणियाँ वे हैं जहाँ आप डेटा को क्रमिक रूप से संग्रहीत करते हैं। मान लीजिए, आप 1-10 संख्याएँ या अक्षर az को एक सरणी में संग्रहीत करना चाहते हैं। सभी अक्षरों को टाइप करने के बजाय, आप नीचे दिए गए कुछ इस तरह से प्रयास कर सकते हैं -
@numbers= (1..10); print @numbers; #Prints numbers from 1 to 10;
आउटपुट:
12345678910
पर्ल सरणी आकार
हमारे पास एक सारणी है जो पहले से ही उपलब्ध है, और आप नहीं जानते कि उस सारणी का आकार क्या है, तो उसे ज्ञात करने का संभावित तरीका क्या है।
@array= qw/a b c d e/; print $size=scalar (@array);
क्या हम फ़ंक्शन का उपयोग किए बिना किसी ऐरे का आकार प्राप्त कर सकते हैं? हाँ, हम कर सकते हैं।
@array= qw/a b c d e/; print $size=scalar (@array); print "\n"; print $size=$#array + 1; # $#array will print the Max Index of the array, which is 5 in this case
आउटपुट:
5
5
गतिशील सरणी
किसी सारणी को घोषित करने की उपरोक्त विधि को कहा जाता है स्थिर सरणियाँ, जहाँ आप एक सरणी का आकार जानते हैं।
डायनामिक ऐरे क्या है?
डायनेमिक ऐरे वे होते हैं जिन्हें आप बिना कोई मान निर्दिष्ट किए घोषित करते हैं। तो हम उस ऐरे में मान कब संग्रहीत करते हैं? सरल, हम उन्हें रन टाइम के दौरान संग्रहीत करते हैं। इसके लिए यहाँ एक सरल प्रोग्राम है।
हम इस कार्य के लिए कुछ इनबिल्ट पर्ल फंक्शन्स का उपयोग करेंगे।
my $string="This is a kind of dynamic array";
my @array;
@array=split('a',$string);
foreach(@array)
{
print "$_ \n”;
# This is a special variable which stores the current value.
}
आउटपुट:
यह वह जगह है
डायन का प्रकार
mic के
rr
y
स्प्लिट फ़ंक्शन स्ट्रिंग की सामग्री को उसके लिए दिए गए सीमांकक के आधार पर एक सरणी में विभाजित करता है। यह फ़ंक्शन स्ट्रिंग से सीमांकक को भी हटा देगा, इस मामले में, यह 'a' है;
पर्ल सरणियों के लिए पुश, पॉप, शिफ्ट, अनशिफ्ट:
इन फंक्शनों का उपयोग पर्ल में सरणी तत्वों को जोड़ने/हटाने के लिए किया जा सकता है।
- पर्ल पुश: किसी मौजूदा सरणी के अंत में सरणी तत्व जोड़ता है।
- पर्ल पॉप: किसी सारणी से अंतिम तत्व को हटाता है।
- पर्ल Shift: किसी सारणी से पहला तत्व हटाता है।
- पर्ल अनशिफ्ट: किसी सारणी के आरंभ में एक तत्व जोड़ता है।
आइए एक उदाहरण देखें जहां हम नीचे दिए गए फ़ंक्शन का उपयोग कर सकते हैं।
@days = ("Mon","Tue","Wed");
print "1st : @days\n";
push(@days, "Thu"); # adds one element at the end of an array
print "2nd when push : @days\n";
unshift(@days, "Fri"); # adds one element at the beginning of an array
print "3rd when unshift : @days\n";
pop(@days);
print "4th when pop : @days\n"; # remove one element from the last of an array.
shift(@days); # remove one element from the beginning of an array.
print "5th when shift : @days\n";
आउटपुट:
प्रथम : सोम मंगल बुध
2 जब धक्का : सोम मंगल बुध गुरु
3रा जब अनशिफ्ट : शुक्र सोम मंगल बुध गुरु
४ वां जब पॉप : शुक्र सोम मंगल बुध
5वीं शिफ्ट कब : सोम मंगल बुध
पर्ल हैश
हमें हैश की आवश्यकता क्यों है?
हम पिछले अनुभागों में स्केलर और ऐरेज़ के बारे में पहले ही सीख चुके हैं।
स्केलर वास्तव में क्या करते हैं? यह केवल पूर्णांक और स्ट्रिंग्स को संग्रहीत करता है।
ऐरे वास्तव में क्या करते हैं? यह स्केलर्स का एक संग्रह है, जहाँ आप इंडेक्स का उपयोग करके ऐरे के प्रत्येक तत्व तक पहुँचते हैं। लेकिन, क्या यह एक ऐरे का उपयोग करने का अच्छा विचार है जब आपके पास सैकड़ों और हज़ारों रिकॉर्ड हों? हम भूल जाएँगे कि किस इंडेक्स का क्या मूल्य है। इस स्थिति से निपटने के लिए हमारे पास पर्ल हैश जैसा कुछ है।
हैश क्या हैं?
एक हैश में उतने ही स्केलर हो सकते हैं जितने कि सरणी में हो सकते हैं। एकमात्र अंतर यह है कि हमारे पास कोई इंडेक्स नहीं है बल्कि हमारे पास कुंजियाँ और मान हैं। हैश को % से शुरू करके उसके बाद हैश के नाम से घोषित किया जा सकता है। आइए एक उदाहरण देखें कि हम पर्ल हैश को कैसे परिभाषित कर सकते हैं और हम इसे सरणी से कैसे अलग कर सकते हैं
तीन व्यक्तियों का उदाहरण लीजिए, जिनकी आयु एक सारणी में दर्शाई गई है।
@array=('Sainath',23,'Krishna',24,'Shruthi',25); #This is how an array looks.
print @array;
आउटपुट:
साईनाथ33Krishna24श्रुति25
इस तरह से व्यक्तिगत आयु जानना मुश्किल है क्योंकि हमें सभी लोगों के नाम और आयु दोनों के सूचकांक स्थान याद रखने की आवश्यकता है। जब आपके पास 3 नाम हों तो यह आसान हो सकता है, लेकिन जब आपके पास 1000 या उससे ज़्यादा नाम हों? आप जवाब जानते हैं।
हम हैश का उपयोग करके इस समस्या पर काबू पा सकते हैं।
हैश उदाहरण:
print %hash=( 'Sainath' => 23, 'Krishna' => 24, 'Shruthi' => 25); # This is how we create a hash.
print %hash=('Sainath',23,'Krishna',24,'Shruthi',25);# This way of assigning is called list.
आउटपुट:
साईनाथ33Krishna24श्रुति25साईनाथ33Krishna24श्रुति25
हमने अब एक हैश घोषित कर दिया है, बढ़िया!! लेकिन, हम इसे कैसे एक्सेस या प्रिंट करेंगे? हैश में प्रत्येक तत्व को उसकी संबद्ध कुंजी के साथ एक्सेस किया जाना चाहिए जिसके लिए एक मान निर्दिष्ट किया जाएगा। इसलिए, हैश में प्रत्येक कुंजी और मान के बीच एक-एक मैपिंग है।
किसी भी व्यक्ति की आयु प्रिंट करने के लिए आपको बस उस व्यक्ति का नाम याद रखना होगा।
print $hash{'Krishna'}; # This how we should access a hash. Key enclosed within {}.
आपको आश्चर्य हो सकता है कि मैंने $hash{KeyName} का उपयोग क्यों किया, याद रखें कि हैश फिर से स्केलर का एक संग्रह है। इसलिए, हम प्रत्येक हैश तत्व तक पहुँचने के लिए $ का उपयोग कर सकते हैं जो स्केलर का प्रतिनिधित्व करता है।
नोट: हैश में प्रत्येक कुंजी अद्वितीय होनी चाहिए अन्यथा यह आपके द्वारा पहले निर्दिष्ट किए गए मान को ओवरराइड कर देगी।
हम एक हैश को दूसरे हैश में कैसे असाइन कर सकते हैं? सरल, उसी तरह जैसे हम करते हैं
हम संपूर्ण हैश भी प्रिंट कर सकते हैं।
%hash=( 'Tom' => 23); %newHash=%hash; # Assigning hash to a new hashprint %newHash; print %newHash;
आउटपुट:
Tom23
पर्ल हैश जोड़ें
जैसा कि आप देख सकते हैं कि हमारे पास पहले से ही एक हैश %newHash है, और अब हमें इसमें और प्रविष्टियाँ जोड़ने की आवश्यकता है।
$newHash{'Jim'}=25;
$newHash{'John'}=26;
$newHash{'Harry'}=27;
print %newHash;
आउटपुट:
जिम25जॉन26हैरी27
पर्ल डिलीट कुंजी
आप किसी हैश से कोई प्रविष्टि हटाना चाह सकते हैं। हम ऐसा इस तरह कर सकते हैं।
delete $newHash{'Jim'};#This will delete an entry from the hash.
डिलीट पर्ल का एक इनबिल्ट फंक्शन है। यहाँ, हम एक ऐरे को हैश असाइन करने का एक उदाहरण देखेंगे।
@array=%newHash; print "@array";
नोट: जब भी आप हैश प्रिंट करते हैं या जब आप हैश को किसी ऐरे में स्टोर करते हैं। क्रम हमेशा अलग-अलग हो सकता है। यह हमेशा एक जैसा नहीं होता।
हम किसी सारणी को केवल हैश की कुंजियाँ या मान ही निर्दिष्ट कर सकते हैं।
@arraykeys= keys(%newHash); @arrayvalues=values(%newHash); print "@arraykeys\n"; print "@arrayvalues\n"; # \n to print new line.
हैश में सभी प्रविष्टियों को हटाने के लिए, हम सीधे हैश को शून्य पर असाइन कर सकते हैं।
%newHash=();# यह बिना प्रविष्टियों के हैश को पुनः परिभाषित करेगा।
पर्ल सशर्त कथन
हम पर्ल में सशर्त कथनों का उपयोग कर सकते हैं। तो, सशर्त कथन क्या हैं? सशर्त कथन वे हैं, जहाँ आप वास्तव में अपने कोड में कुछ परिस्थितियों की संतुष्टि की जाँच करते हैं।
एक उदाहरण के बारे में सोचिए, आप कुछ फल खरीद रहे हैं, और आपको उनकी कीमत 100 रुपये से ज़्यादा पसंद नहीं है। तो, यहाँ नियम 100 रुपये का है।
पर्ल दो प्रकार के सशर्त कथनों का समर्थन करता है; वे हैं if और unless.
पर्ल अगर
यदि कोड ब्लॉक निष्पादित किया जाएगा, जब शर्त सत्य होगी।
my $a=5;
if($a==5)
{
print "The value is $a";
}
आउटपुट:
5
पर्ल अगर अन्यथा
यह अच्छा लग रहा है। आइए हम ऐसी स्थिति के बारे में सोचें जहां $a 5 नहीं है।
my $a=10;
if($a==5)
{
print "The values is $a ---PASS";
}
else
{
print "The value is $a ---FAIL";
}
आउटपुट:
मान 10 है — असफल
इस तरह हम एक समय में केवल एक ही स्थिति को नियंत्रित कर सकते हैं। क्या यह कोई सीमा है? नहीं, आप if… elsif … else का उपयोग करके विभिन्न स्थितियों को भी नियंत्रित कर सकते हैं।
पर्ल अन्यथा यदि
my $a=5;
if($a==6)
{
print "Executed If block -- The value is $a";
}
elsif($a==5)
{
print "Executed elsif block --The value is $a";
}
else
{
print "Executed else block – The value is $a";
}
आउटपुट:
निष्पादित elsif ब्लॉक – मान 5 है
उपरोक्त मामले में, elsif ब्लॉक $a is equal to 5 के रूप में निष्पादित किया जाएगा।
ऐसी परिस्थितियाँ हो सकती हैं जहाँ if और elsif दोनों कोड ब्लॉक विफल हो जाएँगे। इस परिदृश्य में, else कोड ब्लॉक निष्पादित किया जाएगा। यदि आप शामिल करना पसंद नहीं करते हैं तो आप else कोड जाँच को वास्तव में समाप्त कर सकते हैं।
पर्ल नेस्टेड अगर
इस स्थिति में, आप if कोड ब्लॉक को एक और if कोड ब्लॉक में उपयोग कर सकते हैं।
my $a=11; #Change values to 11,2,5 and observe output
if($a<10){
print "Inside 1st if block";
if($a<5){
print "Inside 2nd if block --- The value is $a";
}
else{
print " Inside 2nd else block --- The value is $a";
}
}
else{
print "Inside 1st else block – The value is $a";
}
आउटपुट:
पहले else ब्लॉक के अंदर – मान 1 है
$a का मान बदलकर उसी कोड को निष्पादित करें; आप बाकी का पता लगा सकते हैं।
पर्ल जब तक
आपको पहले से ही अंदाजा हो गया होगा कि if क्या करता है (यदि शर्त सत्य है तो यह कोड ब्लॉक निष्पादित करेगा)। Whens, if के विपरीत है, whens कोड ब्लॉक निष्पादित होगा यदि शर्त असत्य है।
my $a=5;
unless($a==5)
{
print "Inside the unless block --- The value is $a";
}
else
{
print "Inside else block--- The value is $a";
}
आउटपुट:
पहले else ब्लॉक के अंदर – मान 1 है
अनुमान लगाइए कि आउटपुट क्या होगा। आप सही हैं!!!!! आउटपुट else ब्लॉक का प्रिंट स्टेटमेंट होगा। चूँकि जब तक कोड ब्लॉक में शर्त सत्य है, याद रखें जब तक ब्लॉक केवल तभी निष्पादित होगा जब शर्त गलत होगी। $a का मान बदलें और कोड निष्पादित करें, आपको अंतर दिखाई देगा।
पर्ल का उपयोग करना यदि
$a= " This is Perl";
if($a eq "SASSDSS"){
print "Inside If Block";
}
else
{
print "Inside else block"
}
आउटपुट:
else ब्लॉक के अंदर
जब तक का उपयोग न करें
$a= " This is Perl";
unless($a eq "SASSDSS"){
print "Inside unless Block";
}
else
{
print "Inside else block"
}
आउटपुट:
ब्लॉक के अंदर जब तक
पर्ल लूप्स – नियंत्रण संरचनाएं
पर्ल अन्य प्रोग्रामिंग भाषाओं के समान नियंत्रण संरचनाओं का समर्थन करता है। पर्ल चार प्रकार की नियंत्रण संरचनाओं for, foreach, while और Until का समर्थन करता है। हम इन कथनों का उपयोग किसी कोड को बार-बार निष्पादित करने के लिए करते हैं।
फॉर लूप पर्ल
कोड ब्लॉक तब तक निष्पादित होगा जब तक कि शर्त पूरी न हो जाए। आइए एक उदाहरण लेते हैं कि कैसे एक सरणी को पर्ल लूप किया जाता है।
my @array=(1..10);
for(my $count=0;$count<10;$count++)
{
print "The array index $count value is $array[$count]";
print "\n";
}
आउटपुट:
सरणी सूचकांक 0 का मान 1 है
सरणी सूचकांक 1 का मान 2 है
सरणी सूचकांक 2 का मान 3 है
सरणी सूचकांक 3 का मान 4 है
सरणी सूचकांक 4 का मान 5 है
सरणी सूचकांक 5 का मान 6 है
सरणी सूचकांक 6 का मान 7 है
सरणी सूचकांक 7 का मान 8 है
सरणी सूचकांक 8 का मान 9 है
सरणी सूचकांक 9 का मान 10 है
यहाँ, for () अभिव्यक्ति में, कई कथन शामिल हैं। उनमें से प्रत्येक का एक अर्थ है।
के लिए (आरंभीकरण; स्थिति; वृद्धि)
यहाँ for का उपयोग करने का एक और तरीका है।
for(1..10)
{
print "$_ n";
print "\n";
}
आउटपुट:
1n
2n
3n
4n
5n
6n
7n
8n
9n
10n
पर्ल फोरएच
प्रत्येक कथन के लिए उसी तरह उपयोग किया जा सकता है जैसे कि; मुख्य अंतर यह है कि इसमें हमारे पास कोई शर्त जांच और वृद्धि नहीं है।
आइये इसी उदाहरण को foreach perl के साथ लेते हैं।
my @array=(1..10);
foreach my $value (@array)
{
print " The value is $value\n";
}
आउटपुट:
मान 1 है
मान 2 है
मान 3 है
मान 4 है
मान 5 है
मान 6 है
मान 7 है
मान 8 है
मान 9 है
मान 10 है
Foreach एक सरणी के प्रत्येक तत्व को लेता है और प्रत्येक पुनरावृत्ति के लिए उस मान को $var को असाइन करता है। हम इसके लिए $_ का भी उपयोग कर सकते हैं।
my @array=(1..10);
foreach(@array)
{
print " The value is $_ \n"; # This is same as the above code.
}
आउटपुट:
मान 1 है
मान 2 है
मान 3 है
मान 4 है
मान 5 है
मान 6 है
मान 7 है
मान 8 है
मान 9 है
मान 10 है
यह ऐरे तक पहुँचने के लिए अच्छा लगता है। हैश के बारे में क्या, हम foreach का उपयोग करके हैश कुंजियाँ और मान कैसे प्राप्त कर सकते हैं?
हम लूपिंग द्वारा हैश की कुंजियों और मानों तक पहुंचने के लिए foreach का उपयोग कर सकते हैं।
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25);
foreach my $key (keys %hash)
{
print "$key \n";
}
आउटपुट:
मिकी
जिल्द
जेरी
आप सोच रहे होंगे कि हमने foreach() में Keys का इस्तेमाल क्यों किया। Keys Perl का एक इनबिल्ट फ़ंक्शन है, जहाँ हम हैश की कुंजियों तक जल्दी पहुँच सकते हैं। Values के बारे में क्या? हम हैश के मानों तक पहुँचने के लिए values फ़ंक्शन का उपयोग कर सकते हैं।
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25);
foreach my $value(values %hash) # This will push each value of the key to $value
{
print " the value is $value \n";
}
आउटपुट:
मान 24 है
मान 23 है
मान 25 है
पर्ल जबकि
पर्ल While लूप एक नियंत्रण संरचना है, जहां कोड ब्लॉक को तब तक निष्पादित किया जाएगा जब तक कि स्थिति सत्य है।
कोड ब्लॉक तभी बाहर निकलेगा जब शर्त गलत होगी।
आइये Perl While लूप का उदाहरण लेते हैं।
यहां एक समस्या है, जिसके लिए उपयोगकर्ता से इनपुट की आवश्यकता होगी और '7' के रूप में दी गई संख्या तक बाहर नहीं निकलेगा।
#!/usr/bin/perl
$guru99 = 0;
$luckynum = 7;
print "Guess a Number Between 1 and 10\n";
$guru99 = <STDIN>;
while ($guru99 != $luckynum)
{
print "Guess a Number Between 1 and 10 \n ";
$guru99 = <STDIN>;
}
print "You guessed the lucky number 7"
आउटपुट:
1 से 10 के बीच की संख्या का अनुमान लगाएं
9
1 से 10 के बीच की संख्या का अनुमान लगाएं
5
1 से 10 के बीच की संख्या का अनुमान लगाएं
7
आपने भाग्यशाली संख्या 7 का अनुमान लगा लिया है
उपरोक्त उदाहरण में, यदि हम '7' के अलावा कोई अन्य इनपुट दर्ज करते हैं तो while शर्त सत्य नहीं होगी।
यदि आप देखें कि यहाँ while कैसे काम करता है, तो कोड ब्लॉक केवल तभी निष्पादित होगा जब while में शर्त true होगी।
पर्ल डू-व्हाइल
Do while लूप कम से कम एक बार निष्पादित होगा, भले ही while अनुभाग में शर्त गलत हो।
आइए do while का उपयोग करके यही उदाहरण लें।
$guru99 = 10;
do {
print "$guru99 \n";
$guru99--;
}
while ($guru99 >= 1);
print "Now value is less than 1";
आउटपुट:
10
9
8
7
6
5
4
3
2
1
अब मान 1 से कम है
पर्ल तक
जब तक कोड ब्लॉक सशर्त कथन में जब तक के समान है। यहाँ, कोड ब्लॉक केवल तभी निष्पादित होगा जब जब तक ब्लॉक में शर्त गलत हो।
आइए हम वही उदाहरण लें जो हमने कुछ समय के मामले में इस्तेमाल किया था।
यहां एक समस्या है, जिसके लिए उपयोगकर्ता से इनपुट की आवश्यकता होगी और जब तक 'sai' के अलावा कोई अन्य नाम नहीं दिया जाता, तब तक यह समाप्त नहीं होगी।
print "Enter any name \n";
my $name=<STDIN>;
chomp($name);
until($name ne 'sai')
{
print "Enter any name \n";
$name=<STDIN>;
chomp($name);
}
आउटपुट:
कोई भी नाम दर्ज करें साई
पर्ल डू-अंटिल:
Do Until का प्रयोग केवल तभी किया जा सकता है जब हमें किसी शर्त को false करना हो, तथा इसे कम से कम एक बार निष्पादित किया जाना चाहिए।
print "Enter any name \n";
my $name=<STDIN>;
chomp($name);
do
{
print "Enter any name \n";
$name=<STDIN>;
chomp($name);
}until($name ne 'sai');
आउटपुट:
कोई भी नाम दर्ज करें हॉवर्ड
कोई भी नाम दर्ज करें शेल्डन
कोई भी नाम दर्ज करें साई
अंतर देखने के लिए while, do-while, Until और do-until उदाहरण कोड निष्पादित करें।
पर्ल Operaटो
एचएमबी क्या है? Operaटोर?
Operaकंप्यूटर भाषा में टॉर्स एक ऐसी क्रिया को इंगित करते हैं जो कुछ चर या मानों के सेट पर की जा सकती है जिसे कंप्यूटर समझ सकता है। पर्ल ने अधिकांश को शामिल किया है Operaसी भाषा से टोर। अन्य प्रोग्रामिंग भाषाओं की तुलना में पर्ल में कई ऑपरेटर हैं। Operaऑपरेटरों को अंकगणितीय, तार्किक, संबंधपरक और असाइनमेंट ऑपरेटरों के रूप में वर्गीकृत किया गया है।
अंकगणित Operaटोर्स:
अंकगणितीय ऑपरेटर वे होते हैं जिनका उपयोग कुछ बुनियादी गणितीय ऑपरेशन करने के लिए किया जा सकता है। ये अंकगणितीय ऑपरेटर बाइनरी ऑपरेटर होते हैं जहाँ हमें एक बुनियादी ऑपरेशन करने के लिए दो तर्कों की आवश्यकता होती है। हम अन्य बुनियादी ऑपरेशनों के लिए यूनेरी ऑपरेटर का भी उपयोग कर सकते हैं; आप नीचे दिए गए उदाहरणों में अंतर देख सकते हैं।
| Operaटो | विवरण | उदाहरण |
|---|---|---|
|
+ |
दो मानों या चरों को जोड़ने के लिए प्रयुक्त योग संक्रिया मान धारण करना |
$x=5+6; # या $y=6; $z=$x+$y; |
|
- |
घटाव ऑपरेटर का उपयोग दो मानों या मान रखने वाले चरों को घटाने के लिए किया जाता है |
$x=6-5; # या $y=6; $z=$x-$y; |
|
* |
गुणन ऑपरेटर का उपयोग दो मानों या मान रखने वाले चरों को गुणा करने के लिए किया जाता है |
$x=6*5; # या $y=6; $z=$x*$y; |
|
/ |
विभाजन ऑपरेटर का उपयोग दो मानों या मान रखने वाले चरों को विभाजित करने के लिए किया जाता है |
$x=36/6; # या $y=6; $z=$x/$y; |
|
** |
घातांकीय ऑपरेटर का उपयोग घातांक प्रदान करने और मान प्राप्त करने के लिए किया जाता है। उदाहरण : 22 = 4, 33 = 27 |
$x=5**5; # या $x=4; $y=2; $z=$x**$y; |
|
% |
मापांक ऑपरेटर का उपयोग दो मानों या मान रखने वाले चरों के विभाजन के दौरान अनुस्मारक प्राप्त करने के लिए किया जाता है |
$x=5%2; # या $x=10; $y=2; $z=$x % $y; |
|
++ |
किसी चर के मान में 1 की वृद्धि करने के लिए एकल योग ऑपरेटर |
$x=5; $x++; Or ++$x; |
|
- |
एक चर के मान को 1 से घटाने के लिए एकल घटाव ऑपरेटर |
$x=5; $x–; # पोस्ट कमी Or –$x;# पूर्व कमी |
उपरोक्त सभी कार्यों को पूरा करने के लिए उदाहरण.
my $x=10;
my $y=2;
my $z;
$z=$x+$y;
print ("Add of $x and $y is $z \n");
$z=$x-$y;
print ("Sub of $x and $y is $z \n");
$z=$x*$y;
print ("Mul of $x and $y is $z \n");
$z=$x/$y;
print ("Div of $x and $y is $z \n");
$z=$x**$y;
print ("Exp of $x and $y is $z \n");
$z=$x%$y;
print ("Mod of $x and $y is $z \n");
आउटपुट:
10 और 2 का योग 12 है
10 और 2 का उप 8 है
10 और 2 का गुणनफल 20 है
10 और 2 का भाग 5 है
10 और 2 का एक्सप 100 है
10 और 2 का मॉड 0 है
असाइनमेंट Operaटोर्स:
असाइनमेंट ऑपरेटर केवल वेरिएबल्स को मान असाइन करते हैं, लेकिन एक और बात है जिसे हमें यहां याद रखने की आवश्यकता है, असाइनमेंट ऑपरेटर अंकगणितीय ऑपरेशन भी करेंगे और उसी वेरिएबल को नया मान असाइन करेंगे जिस पर ऑपरेशन किया जाता है।
| Operaटो | विवरण | उदाहरण |
|---|---|---|
|
+= |
जोड़ ऑपरेटर का उपयोग समान चर को जोड़ने और उसमें मान निर्दिष्ट करने के लिए किया जाता है |
$x=4; $x+=10; |
|
-= |
घटाव ऑपरेटर का उपयोग समान चर को घटाने और मान निर्दिष्ट करने के लिए किया जाता है |
$x=4; $x-=10; |
|
*= |
गुणन ऑपरेटर का उपयोग समान चर को जोड़ने और मान निर्दिष्ट करने के लिए किया जाता है |
$x=4; $x*=10; |
|
/= |
विभाजन ऑपरेटर का उपयोग समान चर को विभाजित करने और मान निर्दिष्ट करने के लिए किया जाता है |
$x=4; $x/=10; |
|
**= |
घातांक प्राप्त करने और उसी चर को मान निर्दिष्ट करने के लिए घातांकीय ऑपरेटर का उपयोग किया जाता है |
$x=4; $x**=10; |
|
%= |
विभाजन के दौरान अनुस्मारक प्राप्त करने और उसी चर को मान निर्दिष्ट करने के लिए प्रयुक्त मापांक ऑपरेटर |
$x=10; $x%=4; |
उपरोक्त सभी कार्यों को पूरा करने के लिए उदाहरण.
my $x=10;
$x+=5;
print("Add = $x\n");
$x-=5;
print("Sub= $x\n");
$x*=5;
print("Mul = $x\n");
$x/=5;
print("Div = $x\n");
आउटपुट:
जोड़ें = 15
उप= 10
मूल = 50
डिव = १०
तार्किक और संबंधपरक Operaटोर्स:
पर्ल संख्याओं और स्ट्रिंग्स की तुलना करने के लिए तार्किक ऑपरेटरों का उपयोग करता है। ज़्यादातर समय तार्किक ऑपरेटरों का उपयोग कंडीशनल स्टेटमेंट्स में किया जाता है।
तार्किक और संबंधपरक Operaपर्ल में tors
| Operaटो | विवरण |
|---|---|
|
==या समतुल्य |
Operaटोर का उपयोग यह जाँचने के लिए किया जाता है कि क्या दोनों चर समान हैं |
|
!=या ne |
Operaटोर का उपयोग यह जांचने के लिए किया जाता है कि क्या दोनों चर समान नहीं हैं |
|
> या जीटी |
Operaटोर का उपयोग यह जाँचने के लिए किया जाता है कि A, B से बड़ा है |
|
<or lt |
Operaटोर का उपयोग यह जाँचने के लिए किया जाता है कि A, B से कम है |
|
>=या जीई |
Operaटोर का उपयोग यह जाँचने के लिए किया जाता है कि A, B . से बड़ा या उसके बराबर है |
|
<=या ले |
Operaटोर का उपयोग यह जाँचने के लिए किया जाता है कि A, B से कम या बराबर है |
|
|| या या |
Operaटॉर का उपयोग यह जांचने के लिए किया जाता है कि A या B में से कोई एक मान धारण कर रहा है |
|
&&या और |
Operaटॉर का उपयोग यह जांचने के लिए किया जाता है कि A और B दोनों मान धारण कर रहे हैं |
आइये एक उदाहरण लेते हैं जहां हम सभी परिदृश्यों को समझा सकते हैं।
my $x=5;
my $y=5;
if($x == $y){
print ("True -- equal $x and $y \n");
}
else{
print ("False -- not equal $x and $y\n");
}
$x=6;
$y=7;
if($x != $y){
print ("True -- not equal $x and $y\n");
}
else{
print ("False -- equal $x and $y\n");
}
if($y > $x){
print ("True -- $y greater than $x\n");
}
else{
print ("False -- $y greater than $x\n");
}
if($x < $y){
print ("True -- $x less than $y\n");
}
else{
print ("False -- $x less than $y\n");
}
if($x <= $y){
print ("True -- $x less than $y\n");
}
else{
print ("False -- $x less than $y\n");
}
if($y >= $x){
print ("True -- $y greater than $x\n");
}
else{
print ("False -- $y greater than $x\n");
}
आउटपुट:
सत्य — 5 और 5 के बराबर
सत्य - 6 और 7 बराबर नहीं
सत्य - 7 से 6 बड़ा
सत्य - 6 से 7 कम
सत्य - 6 से 7 कम
सत्य - 7 से 6 बड़ा
आप बाद के अनुभागों में तार्किक ऑपरेटरों के उदाहरण देख सकते हैं।
पर्ल विशेष चर
पर्ल स्पेशल वेरिएबल्स क्या है?
पर्ल में विशेष चर वे होते हैं जिनका कुछ पूर्वनिर्धारित अर्थ होता है। इन चरों को वास्तविक नाम या विराम चिह्नों से दर्शाया जाता है। हमारे पास सभी पर्ल समर्थित चर जैसे स्केलर विशेष चर, ऐरे विशेष चर, हैश विशेष चर के लिए एक विशेष चर है। हमारे द्वारा उपयोग किए जाने वाले अधिकांश विशेष चर स्केलर के होते हैं।
जब हम किसी विशेष चर को उसके नाम के साथ प्रयोग करना चाहते हैं, तो हमें पर्ल मॉड्यूल 'use English' लोड करना पड़ता है, ताकि पर्ल इंटरप्रेटर को स्पष्ट रूप से बताया जा सके कि हम विशेष चर को उसके नाम के साथ प्रयोग करने जा रहे हैं।
स्केलर विशेष चर
| परिवर्तनीय | विवरण |
|---|---|
|
$_$एआरजी |
यह डिफ़ॉल्ट वेरिएबल है जो वर्तमान मानों को संग्रहीत करता है। |
|
$0 या $PROGRAM_NAME |
पर्ल स्क्रिप्ट का फ़ाइल नाम संग्रहीत करता है। |
|
$/ |
इनपुट रिकॉर्ड विभाजक, इसका डिफ़ॉल्ट मान '\n' है जो कि न्यूलाइन वर्ण है |
|
$. |
पढ़ी जा रही फ़ाइल की वर्तमान पंक्ति संख्या रखता है |
|
$, |
आउटपुट फ़ील्ड विभाजक, यह मुख्य रूप से print() कथन द्वारा उपयोग किया जाता है। डिफ़ॉल्ट रूप से इसका मान 0 पर सेट है, हम इस चर का मान बदल सकते हैं। |
|
$\ |
आउटपुट रिकॉर्ड विभाजक, इस चर का मान रिक्त होगा; हम इसे कोई भी मान दे सकते हैं, जिसका उपयोग आउटपुट प्रिंट करते समय print() कथन द्वारा किया जाएगा। |
|
$# |
इस वेरिएबल का उपयोग संख्याओं को प्रिंट करते समय आउटपुट फॉर्मेट के लिए किया जाता है। |
|
$%$FORMAT_PAGE_NUMBER |
पढ़ी गई फ़ाइल की वर्तमान पृष्ठ संख्या रखेगा। |
|
$=$FORMAT_LINES_PER_PAGE |
पढ़ी गई फ़ाइल की वर्तमान पृष्ठ लंबाई को धारण करेगा। |
|
$-$FORMAT_LINES_LEFT |
पृष्ठ से प्रिंट करने के लिए शेष पंक्तियों की संख्या का मान रखता है। |
|
$~$FORMAT_NAME |
प्रारूप नाम: डिफ़ॉल्ट रूप से फ़ाइल हैंडल नाम द्वारा वर्तमान में चयनित आउटपुट का प्रारूप रखता है। |
|
$^$FORMAT_TOP_NAME |
फ़ाइल हैंडलर के शीर्षक प्रारूप का मान रखता है, डिफ़ॉल्ट मान _TOP होगा जिसके बाद फ़ाइल हैंडल नाम होगा। |
|
$|$आउटपुट_ऑटोफ्लश |
डिफ़ॉल्ट शून्य है; इसका उपयोग प्रत्येक write() या print() के बाद आउटपुट बफर को फ्लश करने के लिए किया जाता है। |
|
$$ |
पर्ल इंटरप्रेटर की चल रही प्रक्रिया संख्या को धारण करेगा। |
|
$? |
स्थिति कोड : पाइप और सिस्टम कॉल। निष्पादित कमांड की वापसी स्थिति। |
|
$&$मैच |
नियमित अभिव्यक्तियों में प्रयुक्त होने पर, यह अंतिम सफल पैटर्न मिलान की एक स्ट्रिंग रखेगा। |
|
$`$प्रीमैच |
नियमित अभिव्यक्तियों में प्रयुक्त, यह अंतिम सफल पैटर्न मिलान से पहले की स्ट्रिंग को धारण करेगा। |
|
$'$पोस्टमैच |
नियमित अभिव्यक्तियों में प्रयुक्त होने पर, यह एक स्ट्रिंग रखेगा जिसके बाद अंतिम सफल पैटर्न मिलान होगा। |
|
$+$अंतिम_पैरेन_मैच |
अंतिम ब्रैकेट की स्ट्रिंग को रखता है जो अंतिम पैटर्न खोज से मेल खाती है। |
|
$ |
$1, $2, $3 …. मिलान किए गए पैटर्न के मानों को क्रम में रखता है। |
|
$[ |
प्रथम सूचकांक: सारणी, एक उपस्ट्रिंग. |
|
$] |
पर्ल का एक संस्करण. |
|
$" |
सूची तत्वों के लिए प्रयुक्त विभाजक, डिफ़ॉल्ट मान के रूप में रिक्त स्थान होता है। |
|
$; |
बहु-आयामी सरणियों में प्रयुक्त सबस्क्रिप्ट विभाजक |
|
$! |
संख्यात्मक संदर्भ में, त्रुटि संख्या प्रिंट करता है। स्ट्रिंग संदर्भ में, त्रुटि प्रिंट करता है। |
|
$@ |
जब eval() का उपयोग किया जाता है तो वाक्यविन्यास त्रुटि जानकारी रखी जाएगी। |
|
$< |
स्क्रिप्ट चलाने वाली प्रक्रिया का वास्तविक UID (उपयोगकर्ता आईडी) रखता है। |
|
$> |
स्क्रिप्ट चलाने वाली प्रक्रिया का प्रभावी UID रखता है। |
|
$( |
स्क्रिप्ट चलाने वाली प्रक्रिया की वास्तविक GID (समूह आईडी) रखता है। |
|
$) |
स्क्रिप्ट चलाने वाली प्रक्रिया का प्रभावी GID रखता है। |
|
$^D$डीबगिंग |
डिबगिंग फ़्लैग का वर्तमान मान रखता है. |
|
$^सी |
जब –c कमांड लाइन स्विच का उपयोग किया जाता है तो ध्वज का वर्तमान मान रखता है। |
|
$^एफ |
अधिकतम सिस्टम फ़ाइल डिस्क्रिप्टर, डिफ़ॉल्ट मान द्वारा, 2 पर सेट है |
|
$^I$INPLACE_EDIT |
–i कमांड लाइन स्विच का मान रखता है। |
|
$^एम |
विशेष मेमोरी पूल का उपयोग तब किया जा सकता है जब पर्ल स्क्रिप्ट आउट-ऑफ मेमोरी त्रुटि के साथ समाप्त हो जाती है। |
|
$^O$OSनाम |
Operating सिस्टम जानकारी संग्रहीत है। Linux सिस्टम के लिए 'Linux', Windows सिस्टम. |
|
$^T$बेसटाइम |
स्क्रिप्ट चलने का समय (सेकंड में) |
|
$^W$चेतावनी |
–w कमांड लाइन स्विच का वर्तमान मान. चेतावनी स्विच. |
|
$एआरजीवी |
वर्तमान फ़ाइल का नाम, जब <> का उपयोग किया जाता है. |
सरणी विशेष चर:
| परिवर्तनीय | विवरण |
|---|---|
|
@आईएनसी |
पथों की एक सूची रखता है, जहाँ पर्ल लाइब्रेरी मॉड्यूल या स्क्रिप्ट को वर्तमान स्क्रिप्ट निष्पादित करते समय देखा जा सकता है। इस @INC का उपयोग use और require कथनों द्वारा लाइब्रेरी मॉड्यूल के लिए उन पथों को देखने के लिए किया जाता है। |
|
@ARGV |
पारित कमांड लाइन तर्कों को संग्रहीत करता है। |
|
@_ |
सबरूटीन्स में पैरामीटर्स पास करते समय इसका उपयोग किया जाता है। |
|
@F |
यह वह सारणी है जिसमें इनपुट लाइनें संग्रहीत की जाती हैं जब ऑटो स्प्लिट –a (कमांड लाइन स्विच का उपयोग किया जाता है)। |
हैश विशेष चर:
| परिवर्तनीय | विवरण |
|---|---|
|
%आईएनसी |
फ़ाइल नाम कुंजियाँ होंगी; मान उन फ़ाइलों का पथ होगा। do, use और require द्वारा उपयोग किया जाता है। |
|
% ईएनवी |
सिस्टम पर्यावरण चर. |
|
%एसआईजी |
Signalके हैंडलर. |
पर्ल नियमित अभिव्यक्ति
नियमित अभिव्यक्ति क्या है?
पर्ल रेगुलर एक्सप्रेशन किसी कथन या कथनों के समूह के भीतर स्ट्रिंग पैटर्न का मिलान करने में काफी मजबूत है। रेगुलर एक्सप्रेशन का उपयोग ज्यादातर टेक्स्ट पार्सिंग, पैटर्न मैचिंग और आवश्यकता के आधार पर बहुत कुछ में किया जाता है। हमारे पास कुछ ऑपरेटर हैं, जो विशेष रूप से रेगुलर एक्सप्रेशन पैटर्न बाइंडिंग =~ और !~ द्वारा उपयोग किए जाते हैं, ये टेस्ट और असाइनमेंट ऑपरेटर हैं।
नियमित अभिव्यक्ति Operaमरोड़
नियमित अभिव्यक्ति Operaपर्ल में tors
- पर्ल मैच — m//
- पर्ल स्थानापन्न – s///
- पर्ल ट्रांसलिटरेट – tr///
आगे बढ़ने से पहले, हमें नियमित अभिव्यक्ति के बारे में कुछ बातें जानने की जरूरत है; पर्ल रेगेक्स सिंटैक्स में मेटा कैरेक्टर, वाइल्डकार्ड जैसी कुछ चीजें हैं।
| चार | अर्थ |
|---|---|
|
\ |
विशेष या उद्धरण |
|
* |
0 या अधिक वर्णों का मिलान करें |
|
+ |
1 या अधिक वर्णों का मिलान करें |
|
? |
0 या 1 अक्षर का मिलान करें |
|
| |
वैकल्पिक पैटर्न से मिलान करने के लिए इस्तेमाल किया जा सकता है |
|
() |
मिलान किए गए पैटर्न को संग्रहीत करने के लिए उपयोग किया जाता है |
|
[] |
वर्णों का सेट पास किया जा सकता है। विशेष रूप से संख्यात्मक और वर्णमाला के लिए उपयोग किया जाता है। |
|
{} |
मैच कितने समय तक खेला जा सकता है, यह बताने के लिए इसका उपयोग किया जाता है। |
|
^ |
स्ट्रिंग की शुरुआत |
|
$ |
स्ट्रिंग का अंत |
|
\w |
किसी एकल वर्ण या शब्द से मिलान करने के लिए उपयोग किया जाता है जो “_” सहित अल्फ़ान्यूमेरिक हो सकता है |
|
\W |
अल्फ़ान्यूमेरिक के अलावा किसी भी चीज़ का मिलान करें |
|
\s |
रिक्त स्थानों का मिलान करने के लिए उपयोग किया जाता है |
|
\S |
रिक्त स्थान के अलावा किसी भी चीज़ से मिलान करें |
|
\d |
संख्याओं का मिलान करें। दशमलव मान और ऋणात्मक मान नहीं |
|
\D |
संख्याओं के अलावा किसी भी चीज़ का मिलान करें. |
|
\t |
टैब स्पेस का मिलान करें |
|
\n |
नई लाइन का मिलान करें |
उपरोक्त वर्णों का समूह है जिसका उपयोग पैटर्न मिलान के दौरान किया जा सकता है।
आइये कुछ उदाहरण देखें.
एक ऐसी स्थिति पर विचार करें जहाँ उपयोगकर्ता स्क्रिप्ट निष्पादन के दौरान कुछ इनपुट प्रदान करता है, और हम यह जाँचना चाहते हैं कि उपयोगकर्ता ने इनपुट के रूप में कोई नाम दर्ज किया है या नहीं। हमें आपका नाम निकालने और उसे प्रिंट करने के लिए एक रेगुलर एक्सप्रेशन सिंटैक्स लिखना होगा।
my $userinput="Guru99 Rocks";
if($userinput=~m/.*(Guru99).*/)
{
print "Found Pattern";
}
else
{
print "unable to find the pattern";
}
आउटपुट:
पाया गया पैटर्न
यहाँ, हमने नियमित अभिव्यक्ति को /.*(Guru99).*/.* के रूप में लिखा है जो स्ट्रिंग में सभी वर्णों से मेल खाता है। पर्ल रेगेक्स मैच में '.' स्पेस सहित किसी भी वर्ण को संदर्भित करता है।
आइये देखें कि हम Regex का निर्माण कैसे कर सकते हैं।
कई शब्दों और अंकों और विशेष प्रतीकों की एक स्ट्रिंग के उदाहरण पर विचार करें जैसे “सभी को नमस्कार यह मेरा नंबर है: +91-99298373639”;
रेगेक्स : /^\w+\s\w+\s\w+\s\w+\s\w+\s\w+\s\w+\:\+\d+\-\d+/i
शब्द स्थान शब्द स्थान शब्द स्थान शब्द स्थान शब्द स्थान शब्द स्थान विशेष वर्ण: स्थान विशेष वर्ण+अंक विशेष वर्ण-अंक।
पर्ल मैच Operaमरोड़
मैच ऑपरेटर का उपयोग किसी कथन या वेरिएबल में स्ट्रिंग का मिलान करने के लिए किया जाता है।
my $var="Hello this is perl";
if($var=~m/perl/)
{
print "true";
}
else
{
print "False";
}
आउटपुट:
<strong>उद्देश्य</strong>
यह छोटा कोड 'सत्य' प्रिंट करेगा, क्योंकि पर्ल पैटर्न मिलान एक चर में स्ट्रिंग की पहचान करता है। मूल रूप से, पर्ल स्ट्रिंग में // में दिए गए पाठ की खोज करता है, भले ही वह एक स्थान पर मिल जाए, यह 'सत्य' लौटाएगा। पैटर्न चर में कहीं भी हो सकता है। हम उन दो ऑपरेटरों के बीच अंतर देखने के लिए =~ को !~ से बदलने का प्रयास कर सकते हैं।
पर्ल प्रतिस्थापन Operaटो
इस ऑपरेटर का उपयोग किसी भी वर्ण को खोजने और उसे शून्य या किसी अन्य वर्ण से बदलने के लिए किया जा सकता है।
my $a="Hello how are you"; $a=~s/hello/cello/gi; print $a;
आउटपुट:
सेलो आप कैसे हैं?
नोट: हम वास्तव में किसी भी पैटर्न मिलान स्ट्रिंग का उपयोग कर सकते हैं जैसा कि हमने पहले इस प्रतिस्थापन ऑपरेटर में भी किया था। यहाँ हमने 'gi', g-globally, i-ignore केस का उपयोग किया है।
पर्ल अनुवाद Operaटो
यह प्रतिस्थापन के समान है, लेकिन इसमें किसी भी पर्ल नियमित अभिव्यक्ति का उपयोग नहीं किया जाता है, बल्कि हम सीधे उस मान या शब्द को पास कर सकते हैं जिसे हम प्रतिस्थापित करना चाहते हैं।
my $a="Hello how are you"; $a=~tr/hello/cello/; print $a;
आउटपुट:
हेलो गाय क्या आप
पर्ल फ़ाइल I/O
पर्ल को फ़ाइलों और I/O संचालन को प्रभावी ढंग से संचालित करने के लिए डिज़ाइन किया गया था। पर्ल का मुख्य लाभ फ़ाइल पार्सिंग और फ़ाइलों को संभालने में है। पर्ल में फ़ाइल हैंडलिंग के दौरान कई इनबिल्ट फ़ंक्शन और ऑपरेटर का उपयोग किया जाता है।
मूलतः, Perl के साथ निष्पादित फ़ाइल संचालन FILEHANDLE का उपयोग करके किया जाता है। हमें पढ़ने या लिखने के लिए फ़ाइल खोलते समय इस FILEHANDLE को परिभाषित करना होता है।
इस पर्ल स्क्रिप्ट ट्यूटोरियल में, आप सीखेंगे-
पर्ल फ़ाइल खोलें
हम Perl में उपलब्ध open() फ़ंक्शन का उपयोग करके फ़ाइल खोल सकते हैं।
open(FILEHANDLE, "filename or complete path of the file");
अब हमने एक फाइल खोली है, अब सवाल उठता है कि यह पढ़ने के लिए है या लिखने के लिए?
पर्ल रीड फ़ाइल और पर्ल राइट फ़ाइल
पर्ल में कुछ निश्चित मोड होते हैं, जिनका उपयोग फ़ाइल को पढ़ने, लिखने या जोड़ने के लिए किया जाता है।
Read – open(my $fh,"<filename or complete path of the file"); Write – open(my $fh,">filename or complete path of the file"); Append – open(my $fh,">>filename or complete path of the file");
फ़ाइल पढ़ने के कुछ उदाहरण:
मान लीजिए हमारे पास file.txt नाम की एक पर्ल फ़ाइल है और इसमें कुछ पंक्तियाँ हैं। हमें इस फ़ाइल को खोलना है और इसे प्रिंट करना है।
open(FH,"<file.txt");
while(<FH>) # Looping the file contents using the FH as a filehandle.
{
print "$_";
}
close FH;
or
open(FH,"<file.txt");
my @content=<FH>; # specifying the input of the array is FH.
foreach(@content)
{
print "$_";
}
close FH;
इससे फ़ाइल की सामग्री आउटपुट स्क्रीन पर प्रिंट हो जाएगी।
अब, हम एक पर्ल फ़ाइल बनाने और उसमें डेटा लिखने के लिए एक प्रोग्राम लिखेंगे।
open(FH,">test.txt"); my $var=<>; print FH $var; close FH;
यह रन-टाइम के दौरान दिए गए इनपुट को लिखेगा और एक फ़ाइल test.txt बनाएगा जिसमें इनपुट होगा।
उपरोक्त तरीका हमेशा test.txt नामक एक फ़ाइल बनाने का प्रयास करेगा और फ़ाइल में इनपुट लिखेगा; हम फ़ाइल को जोड़ने के लिए भी यही लिखेंगे।
open(FH,">>test.txt"); my $var=<>; print FH $var; close FH;
| मोड | विवरण |
|---|---|
|
< |
पढ़ना |
|
+< |
पढ़ता और लिखता है |
|
> |
बनाता है, लिखता है और काटता है |
|
+> |
पढ़ें, लिखें, बनाएं और काटें |
|
>> |
लिखता है, जोड़ता है और बनाता है |
|
+>> |
पढ़ें, लिखें, जोड़ें और बनाएं |
अब हमें यह देखना है कि बुनियादी उदाहरणों का उपयोग करके फ़ाइलों को कैसे पढ़ा, लिखा और जोड़ा जाए।
हम कुछ और उदाहरण और अन्य फ़ंक्शन देखेंगे जो फ़ाइलों के बारे में अधिक समझने में मदद करेंगे।
पर्ल बताओ
यदि निर्दिष्ट किया गया है तो यह विधि FILEHANDLER की वर्तमान स्थिति बाइट्स में लौटाएगी, अन्यथा यह अंतिम पंक्ति को स्थिति मान लेगी।
open(FH, "test.pl");
while(<FH>)
{
$a=tell FH;
print "$a";
}
पर्ल सीक
Seek फ़ंक्शन fseek सिस्टम कॉल के समान है। इस विधि का उपयोग फ़ाइल पॉइंटर को फ़ाइल पॉइंटर के आरंभ या फ़ाइल पॉइंटर के अंत के बाद बाइट्स निर्दिष्ट करके किसी विशिष्ट स्थान पर रखने के लिए किया जाता है।
seek FH, bytes, WHENCE;
WHENCE फ़ाइल पॉइंटर की आरंभिक स्थिति है। शून्य इसे फ़ाइल की शुरुआत से सेट करेगा।
उदाहरण: मान लें input.txt में कुछ डेटा है जैसे “नमस्ते यह मेरी दुनिया है।”
open FH, '+<','input.txt'; seek FH, 5, 0; # This will start reading data after 5 bytes. $/ = undef; $out = <FH>; print $out; close FH;
आउटपुट:
ये मेरी दुनिया है
पर्ल अनलिंक
अनलिंक का उपयोग फ़ाइल को हटाने के लिए किया जाता है।
unlink("filename or complete file path");
निर्देशिकाओं का प्रबंधन:
हम निर्देशिकाओं को भी संभाल सकते हैं जिसके माध्यम से हम एकाधिक फ़ाइलों को संभाल सकते हैं।
आइए देखें कि डायरेक्टरी कैसे खोलें। हम opendir और readdir विधियों का उपयोग कर सकते हैं।
opendir(DIR,"C:\\Program Files\\"); #DIR is the directory handler.
while(readdir(DIR)) # loop through the output of readdir to print the directory contents.
{
print "$_\n";
}
closedir(DIR); #used to close the directory handler.
or
opendir(DIR,"C:\\Program Files\\");
@content=readdir(DIR);
foreach(@content)
{
print "$_\n";
}
closedir(DIR);
इससे उस निर्देशिका में उपलब्ध सभी फ़ाइलें प्रिंट हो जाएंगी।
पर्ल फ़ाइल परीक्षण और उनका अर्थ
|
-r |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका वर्तमान उपयोगकर्ता/समूह द्वारा पढ़ी जा सकती है |
|
-w |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका वर्तमान उपयोगकर्ता/समूह द्वारा लिखने योग्य है |
|
-x |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका वर्तमान उपयोगकर्ता/समूह द्वारा निष्पादन योग्य है |
|
-o |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका का स्वामित्व वर्तमान उपयोगकर्ता के पास है |
|
-R |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका इस वास्तविक उपयोगकर्ता/समूह द्वारा पढ़ी जा सकती है |
|
-W |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका इस वास्तविक उपयोगकर्ता/समूह द्वारा लिखने योग्य है |
|
-X |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका इस वास्तविक उपयोगकर्ता/समूह द्वारा निष्पादन योग्य है |
|
-O |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका का स्वामित्व इस वास्तविक उपयोगकर्ता के पास है |
|
-e |
यह जाँचने के लिए कि क्या फ़ाइल/निर्देशिका नाम मौजूद है |
|
-z |
यह जाँचने के लिए कि क्या फ़ाइल मौजूद है और उसका आकार शून्य है (निर्देशिकाओं के लिए हमेशा गलत) |
|
-f |
यह जाँचने के लिए कि क्या Entry एक साधारण फ़ाइल है |
|
-d |
यह जाँचने के लिए कि क्या प्रविष्टि एक निर्देशिका है |
|
-l |
यह जाँचने के लिए कि क्या प्रविष्टि एक प्रतीकात्मक लिंक है |
|
-S |
यह जाँचने के लिए कि क्या Entry एक सॉकेट है |
|
-p |
यह जाँचने के लिए कि क्या Entry एक नामित पाइप (एक “FIFO”) है |
|
-b |
यह जांचने के लिए कि क्या एंट्री एक ब्लॉक विशेष फ़ाइल है (जैसे माउंटेबल डिस्क) |
|
-c |
यह जांचने के लिए कि क्या Entry एक वर्ण विशेष फ़ाइल है (जैसे I/O डिवाइस) |
|
-u |
यह जाँचने के लिए कि क्या फ़ाइल या निर्देशिका setuid है |
|
-g |
यह जाँचने के लिए कि क्या फ़ाइल या निर्देशिका setgid है |
|
-k |
यह जाँचने के लिए कि क्या फ़ाइल या निर्देशिका में स्टिकी बिट सेट है |
|
-t |
दिया गया फ़ाइलहैंडिल एक TTY है (जैसा कि isatty() सिस्टम फ़ंक्शन द्वारा, फ़ाइलनामों का इस परीक्षण द्वारा परीक्षण नहीं किया जा सकता है) |
|
-T |
यह जाँचने के लिए कि क्या फ़ाइल “टेक्स्ट” फ़ाइल जैसी दिखती है |
|
-B |
यह जाँचने के लिए कि क्या फ़ाइल “बाइनरी” फ़ाइल जैसी दिखती है |
|
-M |
फ़ाइल की संशोधन आयु (दिनों में मापी गई) की जांच करने के लिए |
|
-A |
फ़ाइल की एक्सेस आयु (दिनों में मापी गई) जाँचने के लिए |
|
-C |
फ़ाइल की इनोड-संशोधन आयु (दिनों में मापी गई) की जांच करने के लिए |
पर्ल सबरूटीन
सबरूटीन क्या है?
सबरूटीन्स अन्य प्रोग्रामिंग भाषाओं में फ़ंक्शन के समान हैं। हमने पहले से ही प्रिंट, चॉम्प, चॉप आदि जैसे कुछ अंतर्निहित फ़ंक्शन का उपयोग किया है। हम पर्ल में अपने स्वयं के सबरूटीन लिख सकते हैं। इन सबरूटीन को प्रोग्राम में कहीं भी लिखा जा सकता है; सबरूटीन को कोड की शुरुआत या अंत में रखना बेहतर होता है।
सबरूटीन्स उदाहरण
sub subroutine_name
{
Statements…; # this is how typical subroutines look like.
}
अब जब हम जानते हैं कि सबरूटीन कैसे लिखा जाता है, तो हम उस तक कैसे पहुंचें?
हमें सबरूटीन तक पहुंचने या कॉल करने के लिए '&' चिन्ह से उपसर्गित सबरूटीन नाम का उपयोग करना होगा।
sub display
{
print "this is a subroutine";
}
display(); # This is how we call a subroutine
पर्ल पैरामीटर्स और पर्ल तर्क पास करना
सबरूटीन या पर्ल फ़ंक्शन को इसमें पुन: प्रयोज्य कोड रखने के लिए लिखा जाता है। अधिकांश पुन: प्रयोज्य कोड को सबरूटीन में पैरामीटर पास करने की आवश्यकता होती है। यहाँ, हम सीखेंगे कि हम सबरूटीन में तर्क कैसे पास कर सकते हैं।
sub display
{
my $var=@_; # @_ is a special variable which stores the list of arguments passed.
print "$var is the value passed";
}
display(2,3,4); #this is how we need to pass the arguments.
आउटपुट:
3 पारित मूल्य है
@_ एक विशेष ऐरे वैरिएबल है जो सबरूटीन्स को दिए गए तर्कों को संग्रहीत करता है।
पर्ल Shift
हम 'shift' कीवर्ड का भी उपयोग कर सकते हैं जो एक समय में एक पैरामीटर को एक चर या $_[0],$_[1]… पर स्थानांतरित करता है जो @_ सरणी का एक व्यक्तिगत तत्व है
sub display
{
my $var=shift;
print "$var is passed";
}
display("hello");
आउटपुट:
नमस्ते बीत गया
सबरूटीन्स का उपयोग आमतौर पर ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में किया जाता है, तथा उन स्थानों पर भी किया जाता है, जहां आपके पास रखने के लिए अधिक पुन: प्रयोज्य कोड हो।
सबरूटीन्स की मुख्य कार्यक्षमता कुछ कार्य करना और पुन: प्रयोज्य कोड का परिणाम लौटाना है।
हम return कीवर्ड का उपयोग करके सबरूटीन से मान लौटा सकते हैं।
sub add
{
my $a=shift;
my $b=shift;
return($a+$b);
}
my $result=add(5,6);
print $result;
आउटपुट:
11
$result में जोड़े गए $a और $b का मान रहेगा।
हम हैश और ऐरे को सीधे सबरूटीन में भी पास कर सकते हैं।
sub hash
{
my %hash=@_;
print %hash;
}
%value= ( 1=>'a', 2=>'b');
&hash(%value);
आउटपुट:
1a2b
हम हैश या ऐरे भी लौटा सकते हैं।
sub hashArray
{
my %hash=@_;
print "Inside Sub-routine";
print %hash;
return(%hash);
}
%hash=(1=>'a', 2=>'b');
my(@ret)=hashArray(%hash);
print "After Sub-routine call";
print @ret;
आउटपुट:
सब-रूटीन2b1a के अंदरसब-रूटीन कॉल2b1a के बाद
पर्ल प्रारूप
पर्ल में एक तंत्र है जिसका उपयोग करके हम रिपोर्ट तैयार कर सकते हैं। इस सुविधा का उपयोग करके, हम आउटपुट स्क्रीन पर या फ़ाइल में प्रिंट करते समय रिपोर्ट को बिल्कुल वैसा ही बना सकते हैं जैसा हम चाहते हैं। पर्ल में उपलब्ध printf या sprintf फ़ंक्शन का उपयोग करके एक सरल प्रारूप लिखा जा सकता है।
printf "%05d\n", 30;
इसमें संख्या 30 के आगे शून्य लगाने से अंकों की कुल संख्या 5 हो जाएगी। इसका उपयोग sprintf के लिए भी किया जा सकता है।
sprintf "%05d\n", 30; # This will print the same as printf.
प्रिंटफ़ और स्प्रिंटफ़ का उपयोग करके, हम अधिकांश पर्ल प्रारूप प्राप्त कर सकते हैं। रिपोर्ट के मामले में, इसे लागू करना मुश्किल होगा।
================================================== =========================
नाम पता आयु फ़ोन
================================================== =========================
Krishna चेन्नई 24 929309242
श्रुति चेन्नई 24 929309232
ऊपर दी गई रिपोर्ट का एक उदाहरण है जिसे हमें Perl में उसी तरीके से प्रिंट करना होगा। इसे perl printf और perl sprintf का उपयोग करके प्राप्त किया जा सकता है। इसे format का उपयोग करके प्रभावी ढंग से लागू किया जा सकता है।
प्रारूप नीचे दिए गए तरीके से घोषित किया जा सकता है।
format FORMATNAME=FORMATLIST.
यहां, हम डेटा को आउटपुट स्क्रीन पर या फ़ाइल में प्रिंट करने के लिए एक विशेष विधि write का उपयोग करेंगे।
| चिन्ह | विवरण |
|---|---|
|
@ |
फ़ील्ड होल्डर की शुरुआत को दर्शाने के लिए उपयोग किया जाता है |
|
> |
पाठ का दायाँ संरेखण |
|
< |
पाठ का बायाँ संरेखण |
|
| |
केंद्र संरेखण |
|
# |
यदि एक से अधिक # दिए गए हों तो संख्यात्मक। यदि एक # दिया गया हो तो टिप्पणी के रूप में मान लिया जाता है |
|
. |
दशमलव बिंदु |
|
^ |
फ़ील्ड होल्डर की शुरुआत का उपयोग मल्टीलाइन और वर्ड-रैप के लिए भी किया जा सकता है |
|
~ |
यदि वेरिएबल रिक्त है तो पंक्ति रिक्त होनी चाहिए |
|
@* |
अनेक पंक्तियाँ. |
($name,$addr,$age,$phone)=("krishna","chennai","24","929309242");
write;
($name,$addr,$age,$phone)=("shruthi","chennai","24","929309232");
write;
format STDOUT_TOP=
===============================================================
NAME ADDRESS AGE PHONE
===============================================================
.
format STDOUT=
@<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<< @<<< @<<<<<<<<<<
$name, $addr, $age, $phone
.
आउटपुट देखने के लिए कोड निष्पादित करें.
हम फ़ील्ड होल्डर या स्ट्रिंग के आरंभ को निर्दिष्ट करने के लिए @ प्रतीक का उपयोग कर रहे हैं, प्रत्येक वर्ण के लिए '<' का उपयोग कर रहे हैं।
हम मानक आउटपुट पर प्रिंट करने के लिए STDOUT का उपयोग कर रहे हैं। हम इसे फ़ाइल हैंडलर में बदल सकते हैं जिसका उपयोग हम फ़ाइल में डेटा लिखने के लिए कर रहे हैं।
open(REPORT,">test.txt");
($name,$addr,$age,$phone)=("krishna","chennai","24","929309232");
write REPORT;
($name,$addr,$age,$phone)=("shruthi","chennai","24","929309232");
write REPORT;
format REPORT_TOP=
===============================================================
NAME ADDRESS AGE PHONE
===============================================================
.
format REPORT=
@<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<< @<<< @<<<<<<<<<<
$name, $addr, $age, $phone
हम पाठ के संरेखण को बदलने के लिए '<' को '>' या '|' से बदल सकते हैं। STDOUT_TOP का उपयोग प्रारूप के हेडर को डिजाइन करने के लिए किया जाता है। हम FH_TOP (FH फ़ाइल हैंडलर है) का उपयोग करके फ़ाइल हैंडलर के साथ भी इसका उपयोग कर सकते हैं। यह उस फ़ाइल के प्रारूप को आउटपुट करेगा जिस पर हम काम कर रहे हैं।
पर्ल कोडिंग मानक
प्रत्येक प्रोग्रामर के पास कुछ मानकों का उपयोग करके कोड लिखने की अपनी समझ होगी; ये मानक इतने परिचित होने चाहिए कि अन्य प्रोग्रामर कोड को ठीक से समझ सकें और उसका समर्थन कर सकें।
पर्ल में कोडिंग मानक
कोड लिखना सरल और आसान है। समस्या तब उत्पन्न होती है जब इसे बाद के चरणों में बनाए रखने की आवश्यकता होती है। कोड लिखते समय उचित दिशा-निर्देशों और कोडिंग मानकों का पालन करने की आवश्यकता होती है। पर्ल कुछ ऐसे मानक भी परिभाषित करता है जो प्रोग्रामर के लिए कोड लिखने में उपयोगी होंगे। कोड लिखते समय 'सख्त' और 'चेतावनी मॉड्यूल' लोड करना उचित है। इनमें से प्रत्येक मॉड्यूल का अपना महत्व है। सख्त हमें उपयोग करने से पहले चर घोषित करने देगा और यह भी बताएगा कि आपके कोड में कोई नंगे शब्द मौजूद हैं या नहीं। वैकल्पिक रूप से चेतावनी मॉड्यूल का उपयोग शेबैंग में पर्ल इंटरप्रेटर को '-w' विकल्प देकर किया जा सकता है। आउटपुट स्क्रीन पर चेतावनियाँ प्रिंट होंगी।
#!/usr/bin/perl –w
नीचे मानकों की कुछ सूचियाँ दी गई हैं।
- 'सख्त' और 'चेतावनी' मॉड्यूल का उपयोग करें।
- जो वेरिएबल उपयोग में नहीं है उसे हटा दें।
- चर नाम अन्य उपयोगकर्ताओं के लिए समझने योग्य होने चाहिए। उदाहरण: $name, @fileData आदि।
- स्क्रिप्ट को कोड करते समय दस्तावेज़ीकरण की आवश्यकता होती है।
- किसी भी मान को हार्डकोड न करें, बल्कि उन्हें गतिशील रूप से प्राप्त करने का प्रयास करें या उपयोगकर्ता को रनटाइम के दौरान दर्ज करने के लिए कहें। (फ़ाइल पथ, फ़ाइल नाम)।
- कोड का पुनः उपयोग अधिकतम करें। पुनः उपयोग योग्य कोड को सबरूटीन में डालने का प्रयास करें।
- इसका अर्थ यह है कि सबरूटीन के लिए पूर्ण नाम दिया जाना चाहिए।
- सबरूटीन्स को उचित टिप्पणियों और दस्तावेज़ीकरण के साथ लिखा जाना चाहिए।
- हमेशा चरों को आरंभीकृत करें.
- सिस्टम कॉल के लिए हमेशा रिटर्न कोड की जाँच करें। फ़ाइल खुल सकती है या नहीं भी, अगर फ़ाइल मौजूद नहीं है तो रिटर्न कोड होने पर त्रुटि स्थिति प्रदर्शित होगी।
उदाहरण: open(FH,
- सबरूटीन को हमेशा एक मान लौटाना चाहिए.
- एक ही पंक्ति में घुंघराले खोलें।
- सिंगल लाइन ब्लॉक को कर्ली के साथ एक ही लाइन में रखा जा सकता है।
- लूप्स के दौरान लेबल का उपयोग करें, इससे जब भी आवश्यक हो लूप से बाहर निकलना आसान होगा।
- शब्दों के लंबे वाक्यांशों को चर नाम या सबरूटीन के रूप में लिखते समय अंडरस्कोर का उपयोग करें।
- कोडिंग करते समय सरल रेगेक्स का उपयोग करने का प्रयास करें।
कोडिंग मानकों के साथ आदर्श उदाहरण:
#######################################################################
Program to read the file content
# Date: 22-2-2013
# Author : Guru99
########################################################################
#!/usr/bin/perl
use strict;
use warnings;
my $line;
open FR, "file.txt" || die("Cannot open the file $!");
while ($line=<FR>)
{
print $line;
} # Looping file handler to print data
पर्ल त्रुटि प्रबंधन
एक अपवाद क्या है?
अपवाद एक ऐसी घटना है जो प्रोग्राम निष्पादन के दौरान घटित होती है जो आपके प्रोग्राम को निलंबित या समाप्त कर देती है।
गलती संभालना
एरर हैंडलिंग एक ऐसी चीज है जिसका ध्यान हर प्रोग्रामर को प्रोग्रामिंग के दौरान रखना होता है। पर्ल एरर हैंडलिंग तकनीक भी प्रदान करता है जिसकी मदद से हम एरर को ट्रैप कर सकते हैं और उसके अनुसार उसे हैंडल कर सकते हैं।
पर्ल में त्रुटि प्रबंधन
प्रोग्राम में त्रुटि की जाँच करने के कई तरीके हैं। हमें उस फ़ंक्शन के रिटर्न कोड की जाँच करनी होगी जिसका हम कोड इस्तेमाल कर रहे हैं। अगर हम उन रिटर्न कोड को ठीक से हैंडल करने में सक्षम हैं, तो अधिकांश त्रुटि हैंडलिंग को हासिल किया जा सकता है।
सिस्टम कॉल के मामले में क्या रिटर्न मिलेगा?
सिस्टम कॉल के मामले में, रिटर्न स्टेटस दो विशेष चरों $? और $! में संग्रहीत हो जाएगा।
$! – यह त्रुटि संख्या या त्रुटि संदेश से संबद्ध त्रुटि संख्या को पकड़ लेगा।
$? – यह return status system() फ़ंक्शन को होल्ड करेगा।
पर्ल ऑपरेटर या लॉजिकल ऑपरेटर का उपयोग करना
सिस्टम कॉल का उपयोग करते समय हम त्रुटि प्रबंधन के लिए लॉजिकल या ऑपरेटर का उपयोग कर सकते हैं।
पूर्व:
open(FH,"<test.txt");
यदि फ़ाइल मौजूद है तो यह फ़ाइल को रीड मोड में खोलेगा।
यदि फ़ाइल गुम हो जाए तो क्या होगा?
open(FH,"<test.txt") or die("File not exists $!"); # This will perl exit the program if the file not exists.
open(FH,"<test.txt") or warn ("File not exists $!"); # This will print a warning message on STDERR
पर्ल इवैल्यूएशन
Eval फ़ंक्शन घातक त्रुटियों, संकलन समय त्रुटियों, रनटाइम त्रुटियों और उन त्रुटियों को संभाल सकता है जो किसी समय आपके कोड को समाप्त कर देती हैं।
पर्ल इवल फ़ंक्शन में कोड का एक ब्लॉक या एक एक्सप्रेशन हो सकता है। इवल्स इसमें रखी गई हर चीज़ को एक स्ट्रिंग के रूप में मानता है।
एक ऐसी स्थिति पर विचार करें जिसमें स्क्रिप्ट में परिभाषित नहीं किए गए सबरूटीन को कॉल किया जाता है। इस स्थिति में, स्क्रिप्ट यह कहते हुए समाप्त हो जाती है कि "अपरिभाषित सबरूटीन &XYZ, इस त्रुटि को eval फ़ंक्शन में संभाला जा सकता है।
इवल्स ब्लॉक के कई उपयोग हैं; ऐसा ही एक उपयोग तब होता है जब हम रनटाइम के दौरान ऑपरेटिंग सिस्टम के लिए विशिष्ट मॉड्यूल को लोड करना चाहते हैं।
उदाहरण: शून्य से भाग देने पर घातक त्रुटि उत्पन्न होती है; इसे नियंत्रित करने के लिए हम कोड को evals ब्लॉक में रख सकते हैं।
$a=5;
$b=0;
eval
{
'$result=$a/$b';
}
if($@)
{
print "$@"; # All the error codes returned by evals will get stored in $@.
}
आउटपुट:
C:\Users\XYZ\Text.pl लाइन 8 पर, “ के पास सिंटैक्स त्रुटि)
{“
संकलन त्रुटियों के कारण C:\Users\XYZ\Text.pl का निष्पादन निरस्त कर दिया गया।
उदाहरण: perl die कथन का उपयोग करके eval.
sub test
{
die "Dieing in sub test \n";
}
eval
{
test();
};
print "Caught : $@\n";
आउटपुट:
पकड़ा गया : उप परीक्षण में मरना
पर्ल का उपयोग करके प्रयास करें
पर्ल अन्य प्रोग्रामिंग भाषाओं की तरह try, catch और finally कोड ब्लॉक का समर्थन नहीं करता है। हम अभी भी बाहरी पर्ल मॉड्यूल लोड करके उनका उपयोग कर सकते हैं।
Try::Tiny का उपयोग करें;
इसका उपयोग करके हम आपके कोड को try ब्लॉक में रख सकते हैं और warn ब्लॉक में त्रुटि पकड़ सकते हैं।
eval में प्रयुक्त $@ के स्थान पर Try::Tiny $_ का प्रयोग करता है।
# कैच हैंडलर से त्रुटियों को संभालें
try
{
die "Die now";
}
catch
{
warn "caught error: $_"; # not $@
};
अंततः उपयोग करना।
my $y;
try
{
die 'foo'
}
finally
{
$y = 'bar'
};
try
{
die 'Die now'
}
catch
{
warn "Returned from die: $_"
}
finally
{
$y = 'gone'
};
आउटपुट:
foo C:\Users\XYZ\Text.pl पंक्ति 4 पर.
हम इस तरीके से try, catch और finally का उपयोग कर सकते हैं।
कोशिश { # कथन }
पकड़ {# कथन }
अंत में { # कथन };
Or
try
{
# statement
}
finally
{
# statement
};
आउटपुट:
Or
try
{
# statement
}
finally
{
# statement
}
catch
{
# statement
};
आउटपुट:
पर्ल सॉकेट प्रोग्रामिंग
सॉकेट क्या है?
सॉकेट एक ऐसा माध्यम है जिसके माध्यम से दो कंप्यूटर नेटवर्क एड्रेस और पोर्ट का उपयोग करके नेटवर्क पर परस्पर क्रिया कर सकते हैं।
मान लीजिए, A (सर्वर) और B (क्लाइंट) दो सिस्टम हैं, जिन्हें कुछ प्रोग्राम चलाने के लिए सॉकेट्स का उपयोग करके एक दूसरे के साथ बातचीत करनी होती है।
इसे कार्यान्वित करने के लिए हमें A (सर्वर) और B (क्लाइंट) दोनों में सॉकेट बनाने की आवश्यकता है, A प्राप्ति अवस्था में होगा और B प्रेषक अवस्था में होगा।
एक सर्वर):
यहाँ, सर्वर B (क्लाइंट) से कनेक्शन प्राप्त करना चाहता है और कुछ कार्य निष्पादित करके परिणाम B (क्लाइंट) को वापस भेजना चाहता है। जब हम कोड निष्पादित करते हैं, तो A में ऑपरेटिंग सिस्टम एक सॉकेट बनाने की कोशिश करता है और उस सॉकेट से एक पोर्ट को बांधता है। फिर यह प्रेषक से सुनेगा जो B है।
बी (ग्राहक).
यहाँ, क्लाइंट अपने सिस्टम से कुछ प्रोग्राम को कुछ प्रोसेसिंग के लिए A (सर्वर) पर भेजना चाहता है। जब हम कोड निष्पादित करते हैं, तो B में ऑपरेटिंग सिस्टम A (सर्वर) के साथ संचार करने के लिए एक सॉकेट बनाने की कोशिश करता है, B को A का IP पता और पोर्ट नंबर निर्दिष्ट करना होता है जिससे B कनेक्ट होना चाहता है।
अगर यह ठीक से हो जाए, तो दोनों सिस्टम एक पोर्ट के ज़रिए सूचना का आदान-प्रदान करने के लिए आपस में बातचीत करेंगे। पर्ल सॉकेट प्रोग्रामिंग का भी समर्थन करता है।
पर्ल में एक मूल API है जिसके माध्यम से सॉकेट को लागू किया जा सकता है। इसे आसान बनाने के लिए, कई CPAN मॉड्यूल हैं जिनका उपयोग करके हम सॉकेट प्रोग्राम लिखते हैं।
सर्वर संचालन:
- सॉकेट बनाएं
- सॉकेट को पते और पोर्ट से जोड़ें
- उस पोर्ट पते पर सॉकेट को सुनें
- उन क्लाइंट कनेक्शन को स्वीकार करें जो सर्वर के पोर्ट और आईपी का उपयोग करके कनेक्ट करने का प्रयास करते हैं
- काम करना
ग्राहक Operaमाहौल:
- सॉकेट बनाएं
- अपने पोर्ट पते का उपयोग करके सर्वर से कनेक्ट करें
- काम करना
सॉकेट
यह सॉकेट प्रोग्रामिंग के लिए एक मॉड्यूल है, जो ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग पर आधारित है। यह मॉड्यूल नेटवर्क में उपयोग किए जाने वाले INET नेटवर्क प्रकार का समर्थन नहीं करता है।
आईओ::सॉकेट::INET:
यह मॉड्यूल INET डोमेन का समर्थन करता है और IO::Sockets पर बनाया गया है। IO::Sockets में उपलब्ध सभी विधियाँ INET मॉड्यूल में विरासत में मिली हैं।
टीसीपी प्रोटोकॉल का उपयोग करने वाले क्लाइंट और सर्वर:
टीसीपी एक कनेक्शन-उन्मुख प्रोटोकॉल है; हम सॉकेट प्रोग्रामिंग के लिए इस प्रोटोकॉल का उपयोग करेंगे।
आगे बढ़ने से पहले आइए देखें कि हम IO::Socket::INET मॉड्यूल के लिए ऑब्जेक्ट कैसे बना सकते हैं और सॉकेट कैसे बना सकते हैं।
$socket = IO::Socket::INET->new(PeerPort => 45787, PeerAddr => inet_ntoa(INADDR_BROADCAST), Proto => udp,LocalAddr => 'localhost',Broadcast => 1 ) or die "Can't create socket and bind it : $@n";
IO::Socket::INET मॉड्यूल में नई विधि सबरूटीन के लिए इनपुट पैरामीटर के रूप में हैश को स्वीकार करती है। यह हैश पूर्वनिर्धारित है, और हमें केवल उन कुंजियों के मान प्रदान करने की आवश्यकता है जिन्हें हम उपयोग करना चाहते हैं। इस हैश द्वारा उपयोग की जाने वाली कुंजियों की एक सूची है।
|
पीयरएड्रेस |
दूरस्थ होस्ट पता |
|
पीयरहोस्ट |
PeerAddr का पर्यायवाची |
|
पीयरपोर्ट |
दूरस्थ पोर्ट या सेवा |
|
स्थानीयपता |
स्थानीय होस्ट बाइंड पता |
|
स्थानीय होस्ट |
LocalAddr का पर्यायवाची |
|
लोकलपोर्ट |
स्थानीय होस्ट बाइंड पोर्ट |
|
आद्य |
प्रोटोकॉल नाम (या संख्या) |
|
प्रकार |
सॉकेट प्रकार |
|
सुनना |
सुनने के लिए कतार का आकार |
|
पुनःउपयोगपता |
बाइंडिंग से पहले SO_REUSEADDR सेट करें |
|
पुन: उपयोग |
बाइंडिंग से पहले SO_REUSEADDR सेट करें |
|
रीयूजपोर्ट |
बाइंडिंग से पहले SO_REUSEPORT सेट करें |
|
प्रसारण |
बाइंडिंग से पहले SO_BROADCAST सेट करें |
|
मध्यांतर |
विभिन्न कार्यों के लिए समय समाप्ति मान |
|
बहु-स्थल |
मल्टीहोम होस्ट के लिए सभी पते आज़माएँ |
|
अवरूध्द |
निर्धारित करें कि क्या कनेक्शन ब्लॉकिंग मोड में होगा |
सर्वर.pl
use IO::Socket;
use strict;
use warnings;
my $socket = new IO::Socket::INET (
LocalHost => 'localhost',
LocalPort => '45655',
Proto => 'tcp',
Listen => 1,
Reuse => 1,
);
die "Could not create socket: $!n" unless $socket;
print "Waiting for the client to send datan";
my $new_socket = $socket->accept();
while(<$new_socket>) {
print $_;
}
close($socket);
क्लाइंट.pl
use strict; use warnings; use IO::Socket; my $socket = new IO::Socket::INET ( PeerAddr => 'localhost', PeerPort => '45655', Proto => 'tcp', ); die "Could not create socket: $!n" unless $socket; print $socket "Hello this is socket connection!n"; close($socket);
टिप्पणी:
सॉकेट प्रोग्रामिंग में, यदि हम स्थानीय होस्ट पर चल रहे हैं तो हमें पहले Server.pl और फिर client.pl को अलग-अलग कमांड प्रॉम्प्ट में निष्पादित करना होगा।
पर्ल मॉड्यूल और पैकेज क्या है
मॉड्यूल और पैकेज एक दूसरे से बहुत करीब से जुड़े हुए हैं और स्वतंत्र हैं। पैकेज: एक पर्ल पैकेज को नेमस्पेस के रूप में भी जाना जाता है और इसमें हैश, एरे, स्केलर और सबरूटीन जैसे सभी अद्वितीय चर होते हैं। मॉड्यूल: मॉड्यूल पुन: प्रयोज्य कोड का एक संग्रह है, जहाँ हम इसमें सबरूटीन लिखते हैं। इन मॉड्यूल को उन मॉड्यूल में लिखे गए सबरूटीन का उपयोग करने के लिए पर्ल प्रोग्राम में लोड किया जा सकता है।
पर्ल मॉड्यूल क्या हैं?
किसी भी सिस्टम पर Perl की स्थापना के दौरान मानक मॉड्यूल स्थापित हो जाएंगे। CPAN: व्यापक Perl Archiवी नेटवर्क - पर्ल मॉड्यूल का एक वैश्विक भंडार। हमारे अपने अनुकूलित पर्ल मॉड्यूल जिन्हें हम स्वयं लिख सकते हैं। मूल रूप से, किसी भी स्क्रिप्ट में लोड होने पर एक मॉड्यूल अपने सभी वैश्विक चर और सबरूटीन निर्यात करेगा। ये सबरूटीन सीधे कॉल कर सकते हैं जैसे कि उन्हें स्क्रिप्ट में ही घोषित किया गया हो। पर्ल मॉड्यूल को फ़ाइल नाम में .pm एक्सटेंशन के साथ लिखा जा सकता है उदाहरण: Foo.pm। प्रोग्राम की शुरुआत में 'पैकेज Foo' का उपयोग करके एक मॉड्यूल लिखा जा सकता है।
बेसिक पर्ल मॉड्यूल:
#!/usr/bin/perl
package Arithmetic;
sub add
{
my $a=$_[0];
my $b=$_[1];
return ($a+$b);
}
sub subtract
{
my $a=$_[0];
my $b=$_[1];
return ($a-$b);
}
1;
उत्पादन नही
इस पर्ल मॉड्यूल का उपयोग करने के लिए, हमें इसे वर्तमान कार्यशील निर्देशिका में रखना होगा।
हम कोड में कहीं भी require या use का उपयोग करके Perl मॉड्यूल लोड कर सकते हैं। require और use के बीच मुख्य अंतर यह है कि require रनटाइम के दौरान लोड होता है और use संकलन समय के दौरान लोड होता है।
#!/usr/bin/perl require Arithmetic; print Arithmetic::add(5,6); print Arithmetic:: subtract (5,6);
यहां, उपरोक्त उदाहरण में, हम पूर्णतः योग्य मॉड्यूल नाम का उपयोग करके सबरूटीन्स तक पहुंच रहे हैं।
हम 'use Arithmetic' का उपयोग करके भी पैकेज तक पहुंच सकते हैं।
निर्यातक:
इस मॉड्यूल में विधियों को आयात करने की डिफ़ॉल्ट कार्यक्षमता है।
#!/usr/bin/perl
package Arithmetic;
require Exporter;
@ISA= qw(Exporter); # This is basically for implementing inheritance.
@EXPORT = qw(add);
@EXPORT_OK = qw(subtract);
sub add
{
my $a=$_[0];
my $b=$_[1];
return ($a+$b);
}
sub subtract
{
my $a=$_[0];
my $b=$_[1];
return ($a-$b);
}
1;
@EXPORT सरणी का उपयोग चरों और सबरूटीनों की सूची को पास करने के लिए किया जा सकता है, जो डिफ़ॉल्ट रूप से मॉड्यूल के कॉलर को निर्यात किया जाएगा।
@EXPORT_OK सरणी का उपयोग चरों और उप-रूटीनों की सूची को पास करने के लिए किया जा सकता है, जिन्हें मांग के आधार पर निर्यात किया जाएगा, जहां उपयोगकर्ता को मॉड्यूल लोड करते समय निर्दिष्ट करना होगा।
#!/usr/bin/perl use Arithmetic qw(subtract); print add(5,6); print subtract (5,6);
डिफ़ॉल्ट रूप से, add subroutine को निर्यात किया जाएगा। घटाना विधि को निर्यात नहीं किया जाएगा यदि मॉड्यूल लोड करते समय इसे निर्दिष्ट नहीं किया गया है।
पर्ल में ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग
इस अनुभाग में, हम सीखेंगे कि पर्ल ऑब्जेक्ट ओरिएंटेड मॉड्यूल कैसे बनाएं। सबसे पहले, आइए देखें कि ऑब्जेक्ट क्या है? ऑब्जेक्ट एक उदाहरण है जिसका उपयोग करके हम किसी भी पर्ल मॉड्यूल में कुछ डेटा तक पहुँच सकते हैं, उसे संशोधित कर सकते हैं और उसका पता लगा सकते हैं। यह आपके मौजूदा पर्ल पैकेज, वैरिएबल और सबरूटीन को अन्य प्रोग्रामिंग भाषाओं के संदर्भ में क्लास, ऑब्जेक्ट और विधियों की तरह कार्य करने के लिए बनाने के अलावा और कुछ नहीं है।
क्लास बनाएं
हम पहले से ही जानते हैं कि पिछले विषय से मॉड्यूल कैसे बनाएं। क्लास का उद्देश्य विधियों और चरों को संग्रहीत करना है। एक पर्ल मॉड्यूल में सबरूटीन होंगे जो विधियाँ हैं। हमें उन चर और सबरूटीन ऑब्जेक्ट तक पहुँचने की आवश्यकता है।
पर्ल कंस्ट्रक्टर
पर्ल में कंस्ट्रक्टर एक ऐसी विधि है जो निष्पादित होगी और हमें संदर्भ में टैग किए गए मॉड्यूल नाम के साथ एक संदर्भ लौटाएगी। इसे क्लास को आशीर्वाद देना कहते हैं। हम पर्ल क्लास को आशीर्वाद देने के लिए एक विशेष चर का उपयोग करते हैं, जिसे आशीर्वाद कहा जाता है।
#!/usr/bin/perl
package Arithmetic;
sub new
{
my $class=shift;
my $self={};
bless $self, $class;
return $self;
}
sub add
{
my $self= shift;
my $a=$_[0];
my $b=$_[1];
return ($a+$b);
}
sub subtract
{
my $self= shift;
my $a=$_[0];
my $b=$_[1];
return ($a-$b);
}
1;
एक क्लास के लिए कन्स्ट्रक्टर के रूप में प्रयुक्त नई विधि, यह कन्स्ट्रक्टर हमारे लिए एक ऑब्जेक्ट बनाएगा तथा उस स्क्रिप्ट पर वापस लौटेगा जो इस कन्स्ट्रक्टर को कॉल कर रही है।
#!/usr/bin/perl use Arithmetic; my $obj= Arithmetic->new(); my $result= $obj->add(5,6); print "$result"; $result = $obj->subtract(6,5); print "$result";
यहाँ, हमें यह समझने की आवश्यकता है कि ऑब्जेक्ट कैसे बनाया गया है। जब भी हम क्लास के लिए ऑब्जेक्ट बनाने की कोशिश करते हैं, तो हमें क्लास का पूरा नाम इस्तेमाल करना होगा। मान लीजिए, अगर पर्ल क्लास किसी lib\Math\Arithmetic.pm में स्थित है। और, अगर हम lib डायरेक्टरी से इस पर्ल क्लास तक पहुँचना चाहते हैं, तो हमें स्क्रिप्ट में कॉल करते समय क्लास का पूरा पथ प्रदान करना होगा।
lib::Math::Arithmetic का उपयोग करें;
my $obj = lib::Math::Arithmetic->new();
पर्ल में ऑब्जेक्ट निर्माण इसी प्रकार होता है।
@आईएनसी:
पर्ल स्क्रिप्ट को कैसे पता चलता है कि लाइब्रेरी मॉड्यूल कहाँ मौजूद है? पर्ल को केवल स्क्रिप्ट की वर्तमान निर्देशिका और पर्ल इनबिल्ट लाइब्रेरी पथ के बारे में पता होता है। जब भी हम पर्ल मॉड्यूल का उपयोग करते हैं, जो वर्तमान निर्देशिका या पर्ल लाइब्रेरी पथ में स्थित नहीं है, तो स्क्रिप्ट हमेशा विफल हो जाएगी। @INC के बारे में, यह एक सरणी है, जिसमें सभी निर्देशिका पथ होते हैं जहाँ इसे पर्ल मॉड्यूल की तलाश करनी होती है। इस कमांड को निष्पादित करने का प्रयास करें और देखें कि आउटपुट क्या होगा।
perl –e "print @INC"
इससे कुछ आउटपुट मिलेगा, और यही वह पथ है जहाँ lib मॉड्यूल उपलब्ध होंगे। जब भी हम कोई नया लाइब्रेरी मॉड्यूल इस्तेमाल करते हैं, तो हमें Perl, इंटरप्रेटर को यह बताने की ज़रूरत होती है कि वह उस विशेष स्थान को देखे जहाँ Perl मॉड्यूल उपलब्ध है।
push(@INC, "PATH TO YOUR MODULE");
इसे अपने कोड की पहली लाइन बनाएं। यह आपके इंटरप्रेटर को उस पथ को देखने के लिए कहेगा। या उपयोग
lib Arithmetic; # List here is your Perl Module location
पर्ल डिस्ट्रक्टर
किसी ऑब्जेक्ट का डिस्ट्रक्टर डिफ़ॉल्ट रूप से अंत में और आपकी स्क्रिप्ट के बाहर निकलने से पहले कॉल किया जाता है। इसका उपयोग मेमोरी से आपके ऑब्जेक्ट को नष्ट करने के लिए किया जाता है।
पर्ल बनाम शेल स्क्रिप्टिंग
- पर्ल में प्रोग्रामिंग करने से पोर्टेबिलिटी संबंधी समस्याएं उत्पन्न नहीं होतीं, जो शेल स्क्रिप्टिंग में विभिन्न शेल्स का उपयोग करते समय आम बात है।
- पर्ल में त्रुटि प्रबंधन बहुत आसान है
- पर्ल की विशालता के कारण आप इस पर आसानी से लंबे और जटिल प्रोग्राम लिख सकते हैं। यह शेल के विपरीत है जो नेमस्पेस, मॉड्यूल, ऑब्जेक्ट, इनहेरिटेंस आदि का समर्थन नहीं करता है।
- शेल में कम पुन: प्रयोज्य लाइब्रेरी उपलब्ध हैं। पर्ल के CPAN की तुलना में कुछ भी नहीं
- शेल कम सुरक्षित है। यह बाहरी फ़ंक्शन को कॉल करता है (mv, cp आदि जैसे कमांड इस्तेमाल किए जा रहे शेल पर निर्भर करते हैं)। इसके विपरीत पर्ल आंतरिक फ़ंक्शन का उपयोग करते हुए उपयोगी कार्य करता है।
स्वचालन परीक्षण में PERL का उपयोग कैसे किया जाता है
पर्ल का इस्तेमाल ऑटोमेशन में बहुत ज़्यादा किया जाता है। हो सकता है कि यह दुनिया की सबसे अच्छी प्रोग्रामिंग लैंग्वेज न हो, लेकिन यह कुछ खास तरह के कामों के लिए सबसे उपयुक्त है। आइए चर्चा करें कि पर्ल का इस्तेमाल कहां और क्यों किया जाता है स्वचालन परीक्षण.
भंडारण परीक्षण
स्टोरेज क्या है? फ़ाइलों में संग्रहीत डेटा।
मान लीजिए, हमारे पास स्टोरेज से संबंधित एक परीक्षण का मामला जहां हमें एक पार्टीशन पर डेटा लिखना है, उसे पढ़ना है और सत्यापित करना है कि डेटा सही ढंग से लिखा गया है।
यह काम मैन्युअली किया जा सकता है, लेकिन क्या मैन्युअल टेस्टर 10000 बार ऐसा कर सकता है? यह एक दुःस्वप्न होगा! हमें स्वचालन की आवश्यकता है
भंडारण से संबंधित किसी भी चीज़ को स्वचालित करने के लिए सबसे अच्छा उपकरण पर्ल है, क्योंकि इसमें फ़ाइल हैंडलिंग तकनीक है, regex और शक्तिशाली फ़ाइल पार्सिंग जो अन्य प्रोग्रामिंग भाषाओं की तुलना में कम से कम निष्पादन समय लेती है।
हमें भंडारण का परीक्षण क्यों करना आवश्यक है? बड़े डेटा सेंटर के बारे में सोचें, जहाँ डेटा एक सिस्टम से दूसरे सिस्टम में लगातार प्रवाहित होता रहेगा और प्रति सेकंड 1000 से ज़्यादा रिकॉर्ड स्टोर किए जाएँगे। ऐसे स्टोरेज तंत्र की मज़बूती का परीक्षण करना ज़रूरी है।
एचपी, डेल जैसी कई कंपनियां IBM और कई सर्वर निर्माता स्टोरेज और नेटवर्किंग डोमेन में कार्यक्षमता का परीक्षण करने के लिए इंटरफ़ेस के रूप में पर्ल का उपयोग करते हैं। नेटऐप एक ऐसी ही कंपनी है जो पूरी तरह से स्टोरेज पर काम करती है और परीक्षण मामलों को स्वचालित करने के लिए प्रोग्रामिंग भाषा के रूप में पर्ल का उपयोग करती है।
यदि आप पर्ल ऑटोमेशन में रुचि रखते हैं, तो स्टोरेज और नेटवर्किंग के बारे में सीखना उचित होगा Concepts.
सर्वर एवं नेटवर्क परीक्षण:
पर्ल का उपयोग करके सर्वर और नेटवर्क परीक्षण
PERL का उपयोग सर्वर अपटाइम और प्रदर्शन निगरानी में व्यापक रूप से किया जाता है।
एक डेटा सेंटर पर विचार करें जिसमें 100 होस्ट (सर्वर) हैं। आपको प्रत्येक होस्ट से कनेक्ट होना होगा, कुछ कमांड को दूरस्थ रूप से निष्पादित करना होगा। आपको सिस्टम को रीबूट करना होगा और यह जांचना होगा कि यह कब ऑनलाइन आता है।
सभी 100 होस्ट के लिए मैन्युअल रूप से यह कार्य करना एक दुःस्वप्न होगा। लेकिन हम PERL का उपयोग करके इसे आसानी से स्वचालित कर सकते हैं
PERL का उपयोग करके उपरोक्त स्वचालन को प्राप्त करने के लिए डिज़ाइन चरण
- फ़ाइल से होस्ट की जानकारी (जैसे आईपी, उपयोगकर्ता नाम और पासवर्ड) के बारे में इनपुट लें।
- प्रत्येक सिस्टम से कनेक्ट करने के लिए Net::SSH2 का उपयोग करें और कमांड निष्पादित करने के लिए एक चैनल स्थापित करें।
- आवश्यक आदेशों का सेट निष्पादित करें जैसे: ls, dir, ifconfig,ps आदि।
- सिस्टम रिबूट करें
- सिस्टम के चालू होने के लिए 10 मिनट तक प्रतीक्षा करें।
- Net::Ping मॉड्यूल का उपयोग करके सिस्टम को पिंग करें और स्थिति प्रिंट करें।
हम उपरोक्त परिदृश्य को कोड करेंगे।
आइए Input.txt नामक एक फाइल लें, जिसमें उन सभी होस्ट्स के बारे में पूरी जानकारी संग्रहीत होगी जिनसे हमें कनेक्ट होना है और कमांड निष्पादित करना है।
इनपुट.txt
192.168.1.2 रूट पासवर्ड
192.168.1.3 रूट पासवर्ड
192.168.1.4 रूट root123
होस्टचेक.pl
use Net::SSH2;
use Net::Ping;
use strict;
use warnings;
my $ping = Net::Ping->new(); # Creating object for Net::Ping
my $SSHObj = Net::SSH2->new(); #Creating object for Net::SSH2
open( FH, "Input.txt" ); # Opening file and placing content to FH
my @hosts = <FH>;
my $ip;
my @ips;
foreach (@hosts)
{
if ( $_ =~ /(.*)\s+(\w+)\s+(.*)/ ) #Regex to get each info from file
{
$ip = $1;
my $user = $2;
my $password = $3;
$SSHObj->connect($ip);
print "Connecting to host -- $ip --Uname:$user --Password:$password\n";
my $status = $SSHObj->auth_password( $user, $password );
print "$status\n";
die("unable to establish connection to -- $ip") unless ($status);
my $shell = $SSHObj->channel();
print "$_\n" while <$shell>;
$shell->blocking(1);
$shell->pty('tty');
$shell->shell();
sleep(5);
#Executing the list of command on particular host. Can be any command
print $shell "ls \n";
print "$_\n" while <$shell>;
print $shell "ps \n";
print "$_\n" while <$shell>;
print $shell "dir \n";
print "$_\n" while <$shell>;
print $shell "init 6\n"; #rebooting the system
push( @ips, $ip );
}
}
sleep 600;
foreach (@ips)
{
if ( $ping->ping($_) )
{
print "$_ is alive.\n" if $ping->ping($_);
}
else
{
print "$_ is not still up --waiting for it to come up\n";
}
}
वेब परीक्षण
पर्ल केवल स्टोरेज और नेटवर्क परीक्षण तक ही सीमित नहीं है। हम पर्ल का उपयोग करके वेब-आधारित परीक्षण भी कर सकते हैं। WWW-मैकेनाइज एक मॉड्यूल के लिए प्रयोग किया जाता है वेब परीक्षणमूलतः, यह वेब अनुप्रयोग की कार्यक्षमता का परीक्षण करने के लिए कोई ब्राउज़र लॉन्च नहीं करेगा, बल्कि यह HTML पृष्ठों के स्रोत कोड का उपयोग करता है।
हम इसका उपयोग करके ब्राउज़र आधारित परीक्षण भी कर सकते हैं Selenium IDE, RC, वेब ड्राइवर। Perl इसके लिए समर्थित है Selenium.
\n”; #यह पैटर्न मिलान हो जाने के बाद शेष स्ट्रिंग को रखेगा।
प्रिंट “
