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

कार्यक्रम:

नाम

पर्लवर - पर्ल पूर्वनिर्धारित चर

वर्णन

RSI वाक्य - विन्यास of परिवर्तनीय नाम
पर्ल में परिवर्तनीय नामों के कई प्रारूप हो सकते हैं। आमतौर पर, उन्हें एक अक्षर से शुरू करना चाहिए
या अंडरस्कोर, जिस स्थिति में वे मनमाने ढंग से लंबे हो सकते हैं (251 की आंतरिक सीमा तक)
अक्षर) और इसमें अक्षर, अंक, अंडरस्कोर या विशेष अनुक्रम "::" या शामिल हो सकते हैं
"'"। इस मामले में, अंतिम "::" या "'" से पहले वाले भाग को लिया जाता है पैकेज
क्वालीफायर; पर्लमॉड देखें.

पर्ल वैरिएबल नाम अंकों का अनुक्रम या एकल विराम चिह्न या नियंत्रण भी हो सकते हैं
चरित्र (शाब्दिक नियंत्रण चरित्र प्रपत्र के साथ बहिष्कृत)। ये सभी नाम हैं
पर्ल द्वारा विशेष उपयोग के लिए आरक्षित; उदाहरण के लिए, सभी अंकों वाले नामों का उपयोग डेटा रखने के लिए किया जाता है
रेगुलर एक्सप्रेशन मैच के बाद बैकरेफरेंस द्वारा कैप्चर किया गया। पर्ल का एक विशेष वाक्यविन्यास है
एकल-नियंत्रण-वर्ण नामों के लिए: इसका अर्थ "^X" (कैरेट "X") है
नियंत्रण-"X" अक्षर. उदाहरण के लिए, अंकन $^W (डॉलर-चिह्न कैरेट "W") है
अदिश चर जिसका नाम एकल वर्ण नियंत्रण-"W" है। ये इससे बेहतर है
अपने प्रोग्राम में शाब्दिक नियंत्रण-"W" टाइप करना।

पर्ल v5.6.0 के बाद से, पर्ल वेरिएबल नाम अल्फ़ान्यूमेरिक स्ट्रिंग हो सकते हैं जो कैरेट से शुरू होते हैं
(या एक नियंत्रण चरित्र, लेकिन यह फ़ॉर्म अप्रचलित है)। इन वेरिएबल्स को अवश्य लिखा जाना चाहिए
प्रपत्र "${^Foo}"; ब्रेसिज़ वैकल्पिक नहीं हैं. "${^Foo}" अदिश चर को दर्शाता है
जिसका नाम एक नियंत्रण है- "F" जिसके बाद दो "o" हैं। ये वेरिएबल्स के लिए आरक्षित हैं
पर्ल द्वारा भविष्य में विशेष उपयोग, "^_" (कंट्रोल-अंडरस्कोर) से शुरू होने वाले उपयोगों को छोड़कर
या कैरेट-अंडरस्कोर)। "^_" से शुरू होने वाला कोई भी नियंत्रण-वर्ण नाम प्राप्त नहीं होगा
पर्ल के किसी भी भावी संस्करण में विशेष अर्थ; इसलिए ऐसे नामों का उपयोग सुरक्षित रूप से किया जा सकता है
कार्यक्रम. हालाँकि, $^_ स्वयं, is आरक्षित।

पर्ल पहचानकर्ता जो अंकों, नियंत्रण वर्णों या विराम चिह्नों से शुरू होते हैं
"पैकेज" घोषणा के प्रभाव से मुक्त हैं और हमेशा इसमें रहने के लिए मजबूर हैं
पैकेज "मुख्य"; उन्हें "सख्त 'वर्स'" त्रुटियों से भी छूट है। कुछ और नाम हैं
इन तरीकों से भी छूट:

एनवी एसटीडीआईएन
इंक स्टडआउट
एआरजीवी एसटीडीईआर
ARGVOUT
हस्ताक्षर

विशेष रूप से, विशेष "${^_XYZ}" वेरिएबल को हमेशा पैकेज "मुख्य" में माना जाता है।
वर्तमान में दायरे में आने वाले किसी भी "पैकेज" घोषणा की परवाह किए बिना।

विशेष चर

निम्नलिखित नामों का पर्ल के लिए विशेष अर्थ है। अधिकांश विराम चिन्ह उचित होते हैं
निमोनिक्स, या गोले में एनालॉग्स। फिर भी, यदि आप long वेरिएबल का उपयोग करना चाहते हैं
नाम, आपको केवल यह कहना होगा:

अंग्रेजी का उपयोग करो;

आपके प्रोग्राम के शीर्ष पर. यह सभी छोटे नामों को लंबे नामों में बदल देता है
वर्तमान पैकेज। कुछ के पास मध्यम नाम भी हैं, जो आम तौर पर उधार लिए गए हैं awk. अधिक जानकारी के लिए
जानकारी, कृपया अंग्रेजी देखें।

जारी रखने से पहले, चरों के क्रम पर ध्यान दें। सामान्य तौर पर, हम पहले सूचीबद्ध करते हैं
केस-असंवेदनशील, लगभग-लेक्सिग्राफ़िकल क्रम में चर ("{" या "^" को अनदेखा करते हुए)
पूर्ववर्ती शब्द, जैसे "${^UNICODE}" या $^T), हालांकि $_ और @_ शीर्ष पर चले जाते हैं
ढेर। समान पहचानकर्ता वाले चर के लिए, हम इसे स्केलर, सरणी, हैश के क्रम में सूचीबद्ध करते हैं।
और नंगे शब्द.

सामान्य जानकारी चर
$एआरजी
$_ डिफ़ॉल्ट इनपुट और पैटर्न-खोज स्थान। निम्नलिखित युग्म हैं
समकक्ष:

while (<>) {...} # केवल while में समतुल्य!
जबकि (परिभाषित($_ = <>)) {...}

/^विषय:/
$_ =~ /^विषय:/

tr/az/AZ/
$_ =~ tr/az/AZ/

chomp
चॉम्प($_)

यहां वे स्थान हैं जहां पर्ल $_ मान लेगा, भले ही आप इसका उपयोग न करें:

· निम्नलिखित फ़ंक्शन डिफ़ॉल्ट तर्क के रूप में $_ का उपयोग करते हैं:

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

· "-t" को छोड़कर सभी फ़ाइल परीक्षण ("-f", "-d"), जो STDIN पर डिफ़ॉल्ट है। "-X" देखें
पर्लफंक में

· पैटर्न मिलान संचालन "एम //", "एस ///" और "टीआर ///" (उर्फ "वाई ///") जब
"=~" ऑपरेटर के बिना उपयोग किया जाता है।

· यदि कोई अन्य वेरिएबल नहीं है तो "foreach" लूप में डिफ़ॉल्ट इटरेटर वैरिएबल
आपूर्ति की।

· "grep()" और "map()" फ़ंक्शंस में अंतर्निहित इटरेटर वैरिएबल।

· "दिया गया()" का अंतर्निहित चर।

· अगला मान या इनपुट रिकॉर्ड डालने का डिफ़ॉल्ट स्थान जब " ",
"रीडलाइन", "रीडिर" या "प्रत्येक" ऑपरेशन के परिणाम का परीक्षण स्वयं के रूप में किया जाता है
"समय" परीक्षण का एकमात्र मानदंड। "थोड़ी देर" परीक्षण के बाहर, ऐसा नहीं होगा
होता है.

$_ डिफ़ॉल्ट रूप से एक वैश्विक चर है। हालाँकि, perl v5.10.0 के अनुसार, आप a का उपयोग कर सकते हैं
$_ का शाब्दिक संस्करण इसे किसी फ़ाइल में या "my" वाले ब्लॉक में घोषित करके।
इसके अलावा, "हमारा $_" घोषित करने से वर्तमान दायरे में वैश्विक $_ पुनर्स्थापित हो जाता है। यद्यपि
जिस समय इसे पेश किया गया था उस समय यह एक अच्छा विचार प्रतीत होता था, वास्तव में शाब्दिक $_
यह समाधान करने की अपेक्षा अधिक समस्याएँ पैदा करता है। यदि आप किसी ऐसे फ़ंक्शन को कॉल करते हैं जो होने की उम्मीद करता है
$_ के माध्यम से जानकारी पारित की गई, यह काम कर भी सकता है और नहीं भी, यह इस बात पर निर्भर करता है कि फ़ंक्शन कैसा है
लिखा है, इसे हल करने का कोई आसान तरीका नहीं है। बस शाब्दिक $_ से बचें,
जब तक कि आप विशेष रूप से पुरुषवादी महसूस न कर रहे हों। इस कारण शाब्दिक $_ है
अभी भी प्रयोगात्मक है और जब तक चेतावनियाँ अक्षम नहीं की जातीं तब तक यह एक चेतावनी उत्पन्न करेगा।
अन्य प्रायोगिक विशेषताओं की तरह, शाब्दिक $_ का व्यवहार इसके अधीन है
बिना सूचना के परिवर्तन, जिसमें घातक त्रुटि में परिवर्तन भी शामिल है।

स्मरणीय: कुछ कार्यों में अंडरलाइन को समझा जाता है।

@ARG
@_ एक सबरूटीन के भीतर सरणी @_ में पास किए गए पैरामीटर शामिल होते हैं
सबरूटीन. सबरूटीन के अंदर, @_ ऐरे ऑपरेटरों के लिए डिफ़ॉल्ट ऐरे है
"पॉप" और "शिफ्ट"।

पर्लसब देखें.

$LIST_SEPARATOR
$" जब एक सरणी या एक सरणी स्लाइस को डबल-कोटेड स्ट्रिंग या ए में इंटरपोल किया जाता है
समान संदर्भ जैसे "/.../", इसके तत्वों को इस मान से अलग किया जाता है।
डिफ़ॉल्ट एक स्थान है. उदाहरण के लिए, यह:

प्रिंट करें "सरणी है: @array\n";

इसके समतुल्य है:

प्रिंट करें "सरणी है:"। सम्मिलित हों($", @array) . "\n";

स्मरणीय: दोहरे उद्धरण वाले संदर्भ में काम करता है।

$PROCESS_ID
$पीआईडी
$$ इस स्क्रिप्ट को चलाने वाले पर्ल की प्रक्रिया संख्या। यद्यपि आप कर सकते हैं इसे सेट करें
परिवर्तनीय, ऐसा करना आमतौर पर हतोत्साहित किया जाता है, हालाँकि यह अमूल्य हो सकता है
कुछ परीक्षण उद्देश्य. यह "फोर्क()" कॉलों पर स्वचालित रूप से रीसेट हो जाएगा।

लिनक्स और डेबियन जीएनयू/केफ्रीबीएसडी उपयोगकर्ताओं के लिए नोट: पर्ल v5.16.0 से पहले पर्ल होगा
आंशिक LinuxThreads का उपयोग करके Linux सिस्टम पर POSIX शब्दार्थ का अनुकरण करें
POSIX थ्रेड्स का कार्यान्वयन जिसे तब से नेटिव POSIX द्वारा प्रतिस्थापित कर दिया गया है
थ्रेड लाइब्रेरी (एनपीटीएल)।

LinuxThreads अब Linux पर अप्रचलित है, और इस तरह "getpid()" को कैशिंग किया गया है
पर्ल को एंबेड करना अनावश्यक रूप से जटिल है (क्योंकि आपको इसे मैन्युअल रूप से अपडेट करना होगा
$$ का मान), इसलिए अब $$ और "getppid()" हमेशा वही मान लौटाएंगे
अंतर्निहित सी लाइब्रेरी।

डेबियन जीएनयू/केफ्रीबीएसडी सिस्टम ने 6.0 तक लिनक्सथ्रेड्स का भी उपयोग किया
रिलीज, लेकिन उसके बाद फ्रीबीएसडी थ्रेड सेमेन्टिक्स में स्थानांतरित हो गया, जो POSIX-जैसे हैं।

यह देखने के लिए कि क्या आपका सिस्टम इस विसंगति से प्रभावित है, जाँचें कि क्या "getconf
GNU_LIBPTHREAD_संस्करण | grep -q NPTL" गलत मान लौटाता है। NTPL थ्रेड्स
POSIX शब्दार्थ को सुरक्षित रखें।

स्मरणीय: सीपियों के समान।

$PROGRAM_NAME
$0 में निष्पादित प्रोग्राम का नाम शामिल है।

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

ध्यान दें कि $0 की ​​अधिकतम लंबाई पर प्लेटफ़ॉर्म-विशिष्ट सीमाएँ हैं। में
सबसे चरम स्थिति में यह मूल $0 के कब्जे वाले स्थान तक सीमित हो सकता है।

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

बीएसडी उपयोगकर्ताओं के लिए नोट: $0 सेट करने से "perl" पूरी तरह से नहीं हटता है ps(1)
आउटपुट. उदाहरण के लिए, $0 को "foobar" पर सेट करने का परिणाम "perl: foobar (perl)" हो सकता है।
(क्या दोनों "perl:" उपसर्ग और "(perl)" प्रत्यय दिखाए गए हैं यह इस पर निर्भर करता है
आपका सटीक बीएसडी संस्करण और संस्करण)। यह एक ऑपरेटिंग सिस्टम फीचर है, पर्ल
इसके लिए कुछ नहीं किया जा सकता।

मल्टीथ्रेडेड स्क्रिप्ट में पर्ल थ्रेड्स का समन्वय करता है ताकि कोई भी थ्रेड ऐसा कर सके
$0 की ​​इसकी प्रति को संशोधित करें और परिवर्तन दृश्यमान हो जाएगा ps(1) (यह मानते हुए
ऑपरेटिंग सिस्टम साथ चलता है)। ध्यान दें कि अन्य थ्रेड्स का दृश्य $0 है
नहीं बदलेगा क्योंकि उनके पास इसकी अपनी प्रतियाँ हैं।

यदि प्रोग्राम "-ई" या "-ई" स्विच के माध्यम से पर्ल को दिया गया है, तो $0 होगा
स्ट्रिंग "-ई" शामिल है।

Linux पर perl v5.14.0 के अनुसार लीगेसी प्रक्रिया का नाम सेट किया जाएगा prctl(2), में
जैसा कि पर्ल ने संस्करण के बाद से किया है, "argv[0]" के माध्यम से POSIX नाम को बदलने के अलावा
4.000. अब सिस्टम उपयोगिताएँ जो विरासत प्रक्रिया का नाम पढ़ती हैं जैसे कि पीएस, टॉप और
$0 असाइन करते समय किलऑल आपके द्वारा सेट किए गए नाम को पहचान लेगा। स्ट्रिंग आप
16 बाइट्स पर आपूर्ति बंद कर दी जाएगी, यह लिनक्स द्वारा लगाई गई सीमा है।

स्मरणीय: के समान sh और क्ष.

$वास्तविक_समूह_आईडी
$जीआईडी
$( इस प्रक्रिया की वास्तविक जानकारी। यदि आप ऐसी मशीन पर हैं जो सदस्यता का समर्थन करती है
एक साथ कई समूह, उन समूहों की एक अलग सूची देता है जिनमें आप हैं।
पहला नंबर वह है जो "getgid()" द्वारा लौटाया जाता है, और बाद वाला नंबर "getgid()" द्वारा लौटाया जाता है
"getgroups()", जिनमें से एक पहले नंबर के समान हो सकता है।

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

आप इसका उपयोग करके एक ही समय में वास्तविक gid और प्रभावी gid दोनों को बदल सकते हैं
"POSIX::setgid()"। किसी भी संभावित का पता लगाने के लिए $( में परिवर्तन के लिए $! की जांच की आवश्यकता होती है
परिवर्तन के प्रयास के बाद त्रुटियाँ।

स्मरणीय: कोष्ठक का उपयोग किया जाता है समूह चीज़ें। असली मार्गदर्शन तो आप ही समूह हैं
बाएं, यदि आप सेटगिड चला रहे हैं।

$प्रभावी_GROUP_ID
$EGID
$) इस प्रक्रिया का प्रभावी मार्गदर्शन। यदि आप ऐसी मशीन पर हैं जो सपोर्ट करती है
एक साथ कई समूहों में सदस्यता, एक स्थान से अलग सूची देती है
जिन समूहों में आप हैं। पहला नंबर वह है जो "गेटेगिड()" द्वारा लौटाया जाता है, और
बाद वाले "getgroups()" द्वारा, जिनमें से एक पहले जैसा ही हो सकता है
संख्या.

इसी प्रकार, $) को निर्दिष्ट मान भी संख्याओं की एक स्थान-पृथक सूची होनी चाहिए।
पहला नंबर प्रभावी गिड सेट करता है, और बाकी (यदि कोई हो) को पास कर दिया जाता है
"सेटग्रुप्स()"। "सेटग्रुप्स ()" के लिए एक खाली सूची का प्रभाव प्राप्त करने के लिए, बस दोहराएँ
नई प्रभावी gid; अर्थात्, 5 की एक प्रभावी gid और एक प्रभावी ढंग से बाध्य करना
खाली "सेटग्रुप्स()" सूची, कहें " $) = "5 5" "।

आप इसका उपयोग करके एक ही समय में प्रभावी गिड और वास्तविक गिड दोनों को बदल सकते हैं
"POSIX::setgid()" (केवल एक संख्यात्मक तर्क का उपयोग करें)। $) में परिवर्तन की आवश्यकता है a
$ की जाँच करें! परिवर्तन के प्रयास के बाद किसी भी संभावित त्रुटि का पता लगाने के लिए।

