पर्लमॉड - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

पर्लमॉड - पर्ल मॉड्यूल (पैकेज और प्रतीक तालिकाएँ)

वर्णन

Is इसका la दस्तावेज़ इसलिए आप थे बाद में?
ऐसे अन्य दस्तावेज़ भी हैं जिनमें वह जानकारी हो सकती है जिसे आप खोज रहे हैं:

यह दस्तावेज़
पर्ल के पैकेज, नेमस्पेस और कक्षाओं पर कुछ जानकारी।

पर्लन्यूमोड
नया मॉड्यूल बनाने पर ट्यूटोरियल।

पर्लमोडस्टाइल
नया मॉड्यूल बनाने के लिए सर्वोत्तम अभ्यास।

संकुल
पर्ल पैकेजों को खराब होने से बचाने के लिए वैकल्पिक नामस्थानों के लिए एक तंत्र प्रदान करता है
एक दूसरे के चर. वास्तव में, वास्तव में वैश्विक चर जैसी कोई चीज़ नहीं है
पर्ल. पैकेज स्टेटमेंट संकलन इकाई को दिए गए के रूप में घोषित करता है
नामस्थान. पैकेज घोषणा का दायरा घोषणा से ही है
संलग्न ब्लॉक का अंत, "eval", या फ़ाइल, जो भी पहले आए (समान दायरा)।
la मेरे() और स्थानीय () ऑपरेटर्स)। इसमें अयोग्य गतिशील पहचानकर्ता होंगे
नेमस्पेस, उन कुछ पहचानकर्ताओं को छोड़कर जो अयोग्य होने पर मुख्य पर डिफ़ॉल्ट होते हैं
जैसा कि नीचे बताया गया है वर्तमान पैकेज के बजाय पैकेज। एक पैकेज स्टेटमेंट केवल प्रभावित करता है
गतिशील चर--जिनमें वे भी शामिल हैं जिनका आपने उपयोग किया है स्थानीय () पर--लेकिन नहीं शाब्दिक चर
के साथ बनाया मेरे(). आमतौर पर यह द्वारा शामिल फ़ाइल में पहली घोषणा होगी
"करें", "आवश्यकता है", या "उपयोग करें" ऑपरेटर। आप एक से अधिक पैकेज में स्विच कर सकते हैं
जगह; यह केवल इस बात को प्रभावित करता है कि कंपाइलर द्वारा बाकी के लिए किस प्रतीक तालिका का उपयोग किया जाता है
वह ब्लॉक. आप उपसर्ग लगाकर अन्य पैकेजों में वेरिएबल्स और फ़ाइलहैंडल का उल्लेख कर सकते हैं
पैकेज नाम और दोहरे कोलन के साथ पहचानकर्ता: $Package::Variable. यदि पैकेज
नाम शून्य है, "मुख्य" पैकेज मान लिया गया है। यानि कि $::sAIL के बराबर है
$मुख्य::पाल.

पुराना पैकेज डिलीमीटर एकल उद्धरण था, लेकिन अब डबल कोलन को प्राथमिकता दी गई है
सीमांकक, आंशिक रूप से क्योंकि यह मनुष्यों के लिए अधिक पठनीय है, और आंशिक रूप से क्योंकि यह अधिक है
पढ़ने योग्य Emacs मैक्रोज़. यह C++ प्रोग्रामर्स को यह भी महसूस कराता है कि उन्हें पता है कि क्या हो रहा है
पर--विभाजक के रूप में एकल उद्धरण का उपयोग करने के विपरीत, जो एडा बनाने के लिए था
प्रोग्रामर को ऐसा लगता है जैसे वे जानते थे कि क्या हो रहा था। क्योंकि पुराने ज़माने का सिंटेक्स है
यदि आप "यह है" जैसी स्ट्रिंग का उपयोग करने का प्रयास करते हैं, तो यह अभी भी पश्चगामी संगतता के लिए समर्थित है
$owner's house", आप $owner::s तक पहुंच पाएंगे; अर्थात, पैकेज में $s वैरिएबल
"मालिक", जो संभवतः आपका अभिप्राय नहीं है। स्पष्ट करने के लिए ब्रेसिज़ का उपयोग करें, जैसे कि "यह है।"
${मालिक} का घर"।

पैकेज में स्वयं पैकेज सेपरेटर हो सकते हैं, जैसे $OUTER::INNER::var. यह
हालाँकि, नाम लुकअप के क्रम के बारे में कुछ भी नहीं बताता है। कोई सापेक्ष पैकेज नहीं हैं:
सभी प्रतीक या तो वर्तमान पैकेज के लिए स्थानीय हैं, या पूरी तरह से योग्य होने चाहिए
बाहरी पैकेज का नाम नीचे। उदाहरण के लिए, पैकेज "आउटर" में ऐसा कहीं नहीं है
$INNER::var का तात्पर्य $OUTER::INNER::var से है। "INNER" एक पूरी तरह से अलग वैश्विक को संदर्भित करता है
पैकेज.