$<, $>, $( और $) को केवल उन मशीनों पर सेट किया जा सकता है जो संबंधित का समर्थन करती हैं
सेट[पुनः][यूजी]आईडी() दिनचर्या। $( और $) को केवल समर्थन करने वाली मशीनों पर ही स्वैप किया जा सकता है
"सेट्रेगिड()"।

स्मरणीय: कोष्ठक का उपयोग किया जाता है समूह चीज़ें। प्रभावी उपाय समूह है
है कि सही आपके लिए, यदि आप सेटगिड चला रहे हैं।

$REAL_USER_ID
$यूआईडी
$< इस प्रक्रिया का वास्तविक यूआईडी। आप वास्तविक यूआईडी और प्रभावी दोनों को बदल सकते हैं
"POSIX::setuid()" का उपयोग करके एक ही समय में यूआईडी। चूँकि $< में परिवर्तन के लिए a की आवश्यकता होती है
सिस्टम कॉल, $ जांचें! परिवर्तन के बाद किसी भी संभावित त्रुटि का पता लगाने का प्रयास करें।

स्मरणीय: यह वह यूआईडी है जो आप आए थे से, यदि आप setuid चला रहे हैं।

$प्रभावी_USER_ID
$EUID
$> इस प्रक्रिया का प्रभावी यूआईडी. उदाहरण के लिए:

$< = $>; # वास्तविक को प्रभावी यूआईडी पर सेट करें
($<,$>) = ($>,$<); # वास्तविक और प्रभावी यूआईडी स्वैप करें

आप इसका उपयोग करके एक ही समय में प्रभावी यूआईडी और वास्तविक यूआईडी दोनों को बदल सकते हैं
"POSIX::setuid()"। $> में परिवर्तन के लिए $ के चेक की आवश्यकता होती है! किसी भी संभावित का पता लगाने के लिए
परिवर्तन के प्रयास के बाद त्रुटियाँ।

$< और $> को केवल "setreuid()" का समर्थन करने वाली मशीनों पर ही बदला जा सकता है।

स्मरणीय: यह वह यूआईडी है जिस पर आप गए थे सेवा मेरे, यदि आप setuid चला रहे हैं।

$SUBSCRIPT_SEPARATOR
$SUBSEP
$; बहुआयामी सरणी अनुकरण के लिए सबस्क्रिप्ट विभाजक। यदि आप एक का उल्लेख करते हैं
हैश तत्व के रूप में

$फू{$x,$y,$z}

इसका वास्तव में मतलब है

$foo{join($;, $x, $y, $z)}

लेकिन मत डालो

@foo{$x,$y,$z} # एक टुकड़ा--@ नोट करें

जिसका मतलब है

($फू{$x},$फू{$y},$फू{$z})

डिफ़ॉल्ट "\034" है, जो SUBSEP के समान है awk. यदि आपकी कुंजियों में बाइनरी डेटा है
$; के लिए कोई सुरक्षित मूल्य नहीं हो सकता है।

पेरलोल में वर्णित "वास्तविक" बहुआयामी सरणियों का उपयोग करने पर विचार करें।

स्मरणीय: अल्पविराम (वाक्यविन्यास सबस्क्रिप्ट विभाजक) एक अर्ध-अर्धविराम है।

$a
$b "सॉर्ट()" का उपयोग करते समय विशेष पैकेज वेरिएबल, perlfunc में "सॉर्ट" देखें। के कारण
इस विशेषता $a और $b को घोषित करने की आवश्यकता नहीं है ("वर्स का उपयोग करें" का उपयोग करके, या
"हमारा()") "सख्त 'वर्स'" प्राग्मा का उपयोग करते समय भी। उनके साथ शब्दाडंबर न करें
"मेरा $a" या "मेरा $b" यदि आप उन्हें "सॉर्ट()" तुलना में उपयोग करने में सक्षम होना चाहते हैं
ब्लॉक या फ़ंक्शन.

%ENV हैश %ENV में आपका वर्तमान वातावरण शामिल है। "ईएनवी" में मान सेट करने से परिवर्तन हो जाता है
किसी भी बच्चे के लिए पर्यावरण आपको बाद में "फोर्क ()" बंद कर देता है।

V5.18.0 के अनुसार, %ENV में संग्रहीत कुंजी और मान दोनों कड़े हैं।

मेरा $फू = 1;
$ENV{'bar'} = \$foo;
यदि(संदर्भ $ENV{'bar'} ) {
कहें "पूर्व 5.18.0 व्यवहार";
और} {
कहें "पोस्ट 5.18.0 व्यवहार";
}

पहले, केवल चाइल्ड प्रक्रियाओं को कड़े मान प्राप्त होते थे:

मेरा $फू = 1;
$ENV{'bar'} = \$foo;

# हमेशा 'नॉन रेफरी' प्रिंट करें
सिस्टम($^X, '-ई',
क्यू/प्रिंट (रेफरी $ENV{'बार'} ? 'रेफरी' : 'नॉन रेफरी' ) /);

ऐसा इसलिए होता है क्योंकि आप वास्तव में विदेशी डेटा संरचनाओं को विदेशी लोगों के साथ साझा नहीं कर सकते हैं
प्रक्रियाओं.

$OLD_PERL_संस्करण
$] पर्ल दुभाषिया का संशोधन, संस्करण और तोड़फोड़, एक के रूप में दर्शाया गया है
फॉर्म 5.XXXYYY का दशमलव, जहां XXX संस्करण / 1e3 है और YYY है
तोड़फोड़ / 1e6. उदाहरण के लिए, पर्ल v5.10.1 "5.010001" होगा।

इस वेरिएबल का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि पर्ल दुभाषिया निष्पादित कर रहा है या नहीं
स्क्रिप्ट संस्करणों की सही श्रेणी में है:

चेतावनी दें "नहीं पर्लिओ!\n" यदि $] lt '5.008';

$] की तुलना करते समय, स्ट्रिंग तुलना ऑपरेटर होते हैं अत्यधिक की सिफारिश की।
बाइनरी फ़्लोटिंग पॉइंट प्रतिनिधित्व की अंतर्निहित सीमाएँ कभी-कभी पैदा हो सकती हैं
कुछ आर्किटेक्चर पर कुछ संख्याओं की गलत तुलना।

सुविधाजनक के लिए "संस्करण का उपयोग करें" और "संस्करण की आवश्यकता है" का दस्तावेज़ भी देखें
यदि चल रहा पर्ल दुभाषिया बहुत पुराना है तो विफल होने का तरीका।

संस्करण ऑब्जेक्ट के रूप में पर्ल संस्करण के प्रतिनिधित्व के लिए "$^V" देखें, जो
अधिक लचीली स्ट्रिंग तुलना की अनुमति देता है।

$^V की तुलना में $] का मुख्य लाभ यह है कि यह किसी भी संस्करण पर समान रूप से काम करता है
पर्ल. नुकसान यह है कि इसकी तुलना अन्य संस्करणों से आसानी से नहीं की जा सकती
प्रारूप (जैसे शाब्दिक वी-स्ट्रिंग्स, "v1.2.3" या संस्करण ऑब्जेक्ट) और संख्यात्मक
तुलनाएँ कभी-कभी विफल हो सकती हैं; यह स्ट्रिंग शाब्दिक संस्करण की जाँच के लिए अच्छा है और
ऐसे वेरिएबल से तुलना करना बुरा है जिसकी विवेक-जांच नहीं की गई है।

$OLD_PERL_VERSION फॉर्म ऐतिहासिक कारणों से पर्ल v5.20.0 में जोड़ा गया था लेकिन
इसका उपयोग हतोत्साहित किया जाता है. (यदि $] का उपयोग करने का आपका कारण पुराने पर्ल्स पर कोड चलाना है
इसे $OLD_PERL_VERSION के रूप में संदर्भित करना आत्म-पराजय होगा।)

स्मरणीय: क्या पर्ल का यह संस्करण सही ब्रैकेट में है?

$SYSTEM_FD_MAX
$^F अधिकतम सिस्टम फ़ाइल डिस्क्रिप्टर, सामान्यतः 2. सिस्टम फ़ाइल डिस्क्रिप्टर होते हैं
"exec()"ed प्रक्रियाओं को पारित कर दिया गया है, जबकि उच्च फ़ाइल डिस्क्रिप्टर नहीं हैं। भी,
"ओपन()" के दौरान, सिस्टम फ़ाइल डिस्क्रिप्टर संरक्षित रहते हैं, भले ही "ओपन()"
विफल रहता है (सामान्य फ़ाइल डिस्क्रिप्टर "ओपन()" का प्रयास करने से पहले बंद कर दिए जाते हैं)।
फ़ाइल डिस्क्रिप्टर की क्लोज़-ऑन-एक्ज़ीक्यूटिव स्थिति इसके अनुसार तय की जाएगी
$^F का मान जब संबंधित फ़ाइल, पाइप, या सॉकेट खोला गया था, समय नहीं
"निष्पादन()" का।

@F सरणी @F में ऑटोस्प्लिट मोड होने पर पढ़ी जाने वाली प्रत्येक पंक्ति के फ़ील्ड शामिल हैं
कामोत्तेजित। के लिए पर्लरन देखें -a बदलना। यह सरणी पैकेज-विशिष्ट है, और
यदि चलते समय पैकेज मुख्य में नहीं है तो घोषित किया जाना चाहिए या पूरा पैकेज नाम दिया जाना चाहिए
"सख्त 'वर्स'" के अंतर्गत।

@INC सरणी @INC में उन स्थानों की सूची शामिल है जो "EXPR करें", "आवश्यकता है", या "उपयोग करें"
निर्माण अपनी लाइब्रेरी फ़ाइलों की तलाश करते हैं। इसमें प्रारंभ में तर्क शामिल होते हैं
किसी को -I कमांड-लाइन स्विच, संभवतः डिफ़ॉल्ट पर्ल लाइब्रेरी के बाद
/usr/local/lib/perl, वर्तमान निर्देशिका का प्रतिनिधित्व करने के लिए "।" के बाद। ("।"
यदि दोष जांच सक्षम है, तो "-T" या "-t" द्वारा जोड़ा नहीं जाएगा।) यदि
आपको इसे रनटाइम पर संशोधित करने की आवश्यकता है, आपको इसे प्राप्त करने के लिए "उपयोग lib" प्राग्मा का उपयोग करना चाहिए
मशीन-निर्भर लाइब्रेरी भी ठीक से लोड की गई:

lib '/mypath/libdir/' का उपयोग करें;
कुछमॉड का उपयोग करें;

आप पर्ल कोड डालकर फ़ाइल समावेशन प्रणाली में हुक भी डाल सकते हैं
सीधे @INC में। वे हुक सबरूटीन संदर्भ, सरणी संदर्भ या हो सकते हैं
धन्य वस्तुएं. विवरण के लिए perlfunc में "आवश्यकता" देखें।

%INC हैश %INC में "do", "require", के माध्यम से शामिल प्रत्येक फ़ाइल नाम के लिए प्रविष्टियाँ शामिल हैं।
या ऑपरेटरों का "उपयोग करें"। कुंजी आपके द्वारा निर्दिष्ट फ़ाइल नाम है (मॉड्यूल नामों के साथ)।
पथनाम में परिवर्तित), और मान मिली फ़ाइल का स्थान है।
"आवश्यकता" ऑपरेटर इस हैश का उपयोग यह निर्धारित करने के लिए करता है कि किसी विशेष फ़ाइल में है या नहीं
पहले से ही शामिल किया गया है.

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

$INPLACE_EDIT
$^I इनप्लेस-एडिट एक्सटेंशन का वर्तमान मूल्य। इनप्लेस को अक्षम करने के लिए "अनडेफ़" का उपयोग करें
संपादन।

स्मरणीय: का मूल्य -i स्विच.

$^M डिफ़ॉल्ट रूप से, मेमोरी ख़त्म होना एक अप्राप्य, घातक त्रुटि है। हालांकि, यदि
उपयुक्त रूप से निर्मित, पर्ल $^M की सामग्री को आपातकालीन मेमोरी पूल के रूप में उपयोग कर सकता है
"मरना()"आईएनजी। मान लीजिए कि आपका पर्ल "-DPERL_EMERGENCY_SBRK" और के साथ संकलित किया गया था
पर्ल के मॉलोक का उपयोग किया। तब

$^M = 'ए' x (1 << 16);

आपातकालीन स्थिति में उपयोग के लिए 64K बफर आवंटित करेगा। देखें इन्सटाल में दायर
कस्टम सी संकलन फ़्लैग कब जोड़ें, इसकी जानकारी के लिए पर्ल वितरण
पर्ल का संकलन। इस उन्नत सुविधा के आकस्मिक उपयोग को हतोत्साहित करने की कोई आवश्यकता नहीं है
इस चर के लिए अंग्रेजी लंबा नाम.

यह वेरिएबल पर्ल 5.004 में जोड़ा गया था।

$OSNAME
$^O ऑपरेटिंग सिस्टम का नाम जिसके अंतर्गत पर्ल की यह प्रति बनाई गई थी, जैसे
कॉन्फ़िगरेशन प्रक्रिया के दौरान निर्धारित किया गया। उदाहरण के लिए "प्लेटफ़ॉर्म" देखें
पर्लपोर्ट.

मान $Config{'osname'} के समान है। कॉन्फिग और यह भी देखें -V कमान
लाइन स्विच को पर्लरुन में प्रलेखित किया गया है।

विंडोज़ प्लेटफ़ॉर्म में, $^O बहुत मददगार नहीं है: चूँकि यह हमेशा "MSWin32" होता है
95/98/ME/NT/2000/XP/CE/.NET के बीच अंतर नहीं बताता। उपयोग
"Win32::GetOSName()" या Win32::GetOSVersion() (Win32 और perlport देखें)
वेरिएंट के बीच अंतर करें.

यह वेरिएबल पर्ल 5.003 में जोड़ा गया था।

%SIG हैश %SIG में सिग्नल के लिए सिग्नल हैंडलर होते हैं। उदाहरण के लिए:

उप हैंडलर { # पहला तर्क सिग्नल नाम है
मेरा($sig) = @_;
प्रिंट करें "एक SIG$sig पकड़ा गया--बंद हो रहा है\n";
बंद करें (लॉग);
निकास; (0)
}

$SIG{'INT'} = \&हैंडलर;
$SIG{'छोड़ें'} = \&हैंडलर;
...
$SIG{'INT'} = 'डिफ़ॉल्ट'; # डिफ़ॉल्ट कार्रवाई बहाल करें
$SIG{'छोड़ें'} = 'अनदेखा करें'; # SIGQUIT को अनदेखा करें

'इग्नोर' के मान का उपयोग करने से आम तौर पर सिग्नल को अनदेखा करने का प्रभाव पड़ता है, सिवाय इसके
"सीएचएलडी" सिग्नल के लिए। इस विशेष मामले के बारे में अधिक जानकारी के लिए perlipc देखें।

यहां कुछ अन्य उदाहरण दिए गए हैं:

$SIG{"PIPE"} = "प्लम्बर"; # मुख्य मानता है::प्लम्बर (नहीं
# अनुशंसित)
$SIG{"PIPE"} = \&प्लम्बर; # बस ठीक; वर्तमान मान लें
# प्लंबर
$SIG{"PIPE"} = *प्लम्बर; # कुछ हद तक गूढ़
$SIG{"PIPE"} = प्लंबर(); #उफ़, प्लंबर ने क्या किया()
# वापस करना??

सुनिश्चित करें कि सिग्नल हैंडलर के नाम के रूप में किसी नंगे शब्द का उपयोग न करें, ऐसा न हो
अनजाने में इसे कॉल करें.

यदि आपके सिस्टम में "सिगेक्शन ()" फ़ंक्शन है तो सिग्नल हैंडलर स्थापित हैं
इसका उपयोग हो रहा है। इसका मतलब है कि आपको विश्वसनीय सिग्नल हैंडलिंग मिलती है।

पर्ल v5.8.0 में सिग्नल की डिफॉल्ट डिलीवरी नीति तत्काल (भी) से बदल गई
"असुरक्षित" के रूप में जाना जाता है) से आस्थगित, जिसे "सुरक्षित सिग्नल" के रूप में भी जाना जाता है। इसके लिए पर्लिप देखें
अधिक जानकारी।

%SIG हैश का उपयोग करके कुछ आंतरिक हुक भी सेट किए जा सकते हैं। दिनचर्या का संकेत दिया
$SIG{__WARN__} द्वारा तब कॉल किया जाता है जब कोई चेतावनी संदेश मुद्रित होने वाला होता है।
चेतावनी संदेश को पहले तर्क के रूप में पारित किया जाता है। "__चेतावनी__" की उपस्थिति
हुक के कारण "STDERR" चेतावनियों की सामान्य छपाई बंद हो जाती है। आप
इसका उपयोग किसी चर में चेतावनियों को सहेजने, या चेतावनियों को घातक त्रुटियों में बदलने के लिए किया जा सकता है,
इस तरह:

स्थानीय $SIG{__WARN__} = उप { मरो $_[0] };
ईवल $ प्रोगी;

चूँकि 'IGNORE' हुक "__WARN__" द्वारा समर्थित नहीं है, आप चेतावनियाँ अक्षम कर सकते हैं
खाली सबरूटीन का उपयोग करना:

स्थानीय $SIG{__WARN__} = उप {};

$SIG{__DIE__} द्वारा इंगित रूटीन को तब कॉल किया जाता है जब कोई घातक अपवाद होता है
फेंक दिया जाना. त्रुटि संदेश पहले तर्क के रूप में पारित किया गया है। जब एक
"__DIE__" हुक रूटीन रिटर्न देता है, अपवाद प्रसंस्करण वैसे ही जारी रहता है
हुक की अनुपस्थिति में, जब तक कि हुक रूटीन स्वयं "गोटो" के माध्यम से बाहर न निकल जाए
&sub", एक लूप निकास, या एक "डाई()"। "__DIE__" हैंडलर स्पष्ट रूप से अक्षम है
कॉल के दौरान, ताकि आप "__DIE__" हैंडलर से मर सकें। इसी प्रकार के लिए
"__चेतावनी देना__"।

एक कार्यान्वयन गड़बड़ी के कारण, $SIG{__DIE__} हुक को a के अंदर भी कॉल किया जाता है
"eval()"। $@ में किसी लंबित अपवाद को फिर से लिखने या विचित्र रूप में लिखने के लिए इसका उपयोग न करें
"कोर::ग्लोबल::डाई()" को ओवरराइड करने का विकल्प। ए पर यह अजीब हरकत
दूरी को भविष्य के रिलीज़ में तय किया जा सकता है ताकि $SIG{__DIE__} को केवल तभी कॉल किया जा सके
आपका प्रोग्राम बाहर निकलने वाला है, जैसा कि मूल इरादा था। कोई अन्य उपयोग है
पदावनत।

"__DIE__"/"__WARN__" हैंडलर एक मामले में बहुत खास हैं: उन्हें बुलाया जा सकता है
पार्सर द्वारा पाई गई (संभावित) त्रुटियों की रिपोर्ट करने के लिए। ऐसे मामले में पार्सर हो सकता है
असंगत स्थिति में, इसलिए ऐसे हैंडलर से पर्ल कोड का मूल्यांकन करने का कोई भी प्रयास
संभवतः सेगफॉल्ट का परिणाम होगा। इसका मतलब है कि चेतावनियाँ या त्रुटियाँ
पार्सिंग से परिणाम पर्ल का उपयोग अत्यधिक सावधानी के साथ किया जाना चाहिए, जैसे:

यदि परिभाषित $^S है तो कार्प की आवश्यकता है;
यदि परिभाषित किया गया है तो कार्प::कबूल('कुछ गलत') &कार्प::कबूल;
मरो "कुछ गड़बड़ है, लेकिन देने के लिए कार्प लोड नहीं कर सका"
. "बैकट्रेस...\n\t"
. "बैकट्रेस देखने के लिए पर्ल को -MCarp स्विच के साथ शुरू करने का प्रयास करें";

यहां पहली पंक्ति "कार्प" लोड करेगी जब तक यह वह पार्सर है जिसने कॉल किया था
हैंडलर. यदि "कार्प" उपलब्ध था तो दूसरी पंक्ति बैकट्रेस प्रिंट करेगी और मर जाएगी।
तीसरी पंक्ति तभी निष्पादित की जाएगी जब "कार्प" उपलब्ध न हो।

अपने अपवाद हैंडलर में $^S वेरिएबल के बारे में भी सोचना सरल है
गलत। $SIG{__DIE__} जैसा कि वर्तमान में लागू किया गया है, गंभीर और कठिन है
त्रुटियों को ट्रैक करें. इससे बचें और "END{}" या CORE::GLOBAL::die ओवरराइड का उपयोग करें
बजाय.

पर्लफंक में "डाई", पर्लफंक में "चेतावनी", पर्लफंक में "ईवल", और चेतावनियां देखें
अतिरिक्त जानकारी।

$बेसटाइम
$^T वह समय जब प्रोग्राम चलना शुरू हुआ, युग (शुरुआत) के बाद से सेकंड में
1970 का)। द्वारा लौटाए गए मान -M, -A, तथा -C फ़ाइल परीक्षण इसी पर आधारित हैं
मूल्य.

$PERL_संस्करण
$^V पर्ल दुभाषिया का संशोधन, संस्करण और तोड़फोड़, एक के रूप में दर्शाया गया है
संस्करण वस्तु.

यह वेरिएबल पहली बार perl v5.6.0 में दिखाई दिया; पर्ल के पुराने संस्करणों में एक दिखाई देगा
अपरिभाषित मूल्य. पर्ल v5.10.0 से पहले $^V को वी-स्ट्रिंग के रूप में दर्शाया जाता था
एक संस्करण वस्तु की तुलना में।

$^V का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि किसी स्क्रिप्ट को निष्पादित करने वाला पर्ल दुभाषिया अंदर है या नहीं
संस्करणों की सही श्रेणी. उदाहरण के लिए:

चेतावनी दें "हैश यादृच्छिक नहीं है!\n" यदि !$^V या $^V lt v5.8.1

जबकि संस्करण ऑब्जेक्ट स्ट्रिंगफिकेशन को ओवरलोड करता है, $^V को पोर्टेबल रूप से परिवर्तित करने के लिए
स्ट्रिंग प्रतिनिधित्व, "sprintf()" के "%vd" रूपांतरण का उपयोग करें, जो दोनों के लिए काम करता है
वी-स्ट्रिंग्स या संस्करण ऑब्जेक्ट:

प्रिंटफ "संस्करण v%vd\n है", $^V; # पर्ल का संस्करण

सुविधाजनक तरीके के लिए "संस्करण का उपयोग करें" और "संस्करण की आवश्यकता है" का दस्तावेज़ देखें
यदि चल रहा पर्ल दुभाषिया बहुत पुराना है तो विफल हो जाना।

पर्ल संस्करण के दशमलव प्रतिनिधित्व के लिए $] भी देखें।

$] पर $^V का मुख्य लाभ यह है कि, पर्ल v5.10.0 या बाद के संस्करण के लिए, यह ओवरलोड हो जाता है
ऑपरेटर, अन्य संस्करण अभ्यावेदन (उदाहरण के लिए) के विरुद्ध आसान तुलना की अनुमति देते हैं
दशमलव, शाब्दिक वी-स्ट्रिंग, "v1.2.3", या ऑब्जेक्ट)। नुकसान यह है कि पहले
v5.10.0 तक, यह केवल एक शाब्दिक वी-स्ट्रिंग था, जिसे आसानी से मुद्रित नहीं किया जा सकता था या
तुलना की।

स्मरणीय: संस्करण ऑब्जेक्ट के लिए ^V का उपयोग करें।

${^WIN32_SLOPPY_STAT}
यदि यह वेरिएबल सही मान पर सेट है, तो विंडोज़ पर "stat()" ऐसा करने का प्रयास नहीं करेगा
फ़ाइल खोलें। इसका मतलब यह है कि लिंक संख्या निर्धारित नहीं की जा सकती और फ़ाइल नहीं की जा सकती
यदि फ़ाइल में अतिरिक्त हार्डलिंक मौजूद हैं तो विशेषताएँ पुरानी हो सकती हैं। पर
दूसरी ओर, फ़ाइल को न खोलना काफी तेज़ है, विशेषकर फ़ाइलों के लिए
नेटवर्क ड्राइव.

इस वेरिएबल को इसमें सेट किया जा सकता है sitecustomize.pl स्थानीय को कॉन्फ़िगर करने के लिए फ़ाइल
डिफ़ॉल्ट रूप से "स्लॉपी" "स्टेट ()" का उपयोग करने के लिए पर्ल इंस्टॉलेशन। इसके लिए दस्तावेज़ देखें
-f साइट अनुकूलन के बारे में अधिक जानकारी के लिए perlrun में।

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

$EXECUTABLE_NAME
$^X पर्ल की वर्तमान प्रतिलिपि को निष्पादित करने के लिए उपयोग किया जाने वाला नाम, C के "argv[0]" या (जहाँ) से
समर्थित) /proc/स्वयं/exe.

होस्ट ऑपरेटिंग सिस्टम के आधार पर, $^X का मान सापेक्ष या हो सकता है
पर्ल प्रोग्राम फ़ाइल का पूर्ण पथनाम, या आह्वान करने के लिए उपयोग की जाने वाली स्ट्रिंग हो सकती है
पर्ल लेकिन पर्ल प्रोग्राम फ़ाइल का पथनाम नहीं। साथ ही, अधिकांश ऑपरेटिंग सिस्टम
ऐसे प्रोग्रामों को लागू करने की अनुमति दें जो PATH पर्यावरण चर में नहीं हैं
इसकी कोई गारंटी नहीं है कि $^X का मान PATH में है। वीएमएस के लिए, मान हो भी सकता है और हो भी सकता है
संस्करण संख्या शामिल नहीं है.

आप आमतौर पर इसकी एक स्वतंत्र प्रतिलिपि को पुनः प्राप्त करने के लिए $^X के मान का उपयोग कर सकते हैं
पर्ल जो वर्तमान में चल रहा है, उदाहरण के लिए,

@first_run = `$^X -le "प्रिंट इंट रैंड 100 फॉर 1..100"`;

लेकिन याद रखें कि सभी ऑपरेटिंग सिस्टम फोर्किंग या कैप्चरिंग का समर्थन नहीं करते हैं
आदेशों का आउटपुट, इसलिए यह जटिल कथन पोर्टेबल नहीं हो सकता है।

किसी फ़ाइल के पथ नाम के रूप में, कुछ ऑपरेटिंग के रूप में $^X के मान का उपयोग करना सुरक्षित नहीं है
जिन प्रणालियों में निष्पादन योग्य फ़ाइलों पर एक अनिवार्य प्रत्यय होता है, उन्हें इसके उपयोग की आवश्यकता नहीं होती है
किसी आदेश को लागू करते समय प्रत्यय। $^X के मान को पथ नाम में बदलने के लिए, उपयोग करें
निम्नलिखित कथन:

# फ़ाइल नामों का एक सेट बनाएं (कमांड नाम नहीं)।
कॉन्फिग का उपयोग करें;
मेरा $this_perl = $^X;
अगर ($^O ने 'वीएमएस') {
$this_perl.= $Config{_exe}
जब तक $this_perl =~ m/$Config{_exe}$/i;
}

क्योंकि कई ऑपरेटिंग सिस्टम किसी भी व्यक्ति को पर्ल प्रोग्राम तक पढ़ने की पहुंच की अनुमति देते हैं
फ़ाइल की प्रतिलिपि बनाने के लिए, प्रतिलिपि को पैच करें, और फिर प्रतिलिपि निष्पादित करें
सुरक्षा के प्रति जागरूक पर्ल प्रोग्रामर को स्थापित प्रतिलिपि को लागू करने का ध्यान रखना चाहिए
पर्ल की, $^X द्वारा संदर्भित प्रति नहीं। निम्नलिखित कथन इसे पूरा करते हैं
लक्ष्य, और एक पथनाम तैयार करें जिसे एक कमांड के रूप में लागू किया जा सकता है या एक के रूप में संदर्भित किया जा सकता है
फ़ाइल.