केवल अक्षरों (या अंडरस्कोर) से शुरू होने वाले पहचानकर्ता ही पैकेज के प्रतीक में संग्रहीत होते हैं
मेज़। अन्य सभी प्रतीकों को पैकेज "मुख्य" में रखा गया है, जिसमें सभी विराम चिह्न चर शामिल हैं,
$_ की तरह. इसके अलावा, अयोग्य होने पर, पहचानकर्ता STDIN, STDOUT, STDERR, ARGV,
ARGVOUT, ENV, INC, और SIG को अन्य के लिए उपयोग किए जाने पर भी "मुख्य" पैकेज में रहने के लिए मजबूर किया जाता है
उनके अंतर्निहित उद्देश्यों की तुलना में उद्देश्य। यदि आपके पास "एम", "एस", या "वाई" नामक पैकेज है
आप किसी पहचानकर्ता के योग्य रूप का उपयोग नहीं कर सकते क्योंकि इसके बजाय इसकी व्याख्या की जाएगी
एक पैटर्न मिलान, प्रतिस्थापन, या लिप्यंतरण के रूप में।

अंडरस्कोर से शुरू होने वाले वेरिएबल को पैकेज मुख्य में जबरदस्ती डाला जाता था, लेकिन हमने इसे तय कर लिया
संकेत देने के लिए अग्रणी अंडरस्कोर का उपयोग करने में सक्षम होने के लिए पैकेज लेखकों के लिए अधिक उपयोगी था
निजी चर और विधि नाम। हालाँकि, वैरिएबल और फ़ंक्शंस को एक ही नाम दिया गया है
"_", जैसे $_ और "उप _", अभी भी "मुख्य" पैकेज में डाले गए हैं। यह भी देखें "द
परिवर्तनीय नामों का वाक्य-विन्यास" पर्लवर में।

"eval"ed स्ट्रिंग्स को उस पैकेज में संकलित किया गया है जिसमें eval () संकलित किया गया था।
($SIG{} को असाइनमेंट, हालांकि, मान लें कि निर्दिष्ट सिग्नल हैंडलर "मुख्य" में है
पैकेट। यदि आप सिग्नल हैंडलर रखना चाहते हैं तो सिग्नल हैंडलर नाम को अर्हता प्राप्त करें
पैकेज।) उदाहरण के लिए, जांच करें perldb.pl पर्ल लाइब्रेरी में. यह प्रारंभ में स्विच करता है
"DB" पैकेज में ताकि डिबगर प्रोग्राम में वेरिएबल्स के साथ हस्तक्षेप न करे
आप डीबग करने का प्रयास कर रहे हैं. हालाँकि, विभिन्न बिंदुओं पर, यह अस्थायी रूप से वापस स्विच हो जाता है
"मुख्य" पैकेज "मुख्य" पैकेज के संदर्भ में विभिन्न अभिव्यक्तियों का मूल्यांकन करने के लिए (या
आप जहां भी से आए हों)। पर्लडेबग देखें।

विशेष प्रतीक "__PACKAGE__" में वर्तमान पैकेज शामिल है, लेकिन इसका उपयोग (आसानी से) नहीं किया जा सकता है
परिवर्तनीय नाम बनाने के लिए.

संबंधित अन्य स्कोपिंग मुद्दों के लिए पर्लसब देखें मेरे() और स्थानीय (), और perlref के संबंध में
बंद।

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

जब आप *नाम का उपयोग करते हैं तो हैश की प्रत्येक प्रविष्टि में मान वही होता है जिसका आप उल्लेख कर रहे हैं
टाइपग्लोब नोटेशन।

स्थानीय *मुख्य::फू = *मुख्य::बार;

उदाहरण के लिए, आप इसका उपयोग किसी पैकेज में सभी वेरिएबल्स को प्रिंट करने के लिए कर सकते हैं। मानक
लेकिन पुरातन Dumpvar.pl लाइब्रेरी और CPAN मॉड्यूल Devel::Symdump इसका उपयोग करते हैं।

नई प्रतीक तालिका प्रविष्टियाँ सीधे बनाने या किसी प्रविष्टि को संशोधित करने के परिणाम
टाइपग्लोब पहले से ही अपरिभाषित नहीं हैं और पर्ल के रिलीज के बीच परिवर्तन के अधीन हैं।