कॉन्फिग का उपयोग करें;
मेरा $secure_perl_path = $Config{perlpath};
अगर ($^O ने 'वीएमएस') {
$secure_perl_path .= $Config{_exe}
जब तक $secure_perl_path =~ m/$Config{_exe}$/i;
}

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

यदि( /पी(ए)टीटी(ईआर)एन/ ) {
प्रिंट करें "मुझे $1 और $2\n मिले";
}

जब तक हम अन्यथा ध्यान न दें, ये चर केवल पढ़ने योग्य और गतिशील रूप से दायरे वाले होते हैं।

नियमित अभिव्यक्ति चर की गतिशील प्रकृति का अर्थ है कि उनका मूल्य सीमित है
जिस ब्लॉक में वे हैं, जैसा कि कोड के इस बिट द्वारा दर्शाया गया है:

मेरा $बाहरी = 'वालेस और ग्रोमिट';
मेरा $आंतरिक = 'मट और जेफ़';

मेरा $पैटर्न = qr/(\S+) और (\S+)/;

सब शो_एन {प्रिंट "\$1, $1 है; \$2, $2\n" }

{
बाहरी:
show_n() यदि $बाहरी =~m/$पैटर्न/;

भीतरी: {
show_n() यदि $आंतरिक =~m/$पैटर्न/;
}

show_n();
}

आउटपुट से पता चलता है कि "आउटर" ब्लॉक में, $1 और $2 के मान हैं
$outer के विरुद्ध मैच। "INNER" ब्लॉक के अंदर, $1 और $2 के मान हैं
$inner के विरुद्ध मिलान करें, लेकिन केवल ब्लॉक के अंत तक (यानी गतिशील दायरा)। बाद
"INNER" ब्लॉक पूरा हो जाता है, $1 और $2 के मान मिलान के मानों पर वापस आ जाते हैं
$outer के विरुद्ध भले ही हमने दूसरा मैच नहीं खेला हो:

$1 वालेस है; $2 ग्रोमिट है
$1 मट है; $2 जेफ है
$1 वालेस है; $2 ग्रोमिट है

प्रदर्शन मुद्दों

परंपरागत रूप से पर्ल में, तीन वेरिएबल्स "$`", $& या "$'" (या उनके) में से किसी का भी उपयोग
कोड में कहीं भी "अंग्रेजी समकक्ष का उपयोग करें"), बाद के सभी सफल पैटर्न का कारण बना
मिलान की गई स्ट्रिंग की प्रतिलिपि बनाने के लिए मिलान करें, यदि कोड बाद में पहुंच सकता है
उन चरों में से एक। इसने समग्र रूप से काफी प्रदर्शन जुर्माना लगाया
कार्यक्रम, इसलिए आम तौर पर इन चरों के उपयोग को हतोत्साहित किया गया है।

पर्ल 5.6.0 में "@-" और "@+" डायनामिक ऐरे पेश किए गए जो सूचकांकों की आपूर्ति करते हैं
सफल मैच. तो उदाहरण के लिए आप यह कर सकते हैं:

$str =~ /पैटर्न/;

$`, $&, $' प्रिंट करें; # ख़राब: प्रदर्शन प्रभावित

प्रिंट # अच्छा: कोई प्रदर्शन हिट नहीं
पदार्थ($str, 0, $-[0]),
सबस्ट्र($str, $-[0], $+[0]-$-[0]),
पदार्थ($str, $+[0]);

पर्ल 5.10.0 में "/p" मैच ऑपरेटर ध्वज और "${^PREMATCH}", "${^MATCH}", और
"${^POSTMATCH}" वैरिएबल पेश किए गए, जिससे आपको केवल दंड भुगतने की अनुमति मिली
"/p" से चिह्नित पैटर्न पर।

पर्ल 5.18.0 के बाद से, पर्ल ने तीन चरों में से प्रत्येक की उपस्थिति को नोट करना शुरू कर दिया
अलग से, और केवल आवश्यक स्ट्रिंग के उस भाग की प्रतिलिपि बनाई गई; तो में

$`; $&; "abcdefgh" =~ /d/

पर्ल केवल स्ट्रिंग के "एबीसीडी" भाग की प्रतिलिपि बनाएगा। इससे बहुत बड़ा फर्क पड़ सकता है
कुछ इस तरह

$str = 'x' x 1_000_000;
$&; #उफ़
$str =~ /x/g # एक वर्ण को दस लाख बार कॉपी किया गया, दस लाख वर्णों को नहीं

पर्ल 5.20.0 में एक नया कॉपी-ऑन-राइट सिस्टम डिफ़ॉल्ट रूप से सक्षम किया गया था, जो अंततः सभी को ठीक करता है
इन तीन चरों के साथ प्रदर्शन संबंधी समस्याएं उत्पन्न होती हैं, और उन्हें कहीं भी उपयोग करना सुरक्षित बनाता है।

"Devel::NYTProf" और "Devel::FindAmpersand" मॉड्यूल आपको इनका उपयोग ढूंढने में मदद कर सकते हैं
आपके कोड में समस्याग्रस्त मिलान चर।

$<अंक> ($1, $2,...)
कोष्ठकों को कैप्चर करने के संबंधित सेट से उप-पैटर्न शामिल है
अंतिम सफल पैटर्न मिलान, नेस्टेड ब्लॉकों में मिलान किए गए पैटर्न की गिनती नहीं
जो पहले ही बाहर हो चुके हैं।

ये चर केवल पढ़ने योग्य और गतिशील रूप से दायरे वाले हैं।

स्मरणीय: \अंकों की तरह।

$मैच
$& स्ट्रिंग अंतिम सफल पैटर्न मिलान से मेल खाती है (किसी भी मिलान की गिनती नहीं)।
वर्तमान ब्लॉक से घिरे एक ब्लॉक या "eval()" के भीतर छिपा हुआ है।

उपयोग के गंभीर प्रदर्शन निहितार्थों के लिए ऊपर "प्रदर्शन संबंधी समस्याएं" देखें
यह वेरिएबल (एक बार भी) आपके कोड में।

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

स्मरणीय: जैसे कुछ संपादकों में "&"।

${^मैच}
यह $& ($MATCH) के समान है, सिवाय इसके कि इसमें प्रदर्शन पर कोई प्रभाव नहीं पड़ता है
उस चर से संबंधित दंड.

ऊपर "प्रदर्शन संबंधी समस्याएं" देखें।

पर्ल v5.18 और इससे पहले के संस्करण में, केवल तभी एक परिभाषित मान लौटाने की गारंटी दी जाती है
पैटर्न को "/p" संशोधक के साथ संकलित या निष्पादित किया गया था। पर्ल v5.20 में,
"/p" संशोधक कुछ नहीं करता है, इसलिए "${^MATCH}" $MATCH जैसा ही कार्य करता है।

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

$प्रीमैच
$` अंतिम सफल पैटर्न मिलान से जो कुछ भी मेल खाता था उससे पहले की स्ट्रिंग,
किसी ब्लॉक या करंट से घिरे "eval" के भीतर छिपे किसी भी मैच की गिनती नहीं की जा रही है
अवरोध पैदा करना।

उपयोग के गंभीर प्रदर्शन निहितार्थों के लिए ऊपर "प्रदर्शन संबंधी समस्याएं" देखें
यह वेरिएबल (एक बार भी) आपके कोड में।

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

स्मरणीय: "`" अक्सर उद्धृत स्ट्रिंग से पहले आता है।

${^प्रीमैच}
यह "$`" ($PREMATCH) के समान है, सिवाय इसके कि इससे प्रदर्शन प्रभावित नहीं होता है
उस चर से संबंधित दंड.

ऊपर "प्रदर्शन संबंधी समस्याएं" देखें।

पर्ल v5.18 और इससे पहले के संस्करण में, केवल तभी एक परिभाषित मान लौटाने की गारंटी दी जाती है
पैटर्न को "/p" संशोधक के साथ संकलित या निष्पादित किया गया था। पर्ल v5.20 में,
"/p" संशोधक कुछ नहीं करता है, इसलिए "${^PREMATCH}" वही काम करता है जो $PREMATCH करता है।

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

$ पोस्टमैच
$' अंतिम सफल पैटर्न मिलान से जो कुछ भी मेल खाता था उसका अनुसरण करने वाली स्ट्रिंग
(किसी ब्लॉक या "eval()" से घिरे किसी भी मिलान की गिनती नहीं की जा रही है
वर्तमान ब्लॉक)। उदाहरण:

स्थानीय $_ = 'abcdefghi';
/डीईएफ़/;
प्रिंट करें "$`:$&:$'\n"; # abc:def:ghi प्रिंट करता है

उपयोग के गंभीर प्रदर्शन निहितार्थों के लिए ऊपर "प्रदर्शन संबंधी समस्याएं" देखें
यह वेरिएबल (एक बार भी) आपके कोड में।

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

स्मरणीय: "'" अक्सर उद्धृत स्ट्रिंग का अनुसरण करता है।

${^पोस्टमैच}
यह "$'" ($POSTMATCH) के समान है, सिवाय इसके कि इससे प्रदर्शन प्रभावित नहीं होता है
उस चर से संबंधित दंड.

ऊपर "प्रदर्शन संबंधी समस्याएं" देखें।

पर्ल v5.18 और इससे पहले के संस्करण में, केवल तभी एक परिभाषित मान लौटाने की गारंटी दी जाती है
पैटर्न को "/p" संशोधक के साथ संकलित या निष्पादित किया गया था। पर्ल v5.20 में,
"/p" संशोधक कुछ नहीं करता है, इसलिए "${^POSTMATCH}" $POSTMATCH जैसा ही कार्य करता है।

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

$LAST_PAREN_MATCH
$+ पाठ अंतिम सफल खोज पैटर्न के अंतिम ब्रैकेट से मेल खाता है। यह
यदि आप नहीं जानते कि वैकल्पिक पैटर्न के सेट में से कौन सा मेल खाता है तो यह उपयोगी है।
उदाहरण के लिए:

/संस्करण: (.*)|संशोधन: (.*)/ && ($rev = $+);

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

स्मरणीय: सकारात्मक और दूरदर्शी बनें।

$LAST_SUBMATCH_RESULT
$^N प्रयुक्त पाठ हाल ही में बंद किए गए समूह से मेल खाता है (अर्थात् जिस समूह के साथ
अंतिम सफल खोज पैटर्न का सबसे दाहिना समापन कोष्ठक)।

इसका उपयोग मुख्य रूप से हाल ही में पाठ की जांच के लिए "(?{...})" ब्लॉक के अंदर किया जाता है
मिलान हुआ. उदाहरण के लिए, किसी वेरिएबल में टेक्स्ट को प्रभावी ढंग से कैप्चर करने के लिए (इसके अतिरिक्त)।
$1, $2, आदि), "(...)" को से बदलें

(?:(...)(?{ $var = $^N }))

इस तरह से $var को सेट करने और फिर उपयोग करने से आपको चिंता करने से राहत मिलती है
वास्तव में वे कोष्ठकों का कौन सा क्रमांकित समूह हैं।

यह वेरिएबल पर्ल v5.8.0 में जोड़ा गया था।

स्मरणीय: (संभवतः) नेस्टेड कोष्ठक जो हाल ही में बंद हुआ है।

@LAST_MATCH_END
@+ यह सरणी अंतिम सफल सबमैचों के सिरों की ऑफसेट रखती है
वर्तमान में सक्रिय गतिशील दायरा। $+[0] अंत की स्ट्रिंग में ऑफसेट है
पूरा मैच. यह वही मान है जो "pos" फ़ंक्शन कब लौटाता है
उस वेरिएबल पर कॉल किया गया जिसका मिलान किया गया था। nइस सरणी का वां तत्व
का ऑफसेट रखता है nवां सबमैच, इसलिए $+[1] ऑफसेट अतीत है जहां $1 समाप्त होता है,
$+[2] ऑफसेट अतीत जहां $2 समाप्त होता है, इत्यादि। आप यह निर्धारित करने के लिए $#+ का उपयोग कर सकते हैं कि कैसे
अंतिम सफल मैच में कई उपसमूह थे। इसके लिए दिए गए उदाहरण देखें
"@-" चर।

यह वेरिएबल पर्ल v5.6.0 में जोड़ा गया था।

%LAST_PAREN_MATCH
%+ "@+" के समान, "%+" हैश नामित कैप्चर बफ़र्स तक पहुंच की अनुमति देता है, ऐसा होना चाहिए
वे वर्तमान में सक्रिय गतिशील दायरे में अंतिम सफल मैच में मौजूद हैं।

उदाहरण के लिए, निम्नलिखित मिलान के बाद $+{foo} $1 के बराबर है:

'फू' =~ /(? foo)/;

"%+" हैश की कुंजियाँ केवल उन बफ़र्स के नाम सूचीबद्ध करती हैं जिन्होंने कैप्चर किया है (और)।
जो इस प्रकार परिभाषित मूल्यों से जुड़े हैं)।

"%+" का अंतर्निहित व्यवहार Tie::Hash::NamedCapture द्वारा प्रदान किया गया है
मॉड्यूल।

नोट: "%-" और "%+" एक सामान्य आंतरिक हैश से जुड़े दृश्य हैं
अंतिम सफल नियमित अभिव्यक्ति. इसलिए उनके माध्यम से पुनरावृत्तीय पहुंच को मिश्रित करना
"प्रत्येक" के अप्रत्याशित परिणाम हो सकते हैं। इसी तरह, अगर आखिरी सफल मैच
परिवर्तन हो तो परिणाम आश्चर्यजनक हो सकते हैं।

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

@LAST_MATCH_START
@- "$-[0]" अंतिम सफल मैच की शुरुआत का ऑफसेट है। "$-["n"]" है
द्वारा मिलान किए गए सबस्ट्रिंग की शुरुआत का ऑफसेट n-वें उपपैटर्न, या अपरिभाषित यदि
उपपैटर्न मेल नहीं खाता.

इस प्रकार, $_ के विरुद्ध मैच के बाद, $& "substr $_, $-[0], $+[0] के साथ मेल खाता है -
$-[0]"। इसी प्रकार, $n "substr $_, $-[n], $+[n] - $-[n]" के साथ मेल खाता है यदि "$-[n]"
परिभाषित किया गया है, और $+ "substr $_, $-[$#-], $+[$#-] - $-[$#-]" से मेल खाता है। एक
अंतिम सफल मैच में अंतिम मिलान वाले उपसमूह को खोजने के लिए "$#-" का उपयोग कर सकते हैं।
$#+ के साथ तुलना करें, रेगुलर एक्सप्रेशन में उपसमूहों की संख्या। तुलना करना
"@+" के साथ.

यह सरणी अंतिम सफल उप-मैचों की शुरुआत के ऑफसेट रखती है
वर्तमान में सक्रिय गतिशील दायरे में। "$-[0]" की स्ट्रिंग में ऑफसेट है
पूरे मैच की शुरुआत. nइस सरणी का वां तत्व ऑफसेट रखता है
का nवां सबमैच, इसलिए "$-[1]" वह ऑफसेट है जहां $1 शुरू होता है, "$-[2]" ऑफसेट है
जहां $2 शुरू होता है, इत्यादि।

कुछ वेरिएबल $var के विरुद्ध मैच के बाद:

"$`" "substr($var, 0, $-[0])" के समान है
$& "substr($var, $-[0], $+[0] - $-[0])" के समान है
"$'" "substr($var, $+[0])" के समान है
$1 "substr($var, $-[1], $+[1] - $-[1])" के समान है
$2 "substr($var, $-[2], $+[2] - $-[2])" के समान है
$3 "substr($var, $-[3], $+[3] - $-[3])" के समान है

यह वेरिएबल पर्ल v5.6.0 में जोड़ा गया था।

%LAST_MATCH_START
%- "%+" के समान, यह वेरिएबल नामित कैप्चर समूहों तक पहुंच की अनुमति देता है
वर्तमान में सक्रिय गतिशील दायरे में अंतिम सफल मैच। प्रत्येक कैप्चर के लिए
समूह का नाम रेगुलर एक्सप्रेशन में पाया जाता है, यह एक सरणी के संदर्भ को जोड़ता है
जिसमें उस नाम के साथ सभी बफ़र्स द्वारा कैप्चर किए गए मानों की सूची शामिल है (वहां होनी चाहिए)।
उनमें से कई हों), उसी क्रम में जहां वे प्रकट होते हैं।

यहाँ एक उदाहरण है:

यदि ('1234' =~ /(? 1)(? 2)(? 3)(? 4)/) {
मेरे $bufname को फ़ोरैच करें (सॉर्ट कुंजियाँ %-) {
मेरा $ary = $-{$bufname};
foreach my $idx (0..$#$ary) {
प्रिंट करें "\$-{$bufname}[$idx] :",
(परिभाषित($ary->[$idx])
? "'$ary->[$idx]'"
: "अपरिभाषित"),
"\एन";
}
}
}

प्रिंट आउट होगा:

$-{A}[0] : '1'
$-{A}[1] : '3'
$-{बी}[0] : '2'
$-{बी}[1] : '4'

"%-" हैश की कुंजियाँ नियमित रूप से पाए जाने वाले सभी बफ़र नामों से मेल खाती हैं
अभिव्यक्ति।

"%-" का व्यवहार Tie::Hash::NamedCapture मॉड्यूल के माध्यम से कार्यान्वित किया जाता है।

नोट: "%-" और "%+" एक सामान्य आंतरिक हैश से जुड़े दृश्य हैं
अंतिम सफल नियमित अभिव्यक्ति. इसलिए उनके माध्यम से पुनरावृत्तीय पहुंच को मिश्रित करना
"प्रत्येक" के अप्रत्याशित परिणाम हो सकते हैं। इसी तरह, अगर आखिरी सफल मैच
परिवर्तन हो तो परिणाम आश्चर्यजनक हो सकते हैं।

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

यह वेरिएबल केवल पढ़ने योग्य और गतिशील रूप से दायरे वाला है।

$LAST_REGEXP_CODE_RESULT
$^R अंतिम सफल "(?{ कोड })" रेगुलर एक्सप्रेशन के मूल्यांकन का परिणाम
दावा (पर्लरे देखें)। को लिखा जा सकता है.

यह वेरिएबल पर्ल 5.005 में जोड़ा गया था।

${^RE_DEBUG_FLAGS}
रेगेक्स डिबगिंग फ़्लैग का वर्तमान मान। बिना डिबग आउटपुट के भी 0 पर सेट करें
जब "पुनः 'डीबग'" मॉड्यूल लोड किया जाता है। विवरण के लिए पुनः देखें.

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

${^RE_TRIE_MAXBUF}
नियंत्रित करता है कि कुछ रेगेक्स अनुकूलन कैसे लागू किए जाते हैं और उनमें कितनी मेमोरी है
उपयोग करें. डिफ़ॉल्ट रूप से यह मान 65536 है जो 512kB अस्थायी से मेल खाता है
कैश. बड़े पैमाने पर मिलान करते समय गति के लिए मेमोरी का व्यापार करने के लिए इसे उच्च मान पर सेट करें
विकल्प. यदि आप चाहते हैं कि अनुकूलन इस प्रकार हो तो इसे कम मान पर सेट करें
जितना संभव हो सके स्मृति का रूढ़िवादी लेकिन फिर भी घटित होता है, और इसे नकारात्मक मान पर सेट करें
अनुकूलन को रोकने और अधिकतम मेमोरी को संरक्षित करने के लिए। सामान्य परिस्थितियों में
इस चर में आपकी कोई रुचि नहीं होनी चाहिए.

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

चर सम्बंधित सेवा मेरे फ़ाइल हैंडल
वर्तमान में चयनित फ़ाइलहैंडल पर निर्भर वेरिएबल को कॉल करके सेट किया जा सकता है
"IO::Handle" ऑब्जेक्ट पर उपयुक्त ऑब्जेक्ट विधि, हालांकि यह इससे कम कुशल है
नियमित अंतर्निर्मित चर का उपयोग करना। (इसके लिए नीचे दी गई सारांश पंक्तियों में यह शब्द है
हैंडल।) सबसे पहले आपको कहना होगा

आईओ :: हैंडल का उपयोग करें;

जिसके बाद आप दोनों का उपयोग कर सकते हैं

विधि हैंडल EXPR

या अधिक सुरक्षित रूप से,

हैंडल->विधि(EXPR)

प्रत्येक विधि "IO::Handle" विशेषता का पुराना मान लौटाती है। प्रत्येक विधि एक लेती है
वैकल्पिक EXPR, जो यदि प्रदान किया जाता है, तो "IO::Handle" विशेषता के लिए नया मान निर्दिष्ट करता है
प्रश्न में। यदि आपूर्ति नहीं की जाती है, तो अधिकांश विधियाँ वर्तमान मूल्य पर कुछ नहीं करतीं--सिवाय इसके
"ऑटोफ्लश()", जो आपके लिए 1 मान लेगा, बस अलग होने के लिए।

क्योंकि "IO::Handle" क्लास में लोड करना एक महंगा ऑपरेशन है, आपको सीखना चाहिए कि कैसे
नियमित अंतर्निहित चर का उपयोग करने के लिए।

इनमें से कुछ चर को "केवल पढ़ने योग्य" माना जाता है। इसका मतलब यह है कि यदि आप असाइन करने का प्रयास करते हैं
इस चर के लिए, प्रत्यक्ष या अप्रत्यक्ष रूप से एक संदर्भ के माध्यम से, आप एक रन बढ़ाएँगे-
समय अपवाद.

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

मेरा $fh खोलें, "<", "foo" या मरें $!;
स्थानीय $/; # स्थानीयकृत स्लर्प मोड सक्षम करें
मेरी $सामग्री = <$fh>;
$fh बंद करें;

लेकिन निम्नलिखित कोड काफी खराब है:

मेरा $fh खोलें, "<", "foo" या मरें $!;
अपरिभाषित $/; # स्लर्प मोड सक्षम करें
मेरी $सामग्री = <$fh>;
$fh बंद करें;

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

आमतौर पर जब कोई चर स्थानीयकृत होता है तो आप यह सुनिश्चित करना चाहते हैं कि यह परिवर्तन प्रभावित करता है
सबसे छोटा दायरा संभव। इसलिए जब तक आप पहले से ही किसी छोटे "{}" ब्लॉक के अंदर न हों, आप
एक स्वयं बनाना चाहिए. उदाहरण के लिए:

मेरा $content = '';
मेरा $fh खोलें, "<", "foo" या मरें $!;
{
स्थानीय $/;
$सामग्री = <$fh>;
}
$fh बंद करें;

यहां एक उदाहरण दिया गया है कि आपका अपना कोड कैसे टूट सकता है:

(1..3) के लिए
$\ = "\r\n";
गंदा_ब्रेक();
"$_" प्रिंट करें;
}

उप गंदा_ब्रेक {
$\ = "\f";
# $_ के साथ कुछ करें
}

आप संभवतः इस कोड के समतुल्य प्रिंट करने की अपेक्षा करते हैं

"1\r\n2\r\n3\r\n"

लेकिन इसके बजाय आपको मिलता है:

"1\f2\f3\f"

क्यों? क्योंकि "nasty_break()" "$\" को पहले स्थानीयकृत किए बिना संशोधित करता है। आपके द्वारा निर्धारित मान
आपके वापस लौटने पर भी "nasty_break()" मौजूद रहता है। समाधान यह है कि "स्थानीय()" जोड़ा जाए
मान "nasty_break()" से लीक नहीं होता है:

स्थानीय $\ = "\f";

इतने छोटे उदाहरण में समस्या को नोटिस करना आसान है, लेकिन अधिक जटिल कोड में आप
यदि आप विशेष चरों में परिवर्तनों को स्थानीयकृत नहीं करते हैं तो परेशानी की आशंका है।

$ARGV में "<>" से पढ़ते समय वर्तमान फ़ाइल का नाम शामिल होता है।

@ARGV सरणी @ARGV में स्क्रिप्ट के लिए इच्छित कमांड-लाइन तर्क शामिल हैं।
$#ARGV आम तौर पर तर्कों की संख्या शून्य से एक है, क्योंकि $ARGV[0] है
पहला तर्क, नहीं प्रोग्राम का कमांड नाम ही। आदेश के लिए "$0" देखें
नाम.

ARGV विशेष फ़ाइलहैंडल जो @ARGV में कमांड-लाइन फ़ाइल नामों पर पुनरावृत्त होता है।
आमतौर पर कोण ऑपरेटर "<>" में शून्य फ़ाइलहैंडल के रूप में लिखा जाता है। ध्यान दें कि
वर्तमान में "ARGV" का जादुई प्रभाव केवल "<>" ऑपरेटर के भीतर ही है; कहीं
यह "<>" द्वारा खोली गई अंतिम फ़ाइल के अनुरूप एक सादा फ़ाइलहैंडल मात्र है। में
विशेष रूप से, "\*ARGV" को उस फ़ंक्शन के पैरामीटर के रूप में पास करना जो अपेक्षा करता है
फ़ाइलहैंडल आपके फ़ंक्शन को सभी की सामग्री को स्वचालित रूप से पढ़ने का कारण नहीं बन सकता है
@ARGV में फ़ाइलें।

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

IO::हैंडल->आउटपुट_फील्ड_सेपरेटर(EXPR)
$OUTPUT_FIELD_SEPARATOR
$OFS
$, प्रिंट ऑपरेटर के लिए आउटपुट फ़ील्ड विभाजक। यदि परिभाषित किया जाए तो यह मान है
प्रत्येक प्रिंट के तर्कों के बीच मुद्रित। डिफ़ॉल्ट "अनिर्धारित" है।

आप किसी हैंडल पर "output_field_separator()" को केवल एक स्थिर विधि के रूप में कॉल नहीं कर सकते।
IO::हैंडल देखें।

स्मरणीय: जब आपके प्रिंट स्टेटमेंट में "," होता है तो क्या मुद्रित होता है।

हैंडल->input_line_number(EXPR)
$INPUT_LINE_NUMBER
$एनआर
$. अंतिम एक्सेस किए गए फ़ाइलहैंडल के लिए वर्तमान लाइन नंबर।

पर्ल में प्रत्येक फ़ाइलहैंडल उससे पढ़ी गई पंक्तियों की संख्या को गिनता है।
($/ के मूल्य के आधार पर, पर्ल का यह विचार नहीं हो सकता है कि एक पंक्ति क्या बनती है
अपने से मेल करें।) जब एक पंक्ति फ़ाइलहैंडल से पढ़ी जाती है ("रीडलाइन()" या "<>" के माध्यम से),
या जब उस पर "बताओ()" या "तलाश()" कहा जाता है, तो $। पंक्ति का उपनाम बन जाता है
उस फ़ाइलहैंडल के लिए काउंटर।

आप $ को निर्दिष्ट करके काउंटर को समायोजित कर सकते हैं, लेकिन यह वास्तव में स्थानांतरित नहीं होगा
सूचक की तलाश करें. स्थानीयकृत $. मर्जी नहीं स्थानीयकरण la फ़ाइलहैंडल line गणना.
इसके बजाय, यह पर्ल की धारणा को स्थानीयकृत करेगा कि कौन सा फ़ाइलहैंडल $। वर्तमान में है
उपनाम दिया गया।

$. फ़ाइलहैंडल बंद होने पर रीसेट हो जाता है, लेकिन नहीं जब एक खुला फाइलहैण्डल होता है
बिना किसी हस्तक्षेप के "बंद करें()" को फिर से खोल दिया गया। अधिक जानकारी के लिए, "I/O ऑपरेटर्स" देखें
पेरलोप में. चूँकि "<>" कभी भी स्पष्ट रूप से बंद नहीं होता है, पंक्ति संख्याएँ बढ़ जाती हैं
"ARGV" फ़ाइलों में (लेकिन perlfunc में "eof" में उदाहरण देखें)।

आप लाइन काउंटर तक पहुंचने के लिए "HANDLE->input_line_number(EXPR)" का भी उपयोग कर सकते हैं
किसी दिए गए फ़ाइलहैंडल को इस बात की चिंता किए बिना कि आपने अंतिम बार किस हैंडल तक पहुंच बनाई थी।

स्मरणीय: कई प्रोग्राम "" का उपयोग करते हैं। वर्तमान पंक्ति संख्या का मतलब है।

IO::Handle->input_record_separator(EXPR)
$INPUT_RECORD_SEPARATOR
$RS
$/ इनपुट रिकॉर्ड विभाजक, डिफ़ॉल्ट रूप से न्यूलाइन। यह पर्ल के विचार को प्रभावित करता है
"लाइन" क्या है. जैसे काम करता है awkका आरएस वैरिएबल, जिसमें खाली पंक्तियों को भी शामिल किया गया है
यदि एक टर्मिनेटर को शून्य स्ट्रिंग पर सेट किया जाता है (एक खाली लाइन में कोई रिक्त स्थान नहीं हो सकता है)।
टैब्स). आप इसे बहु-वर्ण से मेल खाने के लिए बहु-वर्ण स्ट्रिंग पर सेट कर सकते हैं
टर्मिनेटर, या फ़ाइल के अंत तक पढ़ने के लिए "अनडिफ़" करें। इसे "\n\n" पर सेट कर रहा हूँ
यदि फ़ाइल में शामिल है, तो इसका मतलब "" पर सेट करने से थोड़ा अलग है
लगातार खाली पंक्तियाँ. "" पर सेट करने से दो या अधिक लगातार खाली माने जाएंगे
पंक्तियाँ एक खाली पंक्ति के रूप में। "\n\n" पर सेट करने से आँख बंद करके यह मान लिया जाएगा कि अगला
इनपुट कैरेक्टर अगले पैराग्राफ से संबंधित है, भले ही वह एक नई पंक्ति हो।

स्थानीय $/; # "स्लर्प" मोड सक्षम करें
स्थानीय $_ = ; # पूरी फ़ाइल अब यहाँ
s/\n[ \t]+/ /g;

याद रखें: $/ का मान एक स्ट्रिंग है, रेगेक्स नहीं। awk के लिए बेहतर होना चाहिए
कुछ। :-)