टाइपग्लोब को असाइनमेंट एक अलियासिंग ऑपरेशन करता है, यानी,

*डिक = *रिचर्ड;

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

*डिक = \$रिचर्ड;

जो $richard और $dick को एक ही वेरिएबल बनाता है, लेकिन @richard और @dick को छोड़ देता है
अलग सारणी. मुश्किल, एह?

निम्नलिखित कथनों के बीच एक सूक्ष्म अंतर है:

*फू = *बार;
*फू = \$बार;

"*foo = *bar" टाइपग्लोब को स्वयं पर्यायवाची बनाता है जबकि "*foo = \$bar" बनाता है
दो अलग-अलग प्रकार के ग्लोब के SCALAR भाग समान अदिश मान को दर्शाते हैं। इस का मतलब है कि
निम्नलिखित कोड:

$बार = 1;
*फू = \$बार; # $foo को $bar के लिए उपनाम बनाएं

{
स्थानीय $बार ​​= 2; # परिवर्तनों को ब्लॉक करने तक सीमित करें
$foo प्रिंट करें; # '1' प्रिंट करता है!
}

'1' प्रिंट करेंगे, क्योंकि $foo का संदर्भ है मूल $बार. वह जो था
"स्थानीय()" द्वारा भर दिया गया है और जिसे ब्लॉक समाप्त होने पर पुनर्स्थापित किया जाएगा। क्योंकि
वेरिएबल्स को टाइपग्लोब के माध्यम से एक्सेस किया जाता है, आप उपनाम बनाने के लिए "*foo = *bar" का उपयोग कर सकते हैं
जिसे स्थानीयकृत किया जा सकता है। (लेकिन ध्यान रखें कि इसका मतलब यह है कि आपके पास अलग से @foo और नहीं हो सकता
@बार, आदि)

यह सब जो महत्वपूर्ण बनाता है वह यह है कि निर्यातक मॉड्यूल ग्लोब एलियासिंग का उपयोग करता है
आयात/निर्यात तंत्र. आप किसी वेरिएबल को ठीक से स्थानीयकृत कर सकते हैं या नहीं
एक मॉड्यूल से निर्यात इस पर निर्भर करता है कि इसे कैसे निर्यात किया गया था:

@निर्यात = qw($FOO); # सामान्य रूप, स्थानीयकृत नहीं किया जा सकता
@निर्यात = qw(*FOO); #स्थानीयकृत किया जा सकता है

आप पूर्णतः योग्य नाम ($Package::FOO) का उपयोग करके पहले मामले पर काम कर सकते हैं
आपको एक स्थानीय मान की आवश्यकता है, या अपने में "*FOO = *Package::FOO" कहकर इसे ओवरराइड करके
लिपियों.

"*x = \$y" तंत्र का उपयोग सस्ते संदर्भों को पास करने और वापस करने के लिए किया जा सकता है
यदि आप पूरी चीज़ की प्रतिलिपि नहीं बनाना चाहते हैं तो सबरूटीन्स। यह केवल असाइन करते समय ही काम करता है
गतिशील चर, शाब्दिक नहीं।

%some_hash = (); # मेरा नहीं हो सकता()
*some_hash = fn( \%another_hash );
उप एफएन {
स्थानीय *हैशसिम = शिफ्ट;
# अब सामान्य रूप से %hashsym का उपयोग करें, और आप
# कॉल करने वाले के %other_hash को प्रभावित करेगा
मेरा %nhash = (); # तुम्हें जो करना है करो
वापसी \%nhash;
}

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

प्रतीक तालिकाओं का एक अन्य उपयोग "स्थिर" अदिश राशि बनाने के लिए है।

*पीआई = \3.14159265358979;

अब आप $PI में परिवर्तन नहीं कर सकते, जो संभवतः कुल मिलाकर एक अच्छी बात है। यह वैसा नहीं है
एक स्थिर सबरूटीन के रूप में, जो संकलन-समय पर अनुकूलन के अधीन है। निरंतर
सबरूटीन कोई तर्क न लेने और एक स्थिर अभिव्यक्ति लौटाने के लिए एक प्रोटोटाइप है।
इन पर विवरण के लिए पर्लसब देखें। "निरंतर उपयोग करें" प्राग्मा एक सुविधाजनक आशुलिपि है
इन।

आप यह पता लगाने के लिए *foo{PACKAGE} और *foo{NAME} कह सकते हैं कि *foo प्रतीक का नाम और पैकेज क्या है
तालिका प्रविष्टि से आती है। यह एक सबरूटीन में उपयोगी हो सकता है जिसे टाइपग्लोब के रूप में पारित किया जाता है
तर्क:

उप पहचान_टाइपग्लोब {
मेरा $ग्लोब = शिफ्ट;
प्रिंट करें 'आपने मुझे दिया', *{$ग्लोब}{पैकेज},
'::', *{$ग्लोब}{नाम}, "\n";
}
पहचान_टाइपग्लोब *फू;
पहचान_टाइपग्लोब *बार::बाज़;

यह प्रिंट

आपने मुझे मुख्य::फू दिया
आपने मुझे बार::बाज़ दिया

*foo{THING} नोटेशन का उपयोग व्यक्तिगत तत्वों के संदर्भ प्राप्त करने के लिए भी किया जा सकता है
*फू का. पर्लरेफ़ देखें.

सबरूटीन परिभाषाएँ (और उस मामले के लिए घोषणाएँ) आवश्यक नहीं हैं
उस पैकेज में स्थित है जिसकी प्रतीक तालिका पर वे कब्जा करते हैं। आप एक सबरूटीन परिभाषित कर सकते हैं
सबरूटीन के नाम को स्पष्ट रूप से योग्य बनाकर इसके पैकेज के बाहर:

पैकेज मुख्य;
उप Som_package::foo { ... } # &foo को some_package में परिभाषित किया गया है

यह संकलन समय पर टाइपग्लोब असाइनमेंट के लिए सिर्फ एक आशुलिपि है:

प्रारंभ करें { *Some_package::foo = उप {... } }

और यह नहीं लिखने के समान:

{
पैकेज कुछ_पैकेज;
उप फू {...}
}

पहले दो संस्करणों में, सबरूटीन का मुख्य भाग शाब्दिक रूप से मुख्य पैकेज में है,
नहीं कुछ_पैकेज में. तो कुछ इस तरह:

पैकेज मुख्य;

$Some_package::name = "फ़्रेड";
$मुख्य::नाम = "बार्नी";

उप Som_package::foo {
"इन", __पैकेज__, "प्रिंट करें: \$नाम '$नाम'\n" है;
}

Som_package::foo();

प्रिंट:

मुख्य में: $नाम 'बार्नी' है

इसके बजाय:

Som_package में: $नाम 'फ़्रेड' है

इसका SUPER:: क्वालीफायर (perlobj देखें) के उपयोग पर भी प्रभाव पड़ता है।

शुरू करना, यूनिटचेक, जाँच करना, INIT और अंत
पांच विशेष रूप से नामित कोड ब्लॉक को शुरुआत में और रनिंग के अंत में निष्पादित किया जाता है
पर्ल कार्यक्रम. ये "BEGIN", "UNITCHECK", "CHECK", "INIT" और "END" ब्लॉक हैं।

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