किसी पूर्णांक, पूर्णांक युक्त अदिश, या अदिश के संदर्भ में $/ सेट करना
यह एक पूर्णांक में परिवर्तनीय है जो पंक्तियों के बजाय रिकॉर्ड को पढ़ने का प्रयास करेगा,
अधिकतम रिकॉर्ड आकार वर्णों की संदर्भित पूर्णांक संख्या है।
तो यह:

स्थानीय $/ = \32768; # या \"32768", या \$var_containing_32768
मेरा $fh, "<", $myfile याdie $! खोलें;
स्थानीय $_ = <$fh>;

$fh से 32768 से अधिक वर्णों का रिकॉर्ड नहीं पढ़ेगा। यदि आप नहीं हैं
रिकॉर्ड-उन्मुख फ़ाइल से पढ़ना (या आपके ओएस में रिकॉर्ड-उन्मुख नहीं है)।
फ़ाइलें), तो संभवतः आपको प्रत्येक पढ़ने के साथ डेटा का पूरा हिस्सा मिलेगा। यदि कोई रिकार्ड
यदि यह आपके द्वारा निर्धारित रिकॉर्ड आकार से बड़ा है, तो आपको रिकॉर्ड टुकड़ों में वापस मिल जाएगा।
रिकॉर्ड आकार को शून्य या उससे कम पर सेट करने का प्रयास अस्वीकार्य है और इससे $/ का नुकसान होगा
"अनडेफ़" का मान है, जो संपूर्ण (बाकी) में पढ़ने का कारण बनेगा
फ़ाइल.

5.19.9 के अनुसार $/ को किसी अन्य प्रकार के संदर्भ में सेट करने से घातक परिणाम सामने आएगा
अपवाद। यह भविष्य में $/ सेट करने के नए तरीकों का समर्थन करने की तैयारी में है।

केवल वीएमएस पर, रिकॉर्ड पेर्लिओ परतों और किसी भी संबंधित बफरिंग को बायपास करता है
आपको एक ही फाइलहैंडल पर रिकॉर्ड और गैर-रिकॉर्ड रीड्स को मिश्रित नहीं करना चाहिए। रिकार्ड मोड
लाइन मोड के साथ तभी मिश्रित होता है जब दोनों मोड के लिए समान बफरिंग परत का उपयोग किया जाता है।

आप किसी हैंडल पर "input_record_separator()" को केवल एक स्थिर विधि के रूप में कॉल नहीं कर सकते।
IO::हैंडल देखें।

पर्लपोर्ट में "न्यूलाइन्स" भी देखें। "$" भी देखें।

स्मरणीय: / कविता उद्धृत करते समय पंक्ति सीमाओं का परिसीमन करता है।

IO::हैंडल->आउटपुट_रिकॉर्ड_सेपरेटर(EXPR)
$OUTPUT_RECORD_SEPARATOR
$ओआरएस
$\ प्रिंट ऑपरेटर के लिए आउटपुट रिकॉर्ड विभाजक। यदि परिभाषित किया जाए तो यह मान है
प्रिंट के अंतिम तर्कों के बाद मुद्रित। डिफ़ॉल्ट "अनिर्धारित" है।

आप किसी हैंडल पर "output_record_separator()" को केवल एक स्थिर विधि के रूप में कॉल नहीं कर सकते।
IO::हैंडल देखें।

स्मरणीय: आपने प्रिंट के अंत में "\n" जोड़ने के बजाय "$\" सेट किया है। इसके अलावा, यह है
बिल्कुल $/ की तरह, लेकिन यह वही है जो आपको पर्ल से "वापस" मिलता है।

हैंडल->ऑटोफ्लश (एक्सपीआर)
$OUTPUT_ऑटोफ्लश
$| यदि शून्येतर पर सेट किया जाता है, तो तुरंत और प्रत्येक लिखने या प्रिंट करने के बाद फ्लश को बाध्य करता है
वर्तमान में चयनित आउटपुट चैनल। डिफ़ॉल्ट 0 है (इसकी परवाह किए बिना
चैनल वास्तव में सिस्टम द्वारा बफ़र किया गया है या नहीं; $| आपको केवल यह बताता है कि आपने किया है या नहीं
पर्ल से प्रत्येक लेखन के बाद स्पष्ट रूप से फ्लश करने के लिए कहा गया)। STDOUT आम तौर पर लाइन होगी
यदि आउटपुट टर्मिनल पर है तो बफ़र किया गया है और अन्यथा ब्लॉक बफ़र किया गया है। यह सेटिंग
वेरिएबल मुख्य रूप से तब उपयोगी होता है जब आप किसी पाइप या सॉकेट पर आउटपुट कर रहे हों, जैसे
जब आप एक पर्ल प्रोग्राम चला रहे हों RSH और आउटपुट को वैसा ही देखना चाहते हैं जैसा वह है
हो रहा है. इसका इनपुट बफ़रिंग पर कोई प्रभाव नहीं पड़ता है. इसके लिए perlfunc में "getc" देखें
वह। आउटपुट चैनल का चयन कैसे करें, इसके लिए perlfunc में "चयन करें" देखें। यह सभी देखें
आईओ::हैंडल.

स्मरणीय: जब आप चाहते हैं कि आपके पाइप बहुत गर्म हों।

${^LAST_FH}
इस रीड-ओनली वेरिएबल में अंतिम-रीड फ़ाइलहैंडल का संदर्भ शामिल है। यह है
द्वारा निर्धारित " ", "रीडलाइन", "बताएं", "ईओएफ" और "सीक"। यह वही हैंडल है
वह $. और बिना तर्क के "बताओ" और "ईओफ़" का उपयोग करें। इसमें हैंडल का भी उपयोग किया जाता है
जब पर्ल जोड़ता है ", किसी त्रुटि या चेतावनी संदेश के लिए पंक्ति 1"।

यह वेरिएबल पर्ल v5.18.0 में जोड़ा गया था।

चर सम्बंधित सेवा मेरे प्रारूपों

फ़ॉर्मेट के लिए विशेष चर फ़ाइल हैंडल के लिए विशेष चर का एक उपसमूह हैं। इसके लिए पर्लफॉर्म देखें
पर्ल के प्रारूपों के बारे में अधिक जानकारी।

$संचायक
$^A "प्रारूप()" लाइनों के लिए "लिखें()" संचायक का वर्तमान मूल्य। एक प्रारूप
इसमें "फॉर्मलाइन()" कॉल शामिल हैं जो अपना परिणाम $^A में डालते हैं। इसके कॉल करने के बाद
प्रारूप, "write()" $^A और रिक्तियों की सामग्री को प्रिंट करता है। तो आप वास्तव में कभी नहीं
$^A की सामग्री देखें जब तक कि आप स्वयं "फॉर्मलाइन ()" को कॉल न करें और फिर इसे देखें।
पर्लफंक में पर्लफॉर्म और "फॉर्मलाइन पिक्चर, लिस्ट" देखें।

IO::हैंडल->format_formfeed(EXPR)
$FORMAT_FORMFEED
$^L फॉर्म फ़ीड के रूप में आउटपुट को क्या प्रारूपित करता है। डिफ़ॉल्ट "\f" है।

आप किसी हैंडल पर "format_formfeed()" को केवल एक स्थिर विधि के रूप में कॉल नहीं कर सकते। देखना
आईओ::हैंडल.

हैंडल->format_page_number(EXPR)
$FORMAT_PAGE_NUMBER
$% वर्तमान में चयनित आउटपुट चैनल की वर्तमान पृष्ठ संख्या।

स्मरणीय: "%" पृष्ठ संख्या है एनरॉफ.

हैंडल->format_lines_left(EXPR)
$FORMAT_LINES_LEFT
$- वर्तमान में चयनित आउटपुट चैनल के पृष्ठ पर शेष पंक्तियों की संख्या।

स्मरणीय: लाइन्स_ऑन_पेज - लाइन्स_प्रिंटेड।

IO::Handle->format_line_break_characters EXPR
$FORMAT_LINE_BREAK_CHARACTERS
$: वर्णों का वर्तमान सेट जिसके बाद भरने के लिए एक स्ट्रिंग को तोड़ा जा सकता है
एक प्रारूप में निरंतरता फ़ील्ड ("^" से शुरू)। डिफ़ॉल्ट "\n-" है
किसी स्थान, न्यूलाइन, या हाइफ़न पर विराम लगाएं।

आप किसी हैंडल पर "format_line_break_characters()" को केवल स्टेटिक के रूप में कॉल नहीं कर सकते
तरीका। IO::हैंडल देखें।

स्मरणीय: कविता में "कोलन" एक पंक्ति का एक हिस्सा है।

हैंडल->format_lines_per_page(EXPR)
$FORMAT_LINES_PER_PAGE
$= वर्तमान में चयनित आउटपुट की वर्तमान पृष्ठ लंबाई (मुद्रण योग्य पंक्तियाँ)।
चैनल। डिफ़ॉल्ट 60 है.

स्मरणीय: = क्षैतिज रेखाएँ हैं।

हैंडल->format_top_name(EXPR)
$FORMAT_TOP_NAME
$^ वर्तमान में चयनित आउटपुट के लिए वर्तमान शीर्ष-पृष्ठ प्रारूप का नाम
चैनल। डिफ़ॉल्ट फ़ाइलहैंडल का नाम है जिसके साथ "_TOP" जुड़ा हुआ है। के लिए
उदाहरण के लिए, "STDOUT" फ़ाइलहैंडल के लिए डिफ़ॉल्ट प्रारूप शीर्ष नाम "STDOUT_TOP" है।

स्मरणीय: पृष्ठ के शीर्ष की ओर इंगित करता है।

हैंडल->format_name(EXPR)
$FORMAT_NAME
$~ वर्तमान में चयनित आउटपुट चैनल के लिए वर्तमान रिपोर्ट प्रारूप का नाम।
डिफ़ॉल्ट प्रारूप नाम फ़ाइलहैंडल नाम के समान है। उदाहरण के लिए,
"STDOUT" फ़ाइलहैंडल के लिए डिफ़ॉल्ट प्रारूप नाम केवल "STDOUT" है।

स्मरणीय: भाई से $^.

त्रुटि चर
चर $@, $!, $^E, और $? इसमें विभिन्न प्रकार की त्रुटि के बारे में जानकारी होती है
ऐसी स्थितियाँ जो पर्ल प्रोग्राम के निष्पादन के दौरान दिखाई दे सकती हैं। चर दिखाए गए हैं
त्रुटि की सूचना देने वाले सबसिस्टम और पर्ल के बीच "दूरी" द्वारा आदेश दिया गया
प्रक्रिया। वे पर्ल दुभाषिया, सी लाइब्रेरी, संचालन द्वारा पाई गई त्रुटियों के अनुरूप हैं
सिस्टम, या एक बाहरी प्रोग्राम, क्रमशः।

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

इवल क्यू {
मेरा $पाइप खोलें, "/cdrom/install |" या मरो $!;
मेरा @res = <$पाइप>;
$पाइप बंद करें या "ख़राब पाइप: $?, $!" बंद करें;
};

जब पर्ल "eval()" एक्सप्रेशन निष्पादित करता है, तो यह "ओपन()", "का अनुवाद करता है ", और
सी रन-टाइम लाइब्रेरी में "बंद करें" कॉल और फिर ऑपरेटिंग सिस्टम कर्नेल पर। पर्ल
सेट $! यदि इनमें से एक कॉल विफल हो जाती है तो सी लाइब्रेरी के "त्रुटिपूर्ण" पर।

यदि "eval"-ed होने वाली स्ट्रिंग संकलित नहीं होती है तो $@ सेट किया जाता है (ऐसा तब हो सकता है जब "खुला" हो या
"बंद करें" खराब प्रोटोटाइप के साथ आयात किए गए थे), या यदि मूल्यांकन के दौरान पर्ल कोड निष्पादित किया गया था
"मृत। इन मामलों में $@ का मान संकलन त्रुटि है, या "मरने" का तर्क है
(जो $! और $? को प्रक्षेपित करेगा)। (हालांकि घातक भी देखें।)

कुछ ऑपरेटिंग सिस्टम के अंतर्गत, $^E में अधिक वर्बोज़ त्रुटि संकेतक हो सकता है, जैसे कि in
इस मामले में, "सीडीरॉम ट्रे बंद नहीं है।" सिस्टम जो विस्तारित त्रुटि संदेशों का समर्थन नहीं करते हैं
$^E को $! के समान ही छोड़ें।

अंततः, $? यदि बाहरी प्रोग्राम गैर-0 मान पर सेट किया जा सकता है /सीड्रोम/इंस्टॉल करें विफल रहता है.
ऊपरी आठ बिट्स प्रोग्राम द्वारा सामना की गई विशिष्ट त्रुटि स्थितियों को दर्शाते हैं
प्रोग्राम का "निकास ()" मान)। निचले आठ बिट सिग्नल की तरह विफलता के मोड को दर्शाते हैं
मृत्यु और कोर डंप जानकारी। देखना प्रतीक्षा(2) विवरण के लिए। $ के विपरीत! और $^ई,
जो केवल तभी सेट किए जाते हैं जब त्रुटि स्थिति का पता चलता है, वेरिएबल $? प्रत्येक "प्रतीक्षा" पर सेट है
या पाइप "बंद करें", पुराने मान को अधिलेखित कर दें। यह अधिक $@ जैसा है, जो प्रत्येक "eval()" पर होता है
हमेशा विफलता पर निर्धारित किया जाता है और सफलता पर साफ़ किया जाता है।

अधिक विवरण के लिए, $@, $!, $^E, और $? पर अलग-अलग विवरण देखें।

${^CHILD_ERROR_NATIVE}
अंतिम पाइप बंद होने, बैकटिक ("``") कमांड द्वारा लौटाई गई मूल स्थिति,
"प्रतीक्षा()" या "प्रतीक्षापिड()", या "सिस्टम()" ऑपरेटर से सफल कॉल। पर
POSIX-जैसे सिस्टम में इस मान को WIFEXITED, WEXITSTATUS के साथ डिकोड किया जा सकता है।
WIFSIGNALED, WTERMSIG, WIFSTOPPED, WSTOPSIG और WIFCONTINUED फ़ंक्शन प्रदान किए गए
POSIX मॉड्यूल।

वीएमएस के तहत यह वास्तविक वीएमएस निकास स्थिति को दर्शाता है; यानी यह $ के समान है? कब
''vmsish 'status' का उपयोग करें'' का सिद्धांत प्रभावी है।

यह वेरिएबल पर्ल v5.10.0 में जोड़ा गया था।

$EXTENDED_OS_ERROR
$^E वर्तमान ऑपरेटिंग सिस्टम के लिए विशिष्ट त्रुटि जानकारी। फिलहाल, ये
$ से भिन्न है! केवल VMS, OS/2 और Win32 के अंतर्गत (और MacPerl के लिए)। बाकी सब पर
प्लेटफ़ॉर्म, $^E हमेशा $! के समान ही होता है।

वीएमएस के तहत, $^E अंतिम सिस्टम त्रुटि से वीएमएस स्थिति मान प्रदान करता है। यह है
अंतिम सिस्टम त्रुटि के बारे में $! द्वारा प्रदान की गई जानकारी से अधिक विशिष्ट जानकारी।
यह विशेष रूप से महत्वपूर्ण है जब $! इसके लिए सेट है ईवीएमएसईआरआर.

OS/2 के अंतर्गत, $^E को OS/2 API के माध्यम से अंतिम कॉल के त्रुटि कोड पर सेट किया जाता है
सीआरटी, या सीधे पर्ल से।

Win32 के अंतर्गत, $^E हमेशा Win32 द्वारा रिपोर्ट की गई अंतिम त्रुटि जानकारी लौटाता है
"GetLastError()" पर कॉल करें जो Win32 API के भीतर से अंतिम त्रुटि का वर्णन करता है।
अधिकांश Win32-विशिष्ट कोड $^E के माध्यम से त्रुटियों की रिपोर्ट करेंगे। एएनएसआई सी और यूनिक्स जैसी कॉल
"errno" सेट करें और इसलिए अधिकांश पोर्टेबल पर्ल कोड $! के माध्यम से त्रुटियों की रिपोर्ट करेगा।

$ के विवरण में उल्लिखित चेतावनियाँ! आम तौर पर $^E पर भी लागू होता है।

यह वेरिएबल पर्ल 5.003 में जोड़ा गया था।

स्मरणीय: अतिरिक्त त्रुटि स्पष्टीकरण।

$EXCEPTIONS_BEING_CAUGHT
$^S दुभाषिया की वर्तमान स्थिति।

$^S राज्य
------------------------------------------------------
अनडिफ़ पार्सिंग मॉड्यूल, eval, या मुख्य प्रोग्राम
सत्य (1) एक eval निष्पादित करना
असत्य (0) अन्यथा

पहली स्थिति $SIG{__DIE__} और $SIG{__WARN__} हैंडलर में हो सकती है।

अंग्रेजी नाम $EXCEPTIONS_BEING_CAUGHT थोड़ा भ्रामक है, क्योंकि
"अनडेफ़" मान यह नहीं दर्शाता है कि अपवाद पकड़े जा रहे हैं या नहीं
मुख्य कार्यक्रम का संकलन अपवादों को नहीं पकड़ता है।

यह वेरिएबल पर्ल 5.004 में जोड़ा गया था।

$चेतावनी
$^W चेतावनी स्विच का वर्तमान मान, प्रारंभ में सत्य है यदि -w प्रयोग किया गया, मिथ्या
अन्यथा, लेकिन सीधे परिवर्तनीय।

चेतावनियाँ भी देखें.

स्मरणीय: से संबंधित -w स्विच.

${^चेतावनी_बिट्स}
चेतावनी जांच का वर्तमान सेट "चेतावनी का उपयोग करें" प्रगति द्वारा सक्षम किया गया है। यह है
$^H और "%^H" वेरिएबल के समान स्कोपिंग। सटीक मानों पर विचार किया जाता है
चेतावनियों में आंतरिक और पर्ल के संस्करणों के बीच परिवर्तन हो सकता है।

यह वेरिएबल पर्ल v5.6.0 में जोड़ा गया था।

$OS_ERROR
$ERNO
$! जब संदर्भित किया गया, $! C "errno" पूर्णांक चर का वर्तमान मान पुनर्प्राप्त करता है।
यदि $! एक संख्यात्मक मान निर्दिष्ट किया गया है, वह मान "त्रुटि" में संग्रहीत है। कब
एक स्ट्रिंग के रूप में संदर्भित, $! के अनुरूप सिस्टम त्रुटि स्ट्रिंग उत्पन्न करता है
"गलत"।

कई सिस्टम या लाइब्रेरी कॉल विफल होने पर इसका कारण बताने के लिए "त्रुटि" सेट करते हैं
असफलता। वे आमतौर पर ऐसा करते हैं नहीं यदि वे सफल होते हैं तो "errno" को शून्य पर सेट करें। इसका मतलब यह है
"त्रुटि", इसलिए $!, केवल अर्थपूर्ण है तुरंत एक के बाद विफलता:

यदि (मेरा $fh, "<", $फ़ाइल नाम खोलें) {
#यहाँ $! अर्थहीन है.
...
}
और {
# केवल यहाँ $ है! सार्थक.
...
# पहले से ही यहाँ $! अर्थहीन हो सकता है.
}
#चूँकि यहाँ हमें या तो सफलता या असफलता मिल सकती है,
#$! अर्थहीन है.

यहाँ, व्यर्थ इसका मतलब है कि $! "ओपन()" के परिणाम से असंबंधित हो सकता है
ऑपरेटर। $ को असाइनमेंट! वैसे ही क्षणभंगुर है. इसे तुरंत इस्तेमाल किया जा सकता है
"डाई()" ऑपरेटर को लागू करने से पहले, निकास मूल्य निर्धारित करने के लिए, या निरीक्षण करने के लिए
त्रुटि के अनुरूप सिस्टम त्रुटि स्ट्रिंग n, या $ पुनर्स्थापित करने के लिए! एक सार्थक के लिए
राज्य.

स्मरणीय: अभी-अभी क्या धमाका हुआ?

%OS_ERROR
%ERRNO
%! "%!" का प्रत्येक तत्व इसका वास्तविक मूल्य केवल तभी होता है जब $! उस मान पर सेट है. के लिए
उदाहरण के लिए, $!{ENOENT} सत्य है यदि और केवल यदि $ का वर्तमान मान! "एनोएंट" है;
अर्थात्, यदि सबसे हालिया त्रुटि "ऐसी कोई फ़ाइल या निर्देशिका नहीं" (या इसका नैतिक) थी
समतुल्य: सभी ऑपरेटिंग सिस्टम वह सटीक त्रुटि नहीं देते हैं, और निश्चित रूप से सभी नहीं
भाषाएँ)। विशिष्ट वास्तविक मूल्य की गारंटी नहीं है, लेकिन अतीत में है
आम तौर पर $! का संख्यात्मक मान होता है। यह जाँचने के लिए कि क्या कोई विशेष कुंजी है
आपके सिस्टम पर अर्थपूर्ण, "exists $!{the_key}" का उपयोग करें; कानूनी कुंजियों की सूची के लिए, उपयोग करें
"चांबियाँ %!"। अधिक जानकारी के लिए इरनो देखें, और "$!" भी देखें।

यह वेरिएबल पर्ल 5.005 में जोड़ा गया था।

$CHILD_ERROR
$? अंतिम पाइप बंद होने, बैकटिक ("``") कमांड द्वारा लौटाई गई स्थिति, सफल
"प्रतीक्षा()" या "प्रतीक्षापिड()", या "सिस्टम()" ऑपरेटर से कॉल करें। यह तो सिर्फ
पारंपरिक यूनिक्स "प्रतीक्षा ()" सिस्टम कॉल (या) द्वारा लौटाया गया 16-बिट स्टेटस शब्द
अन्यथा इसके जैसा दिखने के लिए बनाया गया है)। इस प्रकार, उपप्रक्रिया का निकास मान है
वास्तव में ("$? >> 8"), और "$? & 127" कौन सा संकेत देता है, यदि कोई हो, तो प्रक्रिया समाप्त हो गई
from, और "$? & 128" रिपोर्ट करता है कि क्या कोई कोर डंप था।

इसके अतिरिक्त, यदि "h_errno" वेरिएबल C में समर्थित है, तो इसका मान वापस कर दिया जाता है
$ के माध्यम से? यदि कोई "gethost*()" फ़ंक्शन विफल हो जाता है।

यदि आपने "SIGCHLD" के लिए सिग्नल हैंडलर स्थापित किया है, तो $ का मान क्या होगा? आमतौर पर होगा
उस हैंडलर के बाहर गलत हो।

एक "END" सबरूटीन के अंदर $? इसमें वह मान शामिल है जो दिया जाने वाला है
"बाहर निकलना()"। आप $ को संशोधित कर सकते हैं? की निकास स्थिति को बदलने के लिए "END" सबरूटीन में
आपका कार्यक्रम. उदाहरण के लिए:

अंत {
$? = 1 यदि $? ==255; # मरने पर यह 255 हो जाएगा
}

वीएमएस के तहत, प्राग्मा "vmsish 'status' का उपयोग करें" $ बनाता है? वास्तविक वीएमएस निकास को प्रतिबिंबित करें
स्थिति, POSIX स्थिति के डिफ़ॉल्ट अनुकरण के बजाय; देखें "$?" के लिए perlvms में
विवरण।

स्मरणीय: के समान sh और क्ष.

$EVAL_ERROR
$@ अंतिम "eval()" ऑपरेटर से पर्ल सिंटैक्स त्रुटि संदेश। यदि $@ शून्य है
स्ट्रिंग, अंतिम "eval()" को पार्स किया गया और सही ढंग से निष्पादित किया गया (हालांकि ऑपरेशंस
हो सकता है कि आपका आह्वान सामान्य तरीके से विफल हो गया हो)।

इस वेरिएबल में चेतावनी संदेश एकत्र नहीं किए जाते हैं। हालाँकि, आप एक सेट अप कर सकते हैं
जैसा कि "%SIG" में वर्णित है, $SIG{__WARN__} सेट करके चेतावनियों को संसाधित करने की दिनचर्या।

स्मरणीय: वाक्यविन्यास त्रुटि "at" कहाँ थी?

चर सम्बंधित सेवा मेरे la दुभाषिया राज्य
ये चर वर्तमान दुभाषिया स्थिति के बारे में जानकारी प्रदान करते हैं।

$संकलन
$^C से संबद्ध ध्वज का वर्तमान मूल्य -c बदलना। मुख्य रूप से उपयोग के साथ
-एमओ=... संकलित करते समय कोड को अपना व्यवहार बदलने की अनुमति देना, जैसे कि
सामान्य, विलंबित लोडिंग के बजाय संकलन समय पर "ऑटोलोड" करने का उदाहरण।
"$^C = 1" सेट करना "B::minus_c" को कॉल करने के समान है।

यह वेरिएबल पर्ल v5.6.0 में जोड़ा गया था।

$डिबगिंग
$^D डिबगिंग फ़्लैग का वर्तमान मान। पढ़ा या सेट किया जा सकता है. इसके आदेश की तरह-
पंक्ति समतुल्य, आप संख्यात्मक या प्रतीकात्मक मानों का उपयोग कर सकते हैं, उदाहरण के लिए "$^D = 10" या "$^D =
"अनुसूचित जनजाति""।

स्मरणीय: का मूल्य -D स्विच.

${^एनकोडिंग}
अस्वीकृत!!!

RSI वस्तु संदर्भ "एनकोड" ऑब्जेक्ट में जिसका उपयोग स्रोत को परिवर्तित करने के लिए किया जाता है
यूनिकोड को कोड। इस वेरिएबल के कारण आपकी पर्ल स्क्रिप्ट का होना आवश्यक नहीं है
UTF-8 में लिखा गया है। डिफ़ॉल्ट "अनिर्धारित" है।

इस वेरिएबल को "अनडेफ़" के अलावा किसी अन्य मान पर सेट करने के कारण बहिष्कृत कर दिया गया है
इसके डिज़ाइन और कार्यान्वयन में मूलभूत दोष। इसे हटाने की योजना बनाई गई है
भविष्य के पर्ल संस्करण से। इसका उद्देश्य आपकी गैर-ASCII पर्ल स्क्रिप्ट को अनुमति देना था
UTF-8 में लिखने की आवश्यकता नहीं है; यह उन संपादकों के लिए उपयोगी था जिन पर काम किया गया था
यूटीएफ-8 एन्कोडेड टेक्स्ट आम थे, लेकिन यह बहुत पहले की बात है। यह समस्याओं का कारण बनता है, जैसे
अन्य मॉड्यूल के संचालन को प्रभावित करने के कारण जो इसकी अपेक्षा नहीं कर रहे हैं
सामान्य तबाही. इसके उपयोग से सेगफॉल्ट हो सकते हैं।

यदि आपको इस तरह की कार्यक्षमता की आवश्यकता है, तो आपको एन्कोडिंग प्राग्मा का उपयोग करना चाहिए,
जिसकी भी निंदा की जाती है, लेकिन इसके दुष्प्रभाव कम होते हैं।

यदि आप यहां इसलिए आ रहे हैं क्योंकि आपके कोड पर प्रतिकूल प्रभाव पड़ रहा है
यदि कोई इस चर का उपयोग कर रहा है, तो आप आमतौर पर ऐसा करके इसके आसपास काम कर सकते हैं:

स्थानीय ${^एन्कोडिंग};

फ़ंक्शंस की शुरुआत के करीब जो टूट रहे हैं। यह अपरिभाषित करता है
फ़ंक्शन सहित निष्पादन के दायरे के दौरान परिवर्तनीय।

यह वेरिएबल पर्ल 5.8.2 में जोड़ा गया था।

${^ग्लोबल_PHASE}
पर्ल दुभाषिया का वर्तमान चरण।

संभावित मान हैं:

निर्माण
"PerlInterpreter*" का निर्माण "perl_construct" के माध्यम से किया जा रहा है। यह
मूल्य अधिकतर पूर्णता के लिए और अंतर्निहित सी के माध्यम से उपयोग के लिए होता है
चर "PL_phase"। पर्ल कोड का होना वास्तव में संभव नहीं है
जब तक दुभाषिया का निर्माण पूरा नहीं हो जाता तब तक निष्पादित किया जाता है।

प्रारंभ करें यह वैश्विक संकलन-समय है। इसमें मूल रूप से प्रत्येक "शुरू" शामिल है
संकलन-समय के दौरान प्रत्यक्ष या अप्रत्यक्ष रूप से निष्पादित ब्लॉक
शीर्ष स्तरीय कार्यक्रम.

"BEGIN"-ब्लॉक के साथ भ्रम से बचने के लिए इस चरण को "BEGIN" नहीं कहा जाता है,
जैसा कि किसी संकलन इकाई के संकलन-समय के दौरान निष्पादित किया जाता है, नहीं
बस शीर्ष स्तर का कार्यक्रम. रन पर एक नया, स्थानीयकृत संकलन-समय दर्ज किया गया-
समय, उदाहरण के लिए "eval "useSomeModule" जैसी रचनाएं वैश्विक नहीं हैं
दुभाषिया चरण, और इसलिए "${^GLOBAL_PHASE}" द्वारा प्रतिबिंबित नहीं होते हैं।

किसी भी "चेक" ब्लॉक का निष्पादन जांचें।

INIT "CHECK" के समान है, लेकिन "INIT"-ब्लॉक के लिए, "CHECK" ब्लॉक के लिए नहीं।

RUN मुख्य रन-टाइम, यानी "PL_main_root" का निष्पादन।

END किसी भी "END" ब्लॉक का निष्पादन।

संहार
वैश्विक विनाश.

यह भी ध्यान दें कि UNITCHECK-ब्लॉक का कोई मूल्य नहीं है। ऐसा इसलिए है क्योंकि वे हैं
प्रत्येक संकलन इकाई के लिए अलग-अलग चलाएँ, और इसलिए यह वैश्विक नहीं है
दुभाषिया चरण.

प्रत्येक कार्यक्रम को प्रत्येक संभावित चरण से नहीं, बल्कि संक्रमण से गुजरना पड़ता है
एक चरण से दूसरे चरण में केवल ऊपर वर्णित क्रम में ही हो सकता है
सूची।