एक "BEGIN" कोड ब्लॉक को जितनी जल्दी हो सके निष्पादित किया जाता है, अर्थात, वह क्षण जब यह पूरी तरह से निष्पादित हो जाता है
परिभाषित, शेष युक्त फ़ाइल (या स्ट्रिंग) को पार्स करने से पहले भी। शायद आपके पास
एक फ़ाइल के भीतर एकाधिक "BEGIN" ब्लॉक (या eval'ed स्ट्रिंग); वे क्रम में निष्पादित करेंगे
परिभाषा। क्योंकि "BEGIN" कोड ब्लॉक तुरंत निष्पादित होता है, यह परिभाषाएँ खींच सकता है
सबरूटीन्स और इस तरह की अन्य फ़ाइलों को समय पर शेष संकलन में दृश्यमान बनाने के लिए
और चलाने का समय. एक बार "BEGIN" चलने के बाद, यह तुरंत अपरिभाषित हो जाता है और इसके द्वारा उपयोग किया जाने वाला कोई भी कोड अपरिभाषित हो जाता है
पर्ल के मेमोरी पूल में वापस आ गया।

एक "END" कोड ब्लॉक को यथासंभव देर से निष्पादित किया जाता है, अर्थात, पर्ल समाप्त होने के बाद
प्रोग्राम चलाना और दुभाषिया के बाहर निकलने से ठीक पहले, भले ही वह बाहर निकल रहा हो
एक का एक परिणाम के रूप में मरने () समारोह। (लेकिन तब नहीं जब इसे किसी अन्य प्रोग्राम में रूपांतरित किया जा रहा हो
"निष्पादन", या एक संकेत द्वारा पानी से बाहर उड़ाया जा रहा है - आपको इसे स्वयं फँसाना होगा (यदि
आप कर सकते हैं)।) आपके पास एक फ़ाइल के भीतर कई "END" ब्लॉक हो सकते हैं - वे रिवर्स में निष्पादित होंगे
परिभाषा का क्रम; वह है: आखिरी अंदर, पहले बाहर (LIFO)। "END" ब्लॉक निष्पादित नहीं होते हैं
जब आप "-सी" स्विच के साथ पर्ल चलाते हैं, या यदि संकलन विफल हो जाता है।

ध्यान दें कि "END" कोड ब्लॉक हैं नहीं एक स्ट्रिंग के अंत में निष्पादित "eval()": यदि कोई हो तो "END"
कोड ब्लॉक एक स्ट्रिंग "eval()" में बनाए जाते हैं, उन्हें किसी अन्य की तरह ही निष्पादित किया जाएगा
दुभाषिया के ठीक पहले LIFO क्रम में उस पैकेज का "END" कोड ब्लॉक
निकल गया।

"END" कोड ब्लॉक के अंदर, $? इसमें वह मान शामिल है जिसे प्रोग्राम पास करने जा रहा है
"बाहर निकलना()"। आप $ को संशोधित कर सकते हैं? प्रोग्राम के निकास मान को बदलने के लिए। बदलने से सावधान रहें
$? दुर्घटनावश (उदाहरण के लिए "सिस्टम" के माध्यम से कुछ चलाकर)।

"END" ब्लॉक के अंदर, "${^GLOBAL_PHASE}" का मान "END" होगा।

"UNITCHECK", "CHECK" और "INIT" कोड ब्लॉक के बीच संक्रमण को पकड़ने के लिए उपयोगी हैं
संकलन चरण और मुख्य कार्यक्रम का निष्पादन चरण।

"UNITCHECK" ब्लॉक उस इकाई के संकलित होने के ठीक बाद चलाए जाते हैं जिसने उन्हें परिभाषित किया है।
मुख्य प्रोग्राम फ़ाइल और उसके द्वारा लोड किया गया प्रत्येक मॉड्यूल संकलन इकाइयाँ हैं, जैसे स्ट्रिंग "eval" हैं,
रन-टाइम कोड को रेगेक्स में "(?{ })" निर्माण का उपयोग करके संकलित किया गया है, "फ़ाइल करें" पर कॉल करता है,
"फ़ाइल की आवश्यकता है", और कमांड लाइन पर "-e" स्विच के बाद कोड।

"BEGIN" और "UNITCHECK" ब्लॉक सीधे दुभाषिया के चरण से संबंधित नहीं हैं।
इन्हें किसी भी चरण के दौरान बनाया और क्रियान्वित किया जा सकता है।

"चेक" कोड ब्लॉक ठीक इसके बाद चलाए जाते हैं प्रारंभिक पर्ल संकलन चरण समाप्त होता है और उससे पहले
रन टाइम शुरू होता है, LIFO क्रम में। पर्ल कंपाइलर सूट में "चेक" कोड ब्लॉक का उपयोग किया जाता है
प्रोग्राम की संकलित स्थिति को सहेजने के लिए।

"CHECK" ब्लॉक के अंदर, "${^GLOBAL_PHASE}" का मान "CHECK" होगा।

पर्ल रनटाइम के निष्पादन शुरू होने से ठीक पहले "INIT" ब्लॉक चलाए जाते हैं, "फर्स्ट इन, फर्स्ट" में
बाहर" (फीफो) आदेश।

"INIT" ब्लॉक के अंदर, "${^GLOBAL_PHASE}" का मान "INIT" होगा।

"आवश्यकता", स्ट्रिंग "डू", या स्ट्रिंग "eval" द्वारा संकलित कोड में "चेक" और "आईएनआईटी" ब्लॉक
यदि वे मुख्य संकलन चरण की समाप्ति के बाद घटित होते हैं तो उन्हें निष्पादित नहीं किया जाएगा; वह हो सकता है
mod_perl और अन्य लगातार वातावरणों में एक समस्या हो जो उन कार्यों का उपयोग करते हैं
रनटाइम पर कोड लोड करें।

जब आप उपयोग करते हैं -n और -p पर्ल पर स्विच, "BEGIN" और "END" वैसे ही काम करते हैं जैसे वे करते हैं
awk, एक पतित मामले के रूप में। जब आप इसका उपयोग करते हैं तो "BEGIN" और "CHECK" दोनों ब्लॉक चलते हैं -c
केवल-संकलन सिंटैक्स जाँच के लिए स्विच करें, हालाँकि आपका मुख्य कोड नहीं है।

RSI जाँच शुरू करें कार्यक्रम अंततः यह सब स्पष्ट कर देता है:

#!/usr/bin/perl

#चेक शुरू करें

प्रिंट करें "10. साधारण कोड रनटाइम पर चलता है।\n";

END { प्रिंट "16। तो यह कहानी का अंत है।\n" }
INIT { print " 7. INIT ब्लॉक रनटाइम से ठीक पहले FIFO चलाते हैं।\n" }
यूनिटचेक {
प्रिंट करें " 4. और इसलिए किसी भी चेक ब्लॉक से पहले।\n"
}
CHECK { print " 6. तो यह छठी पंक्ति है।\n" }

प्रिंट करें "11. यह निश्चित रूप से क्रम में चलता है।\n";

BEGIN { print " 1. BEGIN ब्लॉक संकलन के दौरान FIFO चलाते हैं।\n" }
END {प्रिंट "15। शेष कहानी के लिए पर्लमॉड पढ़ें।\n" }
चेक करें { प्रिंट करें " 5. चेक ब्लॉक सभी संकलन के बाद LIFO चलाते हैं।\n" }
INIT { print " 8. पर्ल के -c स्विच का उपयोग करके इसे फिर से चलाएँ।\n" }

प्रिंट करें "12. यह एंटी-ओबफस्केटेड कोड है।\n";

END {प्रिंट "14. END ब्लॉक छोड़ने के समय LIFO चलाते हैं।\n" }
BEGIN { print " 2. तो यह पंक्ति दूसरे स्थान पर आती है।\n" }
यूनिटचेक {
प्रिंट करें " 3. प्रत्येक फ़ाइल संकलित होने के बाद UNITCHECK ब्लॉक LIFO चलाते हैं।\n"
}
INIT { प्रिंट " 9. आपको तुरंत अंतर दिखाई देगा।\n" }

प्रिंट करें "13. ऐसा केवल _लगता_है_ कि इसे भ्रमित करना चाहिए।\n";

__समाप्त__

पर्ल क्लासेज
पर्ल में कोई विशेष क्लास सिंटैक्स नहीं है, लेकिन यदि कोई पैकेज प्रदान करता है तो वह क्लास के रूप में कार्य कर सकता है
तरीकों के रूप में कार्य करने के लिए सबरूटीन्स। ऐसा पैकेज अपनी कुछ विधियाँ भी प्राप्त कर सकता है
इसके वैश्विक @ISA सरणी में अन्य पैकेज नामों को सूचीबद्ध करके एक अन्य वर्ग (पैकेज)।
(जो एक वैश्विक पैकेज होना चाहिए, शाब्दिक नहीं)।

इस पर अधिक जानकारी के लिए, perloutut और perlobj देखें।

पर्ल मॉड्यूल
एक मॉड्यूल एक लाइब्रेरी फ़ाइल में संबंधित फ़ंक्शंस का एक सेट है, यानी, एक पर्ल पैकेज
फ़ाइल के समान नाम. इसे विशेष रूप से अन्य मॉड्यूल द्वारा पुन: प्रयोज्य होने के लिए डिज़ाइन किया गया है
कार्यक्रम. यह अपने कुछ प्रतीकों को निर्यात करने के लिए एक तंत्र प्रदान करके ऐसा कर सकता है
इसका उपयोग करने वाले किसी भी पैकेज की प्रतीक तालिका, या यह एक वर्ग परिभाषा के रूप में कार्य कर सकती है
कक्षा और उसकी वस्तुओं पर विधि कॉल के माध्यम से इसके शब्दार्थ को अंतर्निहित रूप से उपलब्ध कराना,
स्पष्ट रूप से कुछ भी निर्यात किए बिना। या यह दोनों में से थोड़ा-थोड़ा कर सकता है।

उदाहरण के लिए, कुछ::मॉड्यूल नामक एक पारंपरिक, गैर-ओओ मॉड्यूल शुरू करने के लिए, एक फ़ाइल बनाएं
बुलाया कुछ/मॉड्यूल.दोपहर और इस टेम्पलेट से प्रारंभ करें:

पैकेज कुछ::मॉड्यूल; # कुछ/मॉड्यूल.बजे मानता है

सख्त उपयोग करें;
चेतावनी का उपयोग करें;

शुरू {
निर्यातक की आवश्यकता है;

# संस्करण जाँच के लिए संस्करण सेट करें
हमारा $संस्करण = 1.00;

# निर्यातक से निर्यात कार्यों और चर को प्राप्त करें
हमारा @ISA = qw(निर्यातक);

# फ़ंक्शन और वेरिएबल जो डिफ़ॉल्ट रूप से निर्यात किए जाते हैं
हमारा @EXPORT = qw(func1 func2);

# फ़ंक्शन और वेरिएबल जिन्हें वैकल्पिक रूप से निर्यात किया जा सकता है
हमारा @EXPORT_OK = qw($Var1 %Hashit func3);
}

# निर्यातित पैकेज ग्लोबल यहां जाएं
हमारा $Var1 = '';
हमारा %हैशिट = ();

# गैर-निर्यातित पैकेज ग्लोबल यहां जाते हैं
# (वे अभी भी $Some::Module::stuff के रूप में पहुंच योग्य हैं)
हमारा @अधिक = ();
हमारा $ सामान = '';

# फ़ाइल-प्राइवेट लेक्सिकल यहां जाते हैं, उनका उपयोग करने वाले किसी भी फ़ंक्शन से पहले
मेरा $priv_var = '';
मेरा %secret_hash = ();

# यहां क्लोजर के रूप में एक फाइल-प्राइवेट फ़ंक्शन है,
# $priv_func->() के रूप में कॉल करने योग्य;
मेरा $priv_func = उप {
...
};

# अपने सभी कार्य करें, चाहे निर्यात किया गया हो या नहीं;
# {} स्टब्स में कुछ दिलचस्प डालना याद रखें
उप func1 { ... }
उप func2 { ... }

# इसे निर्यात नहीं किया जाता है, लेकिन इसे सीधे कॉल किया जा सकता है
# कुछ::मॉड्यूल::func3() के रूप में
उप func3 { ... }

END { ... } # मॉड्यूल क्लीन-अप कोड यहां (वैश्विक विध्वंसक)

1; # फ़ाइल से सही मान लौटाना न भूलें

फिर बिना किसी योग्यता के फ़ंक्शंस में अपने वेरिएबल्स को घोषित करने और उनका उपयोग करने के लिए आगे बढ़ें। देखना
मॉड्यूल निर्माण में यांत्रिकी और शैली के मुद्दों पर विवरण के लिए निर्यातक और पर्लमोडलिब।

पर्ल मॉड्यूल को कहकर आपके प्रोग्राम में शामिल किया जाता है

मॉड्यूल का उपयोग करें;

or

मॉड्यूल सूची का उपयोग करें;

यह बिलकुल इसके बराबर है

शुरू करें { 'मॉड्यूल.पीएम' की आवश्यकता है; 'मॉड्यूल'->आयात; }

or

शुरू करें { 'मॉड्यूल.पीएम' की आवश्यकता है; 'मॉड्यूल'->आयात(सूची); }

एक विशेष मामले के रूप में

मॉड्यूल का उपयोग करें ();

बिल्कुल बराबर है exactly

शुरू करें { 'मॉड्यूल.पीएम' की आवश्यकता है; }

सभी पर्ल मॉड्यूल फ़ाइलों में एक्सटेंशन होता है .pm. "उपयोग" ऑपरेटर यह मानता है कि आप ऐसा करते हैं
बताने की ज़रूरत नहीं है"मॉड्यूल.दोपहर"उद्धरण में। इससे नए को अलग करने में भी मदद मिलती है
पुराने से मॉड्यूल .pl और .ph फ़ाइलें. मॉड्यूल नाम भी बड़े अक्षरों में लिखे जाते हैं जब तक कि ऐसा न हो
व्यावहारिक के रूप में कार्य करना; व्यावहारिक रूप से संकलक निर्देश प्रभावी होते हैं, और कभी-कभी होते हैं
इसे "व्यावहारिक मॉड्यूल" कहा जाता है (या यदि आप एक क्लासिकिस्ट हैं तो "प्रैगमाटा") भी कहा जाता है।

दो कथन:

कुछ मॉड्यूल की आवश्यकता है;
"SomeModule.pm" की आवश्यकता है;

दो प्रकार से एक दूसरे से भिन्न हैं। पहले मामले में, मॉड्यूल में कोई भी डबल कोलन
नाम, जैसे "कुछ::मॉड्यूल", आपके सिस्टम के निर्देशिका विभाजक में अनुवादित होते हैं,
आम तौर पर "/"। दूसरा मामला ऐसा नहीं है, और इसे शब्दशः निर्दिष्ट करना होगा।
अन्य अंतर यह है कि कंपाइलर में पहले "आवश्यकता" सुराग देखना जो इसका उपयोग करता है
अप्रत्यक्ष ऑब्जेक्ट नोटेशन में "SomeModule" शामिल है, जैसा कि "$ob = purge someModule" में है
विधि कॉल, फ़ंक्शन कॉल नहीं। (हां, इससे वास्तव में फर्क पड़ सकता है।)

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

सीडब्ल्यूडी की आवश्यकता है; # Cwd:: को सुलभ बनाएं
$यहाँ = Cwd::getcwd();

सीडब्ल्यूडी का प्रयोग करें; # सीडब्ल्यूडी से नाम आयात करें::
$यहाँ = getcwd();

सीडब्ल्यूडी की आवश्यकता है; # Cwd:: को सुलभ बनाएं
$यहाँ = getcwd(); #उफ़! कोई मुख्य नहीं::getcwd()

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

पर्ल पैकेज को अन्य पैकेज नामों के अंदर नेस्ट किया जा सकता है, इसलिए हमारे पास पैकेज नाम हो सकते हैं
जिसमें "::" शामिल है। लेकिन अगर हम उस पैकेज नाम को सीधे फ़ाइल नाम के रूप में उपयोग करते हैं तो यह बन जाएगा
कुछ प्रणालियों पर बोझिल या असंभव फ़ाइल नामों के लिए। इसलिए, यदि किसी मॉड्यूल का नाम है,
कहें, "टेक्स्ट::साउंडेक्स", तो इसकी परिभाषा वास्तव में लाइब्रेरी फ़ाइल में पाई जाती है
टेक्स्ट/साउंडएक्स.पी.एम.

पर्ल मॉड्यूल में हमेशा एक होता है .pm फ़ाइल, लेकिन गतिशील रूप से जुड़े निष्पादनयोग्य भी हो सकते हैं
(अक्सर समाप्त होता है .so) या ऑटोलोडेड सबरूटीन परिभाषाएँ (अक्सर इसमें समाप्त होती हैं .al)
मॉड्यूल से संबद्ध. यदि हां, तो ये उपयोगकर्ता के लिए पूरी तरह से पारदर्शी होंगे
मापांक। की जिम्मेदारी है .pm किसी भी फ़ाइल को लोड करने (या ऑटोलोड करने की व्यवस्था करने) के लिए
अतिरिक्त कार्यक्षमता. उदाहरण के लिए, हालाँकि POSIX मॉड्यूल दोनों कार्य करता है
डायनामिक लोडिंग और ऑटोलोडिंग, उपयोगकर्ता यह सब प्राप्त करने के लिए बस "POSIX का उपयोग करें" कह सकता है।

निर्माण तुंहारे मॉड्यूल सूत की अलमारी
पर्ल एक प्रकार के थ्रेड्स का समर्थन करता है जिन्हें इंटरप्रेटर थ्रेड्स (आईथ्रेड्स) कहा जाता है। ये धागे कर सकते हैं
स्पष्ट और अप्रत्यक्ष रूप से उपयोग किया जाना चाहिए।

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

यदि आप सभी वस्तुओं को क्लोन करना चाहते हैं तो आपको प्रति पैकेज उनका ट्रैक रखना होगा। यह है
बस हैश और का उपयोग करके किया गया अदिश::उपयोग::कमज़ोर().

5.8.7 के बाद पर्ल के पास "CLONE_SKIP" विशेष सबरूटीन के लिए समर्थन है। जैसे "क्लोन",
"CLONE_SKIP" को प्रति पैकेज एक बार कॉल किया जाता है; हालाँकि, इसे क्लोनिंग शुरू होने से ठीक पहले कहा जाता है,
और मूल सूत्र के संदर्भ में। यदि यह सही मान लौटाता है, तो कोई ऑब्जेक्ट नहीं
उस वर्ग का क्लोन बनाया जाएगा; या यों कहें, उन्हें अप्रकाशित, अपरिभाषित मूल्यों के रूप में कॉपी किया जाएगा। के लिए
उदाहरण: यदि मूल में एक ही धन्य हैश के दो संदर्भ हैं, तो
बच्चे के स्थान पर एकल अपरिभाषित अदिश मान के दो संदर्भ होंगे। यह
मॉड्यूल को थ्रेडसेफ़ बनाने के लिए एक सरल तंत्र प्रदान करता है; बस "उप CLONE_SKIP { 1 जोड़ें
}" कक्षा के शीर्ष पर, और "DESTROY()" को अब प्रति ऑब्जेक्ट केवल एक बार कॉल किया जाएगा।
बेशक, यदि चाइल्ड थ्रेड को वस्तुओं का उपयोग करने की आवश्यकता है, तो यह अधिक परिष्कृत है
दृष्टिकोण की आवश्यकता है.

"CLONE" की तरह, "CLONE_SKIP" को वर्तमान में इनवॉकेंट के अलावा किसी अन्य पैरामीटर के साथ नहीं कहा जाता है
पैकेज का नाम, हालाँकि वह बदल सकता है। इसी तरह, भविष्य में विस्तार की अनुमति देने के लिए
वापसी मान एकल 0 या 1 मान होना चाहिए।

onworks.net सेवाओं का उपयोग करके ऑनलाइन perlmod का उपयोग करें