पर्ल कोड उन सभी चरणों का एक उदाहरण देख सकता है:

प्रारंभ करें {प्रिंट "संकलन-समय: ${^GLOBAL_PHASE}\n" }

INIT {प्रिंट "init-time: ${^GLOBAL_PHASE}\n" }

जाँचें {प्रिंट करें "चेक-समय: ${^GLOBAL_PHASE}\n" }

{
पैकेज प्रिंट::चरण;

उप नया {
मेरा ($कक्षा, $समय) = @_;
वापसी आशीर्वाद \$समय, $वर्ग;
}

उप नष्ट {
मेरा $ स्वयं = शिफ्ट;
प्रिंट करें "$$self: ${^GLOBAL_PHASE}\n";
}
}

प्रिंट करें "रन-टाइम: ${^GLOBAL_PHASE}\n";

मेरा $रनटाइम = प्रिंट::फ़ेज़->नया(
"लेक्सिकल वैरिएबल END से पहले एकत्र किया गया कचरा है"
);

END {प्रिंट "अंत-समय: ${^GLOBAL_PHASE}\n" }

हमारा $destruct = Print::Phase->new(
"पैकेज वैरिएबल END के बाद एकत्र किया गया कचरा है"
);

यह प्रिंट आउट हो जाएगा

संकलन-समय: प्रारंभ करें
चेक-टाइम: चेक करें
init-समय: INIT
रन-टाइम: रन
शाब्दिक चर END: RUN से पहले एकत्र किया गया कचरा है
अंत समय: अंत
पैकेज वैरिएबल END: DESTRUCT के बाद एकत्र किया गया कचरा है

यह वेरिएबल पर्ल 5.14.0 में जोड़ा गया था।

$^H चेतावनी: यह वेरिएबल केवल आंतरिक उपयोग के लिए है। इसकी उपलब्धता,
व्यवहार और सामग्री बिना सूचना के परिवर्तन के अधीन हैं।

इस वेरिएबल में पर्ल दुभाषिया के लिए संकलन-समय संकेत शामिल हैं। के अंत में
किसी ब्लॉक का संकलन करते समय इस चर का मान उस मान पर पुनर्स्थापित किया जाता है
दुभाषिया ने ब्लॉक संकलित करना शुरू कर दिया।

जब पर्ल किसी ब्लॉक निर्माण को पार्स करना शुरू करता है जो एक शाब्दिक दायरा प्रदान करता है (उदाहरण के लिए,
ईवल बॉडी, आवश्यक फ़ाइल, सबरूटीन बॉडी, लूप बॉडी, या कंडीशनल ब्लॉक), द
$^H का मौजूदा मूल्य सहेजा गया है, लेकिन इसका मूल्य अपरिवर्तित छोड़ दिया गया है। जब
ब्लॉक का संकलन पूरा हो गया है, यह सहेजे गए मान को पुनः प्राप्त कर लेता है। बीच
ऐसे बिंदु जहां इसका मूल्य सहेजा और पुनर्स्थापित किया जाता है, कोड जो BEGIN के भीतर निष्पादित होता है
ब्लॉक $^H का मान बदलने के लिए स्वतंत्र है।

यह व्यवहार शाब्दिक दायरे का अर्थ प्रदान करता है, और इसका उपयोग, के लिए किया जाता है
उदाहरण के लिए, "सख्त उपयोग करें" व्यावहारिकता।

सामग्री पूर्णांक होनी चाहिए; इसके अलग-अलग बिट्स का अलग-अलग उपयोग किया जाता है
व्यावहारिक झंडे. यहाँ एक उदाहरण है:

उप add_100 { $^H |= 0x100 }

उप फू {
प्रारंभ करें { add_100() }
बार->बाज़($वरदान);
}

विचार करें कि BEGIN ब्लॉक के निष्पादन के दौरान क्या होता है। इस बिंदु पर
BEGIN ब्लॉक पहले ही संकलित किया जा चुका है, लेकिन "foo()" का मुख्य भाग अभी भी संकलित किया जा रहा है
संकलित. इसलिए $^H का नया मान केवल मुख्य भाग के दौरान ही दिखाई देगा
"foo()" संकलित किया जा रहा है।

"BEGIN { add_100() }" ब्लॉक का प्रतिस्थापन:

शुरू करें { सख्त आवश्यकता है; सख्त->आयात('vars') }

दर्शाता है कि कैसे "सख्त 'वर्स' का उपयोग करें" लागू किया जाता है। यहाँ एक सशर्त संस्करण है
उसी शाब्दिक व्यावहारिकता का:

शुरू {
सख्त आवश्यकता है; सख्त->आयात('vars') यदि $condition
}

यह वेरिएबल पर्ल 5.003 में जोड़ा गया था।

%^H "%^H" हैश $^H के समान स्कोपिंग सिमेंटिक प्रदान करता है। यह इसे उपयोगी बनाता है
शाब्दिक रूप से दायरे वाले प्राग्मास के कार्यान्वयन के लिए। पर्लप्राग्मा देखें। सभी प्रविष्टियाँ
रनटाइम पर पहुंचने पर स्ट्रिंगीकृत हो जाते हैं, इसलिए केवल साधारण मान ही हो सकते हैं
समायोजित. उदाहरण के लिए, इसका मतलब वस्तुओं के लिए कोई संकेतक नहीं है।

अन्य उपयोगकर्ताओं के साथ टकराव से बचने के लिए आइटम को "%^H" में डालते समय
हैश में किस कुंजी का उपयोग करना है इसके संबंध में एक परंपरा है। एक मॉड्यूल का उपयोग करना चाहिए
केवल वे कुंजियाँ जो मॉड्यूल के नाम (इसके मुख्य पैकेज का नाम) और a से शुरू होती हैं
"/" चरित्र। उदाहरण के लिए, एक मॉड्यूल "Foo::Bar" को कुंजियों का उपयोग करना चाहिए जैसे
"फू::बार/बाज़"।

यह वेरिएबल पर्ल v5.6.0 में जोड़ा गया था।

${^खुला}
PerlIO द्वारा उपयोग किया जाने वाला एक आंतरिक चर। दो भागों में एक स्ट्रिंग, जिसे "\0" से अलग किया गया है
बाइट, पहला भाग इनपुट परतों का वर्णन करता है, दूसरा भाग वर्णन करता है
आउटपुट परतें।

यह वेरिएबल पर्ल v5.8.0 में जोड़ा गया था।

$PERLDB
$^P डिबगिंग समर्थन के लिए आंतरिक चर। विभिन्न बिट्स के अर्थ हैं
परिवर्तन के अधीन है, लेकिन वर्तमान में संकेत मिलता है:

0x01 डीबग सबरूटीन प्रवेश/निकास।

0x02 लाइन-दर-लाइन डिबगिंग। प्रत्येक के लिए "DB::DB()" सबरूटीन को कॉल करने का कारण बनता है
कथन निष्पादित. स्रोत कोड लाइनों (जैसे 0x400) को सहेजने का भी कारण बनता है।

0x04 अनुकूलन बंद करें.

0x08 भविष्य के इंटरैक्टिव निरीक्षणों के लिए अधिक डेटा सुरक्षित रखें।

0x10 उन स्रोत लाइनों के बारे में जानकारी रखें जिन पर सबरूटीन परिभाषित है।

0x20 सिंगल-स्टेप ऑन से प्रारंभ करें।

0x40 रिपोर्टिंग करते समय नाम के बजाय सबरूटीन पते का उपयोग करें।

0x80 "गोटो और सबरूटीन" की भी रिपोर्ट करें।

0x100 ईवल्स के लिए उनके स्थान के आधार पर जानकारीपूर्ण "फ़ाइल" नाम प्रदान करें
संकलित।

0x200 अज्ञात सबरूटीन्स को उनके स्थान के आधार पर सूचनात्मक नाम प्रदान करें
संकलित किये गये।

0x400 स्रोत कोड पंक्तियों को "@{"_<$filename"}" में सहेजें।

0x800 स्रोत को सहेजते समय, ऐसे evals शामिल करें जो कोई सबरूटीन उत्पन्न नहीं करते हैं।

0x1000
स्रोत सहेजते समय, वह स्रोत शामिल करें जो संकलित नहीं हुआ।

कुछ बिट्स केवल संकलन-समय पर प्रासंगिक हो सकते हैं, कुछ केवल रन-टाइम पर। यह है एक
नई व्यवस्था और विवरण बदल सकते हैं। Perldebguts भी देखें.

${^TAINT}
यदि टैन मोड चालू या बंद है तो प्रतिबिंबित करता है। 1 के लिए (प्रोग्राम के साथ चलाया गया था -T) 0
ऑफ के लिए, -1 जब केवल दागी चेतावनियाँ सक्षम होती हैं (अर्थात् -t or -तु).

यह वेरिएबल केवल पढ़ने योग्य है.

यह वेरिएबल पर्ल v5.8.0 में जोड़ा गया था।

${^यूनिकोड}
पर्ल की कुछ यूनिकोड सेटिंग्स को दर्शाता है। "-C" के लिए perlrun दस्तावेज़ देखें
संभावित मानों के बारे में अधिक जानकारी के लिए स्विच करें।

यह वेरिएबल पर्ल स्टार्टअप के दौरान सेट किया गया है और उसके बाद केवल-पढ़ने के लिए है।

यह वेरिएबल पर्ल v5.8.2 में जोड़ा गया था।

${^UTF8CACHE}
यह वैरिएबल आंतरिक UTF-8 ऑफसेट कैशिंग कोड की स्थिति को नियंत्रित करता है। 1 के लिए
ऑन (डिफ़ॉल्ट), 0 फॉर ऑफ, -1 कैशिंग कोड को डीबग करने के लिए इसकी सभी जांच करें
रैखिक स्कैन के विरुद्ध परिणाम, और किसी भी विसंगति पर घबरा जाना।

यह वेरिएबल पर्ल v5.8.9 में जोड़ा गया था। यह परिवर्तन या निष्कासन के अधीन है
बिना किसी सूचना के, लेकिन वर्तमान में इसका उपयोग सीमाओं की पुनर्गणना से बचने के लिए किया जाता है
मल्टी-बाइट UTF-8-एन्कोडेड वर्ण।

${^UTF8LOCALE}
यह वेरिएबल इंगित करता है कि स्टार्टअप पर पर्ल द्वारा UTF-8 लोकेल का पता लगाया गया था या नहीं।
इस जानकारी का उपयोग पर्ल द्वारा तब किया जाता है जब यह एडजस्ट-यूटीएफ8नेस-टू-लोकेल मोड में होता है (जैसा कि)।
जब "-CL" कमांड-लाइन स्विच के साथ चलाया जाता है); इस पर अधिक जानकारी के लिए perlrun देखें।

यह वेरिएबल पर्ल v5.8.8 में जोड़ा गया था।

पदावनत और हटाया चर
किसी वेरिएबल को अस्वीकृत करना अंततः पर्ल अनुरक्षकों को हटाने के इरादे की घोषणा करता है
भाषा से चर. यह अपनी स्थिति के बावजूद अभी भी उपलब्ध हो सकता है। इसका उपयोग करना
बहिष्कृत वैरिएबल एक चेतावनी ट्रिगर करता है।

एक बार जब एक वेरिएबल हटा दिया जाता है, तो इसका उपयोग आपको यह बताने में त्रुटि उत्पन्न करता है कि वेरिएबल कौन सा है
असमर्थित।

त्रुटि संदेशों के बारे में विवरण के लिए perldiag देखें।

$# $# एक वेरिएबल था जिसका उपयोग मुद्रित संख्याओं को प्रारूपित करने के लिए किया जा सकता था। बाद एक
बहिष्करण चक्र, इसका जादू पर्ल v5.10.0 में हटा दिया गया था और अब इसका उपयोग ट्रिगर हो गया है
एक चेतावनी: "$# अब समर्थित नहीं है"।

यह वह संकेत नहीं है जिसका उपयोग आप अंतिम अनुक्रमणिका प्राप्त करने के लिए किसी सरणी नाम के सामने करते हैं,
$#सरणी की तरह। यह अभी भी है कि आप पर्ल में किसी सरणी का अंतिम सूचकांक कैसे प्राप्त करते हैं।
दोनों का एक-दूसरे से कोई लेना-देना नहीं है।

पर्ल 5 में बहिष्कृत।

पर्ल v5.10.0 में हटा दिया गया।

$* $* एक वैरिएबल था जिसका उपयोग आप मल्टीलाइन मिलान को सक्षम करने के लिए कर सकते हैं। बाद एक
बहिष्करण चक्र, इसका जादू पर्ल v5.10.0 में हटा दिया गया था। अब इसका उपयोग करने से ट्रिगर होता है
चेतावनी: "$* अब समर्थित नहीं है"। आपको "/s" और "/m" regexp का उपयोग करना चाहिए
इसके बजाय संशोधक.

पर्ल 5 में बहिष्कृत।

पर्ल v5.10.0 में हटा दिया गया।

$[ यह वेरिएबल किसी ऐरे में पहले तत्व और पहले तत्व के सूचकांक को संग्रहीत करता है
एक सबस्ट्रिंग में वर्ण. डिफ़ॉल्ट 0 है, लेकिन आप सैद्धांतिक रूप से इसे इस पर सेट कर सकते हैं
1 पर्ल के जैसा व्यवहार करने के लिए awk (या फोरट्रान) सबस्क्रिप्ट कब और कब
का मूल्यांकन कर रहे हैं सूचकांक () और पदार्थ () कार्य करता है.

पर्ल के रिलीज़ 5 के अनुसार, $[ को असाइनमेंट को एक कंपाइलर निर्देश के रूप में माना जाता है, और
किसी अन्य फ़ाइल के व्यवहार को प्रभावित नहीं कर सकता. (इसलिए आप केवल असाइन कर सकते हैं
इसमें संकलन-समय स्थिरांक है।) इसका उपयोग अत्यधिक हतोत्साहित किया जाता है।

पर्ल v5.10.0 से पहले, $[ के असाइनमेंट को बाहरी शाब्दिक दायरे से देखा जा सकता था
अन्य संकलन-समय निर्देशों (जैसे सख्त) के विपरीत, वही फ़ाइल। का उपयोग करते हुए
स्थानीय () इस पर इसका मूल्य सख्ती से एक शाब्दिक ब्लॉक से बंध जाएगा। अब यह हमेशा है
शाब्दिक रूप से दायरा।

पर्ल v5.16.0 के अनुसार, इसे एरीबेस मॉड्यूल द्वारा कार्यान्वित किया जाता है। अधिक जानकारी के लिए एरीबेस देखें
इसके व्यवहार पर विवरण.

"v5.16 का उपयोग करें" या "कोई सुविधा नहीं" array_base" के अंतर्गत, $[ का अब कोई प्रभाव नहीं है, और
इसमें हमेशा 0 होता है। इसमें 0 निर्दिष्ट करने की अनुमति है, लेकिन कोई अन्य मान होगा
एक त्रुटि उत्पन्न करें.

स्मरणीय: [ सबस्क्रिप्ट प्रारंभ करता है।

पर्ल v5.12.0 में बहिष्कृत।

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