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

कार्यक्रम:

नाम

पर्लडेटा - पर्ल डेटा प्रकार

वर्णन

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

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

पर्ल के अपने स्वयं के अंतर्निहित वैरिएबल भी हैं जिनके नाम इन नियमों का पालन नहीं करते हैं। उनके पास है
अजीब नाम ताकि वे गलती से आपके किसी सामान्य चर से न टकराएँ।
नियमित अभिव्यक्ति के कोष्ठक वाले भागों से मेल खाने वाली स्ट्रिंग्स को नामों के अंतर्गत सहेजा जाता है
जिसमें केवल "$" के बाद के अंक हों (पर्लॉप और पर्लरे देखें)। इसके अलावा, अनेक
विशेष वेरिएबल जो पर्ल की आंतरिक कार्यप्रणाली में विंडो प्रदान करते हैं, उनके नाम हैं
विराम चिह्न और नियंत्रण वर्ण युक्त। इन्हें प्रलेखित किया गया है
perlvar.

अदिश मानों को हमेशा '$' से नामित किया जाता है, भले ही वह उस अदिश का संदर्भ हो जो इसका हिस्सा है
एक सरणी या एक हैश. '$' चिन्ह शब्दार्थ की दृष्टि से अंग्रेजी शब्द "द" की तरह काम करता है
यह इंगित करता है कि एकल मान अपेक्षित है।

$दिन # सरल अदिश मान "दिन"
$days[28] # सरणी @days का 29वाँ तत्व
$days{'Feb'} # हैश %days से 'फरवरी' मान
$#days # सरणी का अंतिम सूचकांक @days

संपूर्ण सरणियों (और सरणियों और हैश के स्लाइस) को '@' द्वारा दर्शाया जाता है, जो काफी हद तक काम करता है
शब्द "ये" या "वे" अंग्रेजी में है, इसमें यह इंगित करता है कि कई मान हैं
उम्मीद थी.

@दिन # ($दिन[0], $दिन[1],... $दिन[n])
@दिन[3,4,5] # ($दिन[3],$दिन[4],$दिन[5]) के समान
@days{'a','c'} # समान ($days{'a'},$days{'c'})

संपूर्ण हैश को '%' द्वारा दर्शाया जाता है:

%दिन # (कुंजी1, वैल1, कुंजी2, वैल2...)

इसके अलावा, सबरूटीन्स को प्रारंभिक '&' के साथ नाम दिया गया है, हालांकि यह वैकल्पिक है
असंदिग्ध, जैसे अंग्रेजी में "डू" शब्द अक्सर अनावश्यक होता है। प्रतीक तालिका प्रविष्टियाँ
प्रारंभिक '*' के साथ नाम दिया जा सकता है, लेकिन अभी तक आपको वास्तव में इसकी परवाह नहीं है (यदि कभी :-)।

प्रत्येक चर प्रकार का अपना नामस्थान होता है, जैसे कई गैर-परिवर्तनीय पहचानकर्ता होते हैं। यह
इसका मतलब है कि आप संघर्ष के डर के बिना, एक अदिश चर के लिए एक ही नाम का उपयोग कर सकते हैं
सरणी, या एक हैश - या, उस मामले के लिए, एक फ़ाइलहैंडल के लिए, एक निर्देशिका हैंडल, एक सबरूटीन
नाम, प्रारूप नाम, या लेबल। इसका मतलब है कि $foo और @foo दो अलग-अलग हैं
चर। इसका मतलब यह भी है कि $foo[1] @foo का हिस्सा है, $foo का हिस्सा नहीं। शायद यह
थोड़ा अजीब लगता है, लेकिन यह ठीक है, क्योंकि यह अजीब है।

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

ऐसे अल्फ़ान्यूमेरिक नाम को उस अभिव्यक्ति से बदलना संभव है जो रिटर्न देता है
उपयुक्त प्रकार का संदर्भ. इसके विवरण के लिए, perlref देखें।

जो नाम एक अंक से शुरू होते हैं उनमें केवल अधिक अंक हो सकते हैं। वे नाम जिनसे शुरू नहीं होते
एक अक्षर, अंडरस्कोर, अंक या कैरेट (यानी एक नियंत्रण वर्ण) एक तक सीमित हैं
चरित्र, उदाहरण के लिए, $% या $$। (इनमें से अधिकांश एक वर्ण के नाम पूर्वनिर्धारित हैं
पर्ल के लिए महत्व. उदाहरण के लिए, $$ वर्तमान प्रक्रिया आईडी है।)

पहचानकर्ता पदच्छेद
पर्ल 5.18 तक, वैध पहचानकर्ता के वास्तविक नियम थोड़े अस्पष्ट थे।
हालाँकि, सामान्य तौर पर, यहाँ परिभाषित कुछ भी पर्ल के पिछले संस्करणों पर काम करना चाहिए
विपरीत - किनारे वाले मामले जो पिछले संस्करणों में काम करते हैं, लेकिन यहां परिभाषित नहीं हैं -
संभवतः नए संस्करणों पर काम नहीं करेगा. एक महत्वपूर्ण अतिरिक्त नोट के रूप में, कृपया ध्यान दें कि
निम्नलिखित केवल नंगे शब्द पहचानकर्ताओं पर लागू होता है जैसा कि पर्ल स्रोत कोड में पाया जाता है, नहीं
पहचानकर्ताओं को प्रतीकात्मक संदर्भों के माध्यम से पेश किया गया, जिन पर बहुत कम प्रतिबंध हैं।
यदि "UTF8 का उपयोग करें;" के प्रभाव में काम कर रहे हैं व्यावहारिक रूप से, निम्नलिखित नियम लागू होते हैं:

/ (?[ ( \p{Word} & \p{XID_Start} ) + [_] ])
(?[ ( \p{शब्द} और \p{XID_जारी रखें} ) ]) * /x

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

यदि "utf8 का उपयोग करें" के अंतर्गत नहीं है, तो स्रोत को ASCII + 128 अतिरिक्त नियंत्रण के रूप में माना जाता है, और
पहचानकर्ताओं का मिलान होना चाहिए

/ (?aa) (?!\d) \w+ /x

अर्थात्, ASCII श्रेणी में कोई भी शब्द वर्ण, जब तक कि पहला वर्ण a न हो
अंक।

पर्ल में दो पैकेज सेपरेटर हैं: एक डबल कोलन ("::") और एक सिंगल कोट ("'")।
सामान्य पहचानकर्ता दोहरे कोलन के साथ शुरू या समाप्त हो सकते हैं, और इसमें कई भाग हो सकते हैं
दोहरे कोलन द्वारा सीमांकित। सिंगल कोट्स में समान नियम होते हैं, लेकिन अपवाद के साथ
वे पहचानकर्ता के अंत में कानूनी नहीं हैं: यानी, "$'foo" और "$foo'bar" कानूनी हैं,
लेकिन "$foo'bar'" नहीं है।

इसके अतिरिक्त, यदि पहचानकर्ता के पहले एक संकेत है - अर्थात, यदि पहचानकर्ता है
एक चर नाम का हिस्सा - इसे वैकल्पिक रूप से ब्रेसिज़ में संलग्न किया जा सकता है।

हालाँकि आप डबल कोलन को सिंगल कोट्स के साथ मिला सकते हैं, लेकिन कोट्स को इसके बाद आना चाहिए
कोलन: "$::::'foo" और "$foo::'bar" वैध हैं, लेकिन "$::'::foo" और "$foo'::bar" नहीं हैं।

एक साथ रखने पर, मूल पहचानकर्ता से मेल खाने वाला व्याकरण बन जाता है

/
(?(परिभाषित करना)
(?
(?&सिगिल)
(?:
(?&सामान्य_पहचानकर्ता)
| \{ \s* (?&सामान्य_पहचानकर्ता) \s* \}
)
)
(?
(?: :: )* '?
(?&basic_identifier)
(?: (?= (?: :: )+ '? | (?: :: )* ' ) (?&सामान्य_पहचानकर्ता) )?
(?:::)*
)
(?
# क्या utf8 का उपयोग चालू है?
(?(?{ (फोन करने वाले(0))[8] और $utf8::hint_bits })
(?&Perl_XIDS) (?&Perl_XIDC)*
| (?aa) (?!\d) \w+
)
)
(? [&*\$\@\%])
(? (?[ ( \p{Word} & \p{XID_Start} ) + [_] ]) )
(? (?[ \p{शब्द} और \p{XID_जारी रखें} ]) )
)
/x

इस बीच, विशेष पहचानकर्ता उपरोक्त नियमों का पालन नहीं करते हैं; अधिकांश भाग के लिए, सभी
इस श्रेणी के पहचानकर्ताओं का पर्ल द्वारा दिया गया एक विशेष अर्थ है। क्योंकि उनके पास है
विशेष पार्सिंग नियम, ये आम तौर पर पूरी तरह से योग्य नहीं हो सकते हैं। वे चार रूपों में आते हैं:

· एक संकेत, जिसके बाद केवल "\p{POSIX_Digit}" से मेल खाने वाले अंक आते हैं, जैसे $0, $1, या $10000।

· एक सिगिल, उसके बाद एक कैरेट और कोई एक अक्षर "[][AZ^_?\]", जैसे $^V या
$^], या एक सिगिल जिसके बाद शाब्दिक गैर-स्पेस, गैर-"एनयूएल" नियंत्रण वर्ण मिलान होता है
"\p{POSIX_Cntrl}" संपत्ति। एक ऐतिहासिक विचित्रता के कारण, यदि "उपयोग" के अंतर्गत नहीं चल रहा है
utf8", "[128x0-80xff]" श्रेणी के 0 वर्णों को नियंत्रण माना जाता है,
और इसका उपयोग लंबाई-एक चर में भी किया जा सकता है। हालाँकि, गैर-ग्राफ़िकल का उपयोग
वर्णों को v5.22 से हटा दिया गया है, और भविष्य में उनके लिए समर्थन हटा दिया जाएगा
पर्ल का संस्करण. ASCII स्पेस कैरेक्टर और "NUL" की पहले से ही अनुमति नहीं है, इसलिए यह
इसका मतलब है कि एक एकल-वर्ण चर नाम, उस नाम के साथ कोई अन्य C0 नियंत्रण है
"[0x01-0x1F]", या "DEL" एक अप्रचलित चेतावनी उत्पन्न करेगा। पहले से ही, "उपयोग" के अंतर्गत
utf8", गैर-ASCII वर्णों को "Perl_XIDS" से मेल खाना चाहिए। v5.22 के अनुसार, जब "उपयोग" के अंतर्गत न हो
utf8" C1 नियंत्रण "[0x80-0x9F]", कोई ब्रेक स्पेस नहीं, और सॉफ्ट हाइफ़न ("शर्मीली")) उत्पन्न करता है
अस्वीकृत चेतावनी.

· उपरोक्त के समान, एक सिगिल, उसके बाद ब्रेसिज़ में नंगे शब्द का पाठ, जहां पहला
चरित्र या तो एक कैरेट है जिसके बाद "[][AZ^_?\]" वर्णों में से कोई एक आता है
"${^GLOBAL_PHASE}", या एक गैर-"NUL", गैर-स्पेस शाब्दिक नियंत्रण जैसे "${\7LOBAL_PHASE}"।
उपरोक्त की तरह, जब "utf8 का उपयोग करें" के अंतर्गत नहीं, तो "[0x80-0xFF]" में वर्ण हैं
नियंत्रण माना जाता है, लेकिन v5.22 के अनुसार, किसी भी गैर-ग्राफ़िकल का उपयोग होता है
बहिष्कृत, और v5.20 के अनुसार किसी भी ASCII-रेंज शाब्दिक नियंत्रण का उपयोग बहिष्कृत है।
पर्ल के भविष्य के संस्करण में इनके लिए समर्थन हटा दिया जाएगा।

· "\p{POSIX_Punct}" प्रॉपर्टी से मेल खाने वाले एकल अक्षर के बाद एक सिगिल, जैसे
$! या "%+", अक्षर "{" को छोड़कर काम नहीं करता है।

ध्यान दें कि पर्ल 5.20 के अनुसार, परिवर्तनीय नामों में शाब्दिक नियंत्रण वर्ण हटा दिए गए हैं;
और पर्ल 5.22 के अनुसार, किसी भी अन्य गैर-ग्राफ़िक वर्ण को भी बहिष्कृत कर दिया गया है।

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

पारस्परिक रूप से, एक ऑपरेशन प्रत्येक को एक अदिश या एक सूची संदर्भ प्रदान करता है
इसके तर्कों का. उदाहरण के लिए, यदि आप कहते हैं

int( )

पूर्णांक ऑपरेशन <> ऑपरेटर के लिए स्केलर संदर्भ प्रदान करता है, जो इसके द्वारा प्रतिक्रिया करता है
एसटीडीआईएन से एक पंक्ति को पढ़ना और इसे पूर्णांक ऑपरेशन में वापस भेजना, जो तब होगा
उस पंक्ति का पूर्णांक मान ज्ञात करें और उसे वापस लौटाएँ। यदि, दूसरी ओर, आप कहते हैं

क्रम से लगाना( )

फिर सॉर्ट ऑपरेशन <> के लिए सूची संदर्भ प्रदान करता है, जो प्रत्येक को पढ़ने के लिए आगे बढ़ेगा
फ़ाइल के अंत तक उपलब्ध पंक्ति, और पंक्तियों की उस सूची को वापस सॉर्ट में पास करें
रूटीन, जो फिर उन पंक्तियों को क्रमबद्ध करेगा और उन्हें जो भी हो, एक सूची के रूप में लौटा देगा
प्रकार का प्रसंग था.

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

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

उपयोगकर्ता-परिभाषित सबरूटीन्स इस बात का ध्यान रख सकते हैं कि क्या उन्हें शून्य में बुलाया जा रहा है,
अदिश, या सूची संदर्भ। हालाँकि, अधिकांश सबरूटीन्स को परेशान होने की आवश्यकता नहीं है। ऐसा है क्योंकि
स्केलर और सूचियाँ दोनों स्वचालित रूप से सूचियों में प्रक्षेपित हो जाते हैं। में "वान्टरे" देखें
आप अपने फ़ंक्शन के कॉलिंग संदर्भ को गतिशील रूप से कैसे समझेंगे, इसके लिए perlfunc।

अदिश मानों
पर्ल में सभी डेटा एक अदिश, अदिशों की एक सरणी, या अदिशों का एक हैश है। एक अदिश राशि हो सकती है
तीन अलग-अलग स्वादों में से किसी एक में एक ही मान शामिल है: एक संख्या, एक स्ट्रिंग, या एक
संदर्भ। सामान्य तौर पर, एक रूप से दूसरे रूप में रूपांतरण पारदर्शी होता है। हालाँकि ए
स्केलर सीधे तौर पर कई मान नहीं रख सकता है, इसमें किसी सरणी या का संदर्भ हो सकता है
हैश जिसमें बदले में कई मान शामिल होते हैं।

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

एक अदिश मान की व्याख्या बूलियन अर्थ में FALSE के रूप में की जाती है यदि यह अपरिभाषित है, तो शून्य है
स्ट्रिंग या संख्या 0 (या इसके स्ट्रिंग समतुल्य, "0"), और यदि यह कुछ और है तो TRUE।
बूलियन संदर्भ केवल एक विशेष प्रकार का अदिश संदर्भ है जहां कोई रूपांतरण नहीं होता है
स्ट्रिंग या संख्या कभी भी निष्पादित की जाती है।

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

यह पता लगाने के लिए कि क्या दी गई स्ट्रिंग एक वैध गैर-शून्य संख्या है, कभी-कभी यह पर्याप्त होता है
संख्यात्मक 0 और शाब्दिक "0" दोनों के विरुद्ध इसका परीक्षण करें (हालाँकि इससे शोर उत्पन्न होगा
चेतावनियाँ चालू हैं)। ऐसा इसलिए है क्योंकि जो स्ट्रिंग संख्याएं नहीं हैं उन्हें 0 के रूप में गिना जाता है, जैसे कि वे करते हैं
in awk:

अगर ($str == 0 && $str ne "0") {
चेतावनी दें "यह एक संख्या की तरह नहीं दिखता";
}

वह विधि सर्वोत्तम हो सकती है क्योंकि अन्यथा आप IEEE नोटेशन को "NaN" या जैसे नहीं मानेंगे
ठीक से "अनंत"। अन्य समय में, आप यह निर्धारित करना पसंद कर सकते हैं कि क्या स्ट्रिंग डेटा
को कॉल करके संख्यात्मक रूप से उपयोग किया जा सकता है POSIX::strtod() कार्य या आपका निरीक्षण करके
नियमित अभिव्यक्ति के साथ स्ट्रिंग (जैसा कि perlre में प्रलेखित है)।

चेतावनी दें "इसमें कोई अंक नहीं हैं" यदि /\D/;
चेतावनी दें "यह एक प्राकृतिक संख्या नहीं है" जब तक कि /^\d+$/; # अस्वीकार -3
चेतावनी दें "पूर्णांक नहीं" जब तक कि /^-?\d+$/; #+3 को अस्वीकार करता है
चेतावनी दें "पूर्णांक नहीं" जब तक कि /^[+-]?\d+$/;
चेतावनी दें "यह दशमलव संख्या नहीं है" जब तक कि /^-?\d+\.?\d*$/; #अस्वीकार .2
चेतावनी दें "दशमलव संख्या नहीं" जब तक कि /^-?(?:\d+(?:\.\d*)?|\.\d+)$/;
चेतावनी दें "सी फ़्लोट नहीं"
जब तक /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;

किसी सरणी की लंबाई एक अदिश मान है। आपको सारणी की लंबाई @days तक मिल सकती है
$#days का मूल्यांकन, जैसे कि csh. हालाँकि, यह सरणी की लंबाई नहीं है; यह है
अंतिम तत्व का सबस्क्रिप्ट, जो एक अलग मान है क्योंकि आमतौर पर 0वां होता है
तत्व। $#days को असाइन करने से वास्तव में सरणी की लंबाई बदल जाती है। ए को छोटा करना
इस तरह से सरणी हस्तक्षेप करने वाले मानों को नष्ट कर देती है। पहले से मौजूद सरणी को लंबा करना
छोटा उन मानों को पुनर्प्राप्त नहीं करता है जो उन तत्वों में थे।

आप किसी सरणी को पूर्व-विस्तारित करके दक्षता का कुछ छोटा माप भी प्राप्त कर सकते हैं
बड़ा होने जा रहा हूँ. आप किसी ऐसे तत्व को असाइन करके किसी सरणी का विस्तार भी कर सकते हैं जो इससे बाहर है
सरणी का अंत. आप शून्य सूची निर्दिष्ट करके किसी सरणी को छोटा करके शून्य कर सकते हैं ()
इसे. निम्नलिखित समतुल्य हैं:

@जो कुछ भी = ();
$#जो कुछ भी = -1;

यदि आप स्केलर संदर्भ में किसी सरणी का मूल्यांकन करते हैं, तो यह सरणी की लंबाई लौटाता है। (टिप्पणी
यह उन सूचियों के लिए सत्य नहीं है, जो अंतिम मान लौटाती हैं, जैसे C अल्पविराम ऑपरेटर,
न ही अंतर्निहित फ़ंक्शंस, जो जो कुछ भी उन्हें लौटने का मन करता है उसे वापस कर देते हैं।) निम्नलिखित
सदैव सत्य है:

अदिश (@जो कुछ भी) == $#जो कुछ भी + 1;

कुछ प्रोग्रामर स्पष्ट रूपांतरण का उपयोग करना चुनते हैं ताकि कोई संदेह न रह जाए:

$element_count = अदिश (@जो कुछ भी);

यदि आप अदिश संदर्भ में हैश का मूल्यांकन करते हैं, तो हैश खाली होने पर यह गलत रिटर्न देता है। अगर वहाँ
यदि कोई कुंजी/मान युग्म है, तो यह सत्य लौटाता है; अधिक सटीक रूप से, लौटाया गया मान एक स्ट्रिंग है
इसमें उपयोग की गई बाल्टियों की संख्या और आवंटित बाल्टियों की संख्या को अलग करके शामिल किया गया है
एक स्लैश. यह केवल यह पता लगाने के लिए काफी उपयोगी है कि पर्ल की आंतरिक हैशिंग है या नहीं
एल्गोरिदम आपके डेटा सेट पर खराब प्रदर्शन कर रहा है। उदाहरण के लिए, आप 10,000 चीज़ें चिपका देते हैं
एक हैश, लेकिन अदिश संदर्भ में %HASH का मूल्यांकन करने से "1/16" का पता चलता है, जिसका अर्थ है इनमें से केवल एक
सोलह बाल्टियाँ छू ली गई हैं, और संभवतः इसमें आपकी सभी 10,000 वस्तुएँ शामिल हैं। यह
ऐसा नहीं होना चाहिए. यदि एक बंधे हुए हैश का मूल्यांकन अदिश संदर्भ में किया जाता है, तो "SCALAR"
विधि को कहा जाता है ("FIRSTKEY" के फ़ॉलबैक के साथ)।

आप को असाइन करके हैश के लिए स्थान पूर्व-आवंटित कर सकते हैं चांबियाँ() समारोह। यह गोल हो जाता है
दो की अगली शक्ति के लिए आवंटित बाल्टियाँ:

कुंजियाँ(%उपयोगकर्ता) = 1000; # 1024 बाल्टी आवंटित करें

अदिश मूल्य कंस्ट्रक्टर्स
संख्यात्मक अक्षर निम्नलिखित फ़्लोटिंग पॉइंट या पूर्णांक प्रारूपों में से किसी में निर्दिष्ट हैं:

12345
12345.67
.23ई-10# बहुत छोटी संख्या
3.14_15_92# एक बहुत ही महत्वपूर्ण संख्या
4_294_967_296 # सुपाठ्यता के लिए अंडरस्कोर
0xff # हेक्स
0xdead_beef # अधिक हेक्स
0377 # अष्टक (केवल संख्याएँ, 0 से शुरू होती हैं)
0b011011 # बाइनरी
0x1.999ap-4 # हेक्साडेसिमल फ़्लोटिंग पॉइंट ('पी' आवश्यक है)

आपको अंकों के बीच संख्यात्मक शाब्दिक में अंडरस्कोर (अंडरबार्स) का उपयोग करने की अनुमति है
सुपाठ्यता (लेकिन एक पंक्ति में एकाधिक अंडरस्कोर नहीं: "23__500" कानूनी नहीं है; "23_500" है)।
उदाहरण के लिए, आप बाइनरी अंकों को तीन के आधार पर समूहित कर सकते हैं (यूनिक्स-शैली मोड तर्क के लिए)।
जैसे कि 0b110_100_100) या चार द्वारा (निबल्स को दर्शाने के लिए, जैसे कि 0b1010_0110 में) या अन्य में
समूहों.

स्ट्रिंग अक्षर आमतौर पर एकल या दोहरे उद्धरण चिह्नों द्वारा सीमांकित होते हैं। वे बहुत काम करते हैं
मानक यूनिक्स शेल्स में उद्धरण चिह्नों की तरह: दोहरे-उद्धृत स्ट्रिंग अक्षर इसके अधीन हैं
बैकस्लैश और परिवर्तनीय प्रतिस्थापन; एकल-उद्धृत स्ट्रिंग नहीं हैं ("\'" को छोड़कर और
"\\"). सामान्य सी-शैली बैकस्लैश नियम न्यूलाइन जैसे अक्षर बनाने के लिए लागू होते हैं,
टैब, आदि, साथ ही कुछ और विदेशी रूप। "उद्धरण और उद्धरण-समान संचालक" देखें
एक सूची के लिए perlop.

हेक्साडेसिमल, ऑक्टल, या बाइनरी, स्ट्रिंग अक्षर में प्रतिनिधित्व (उदाहरण के लिए '0xff') नहीं हैं
स्वचालित रूप से उनके पूर्णांक प्रतिनिधित्व में परिवर्तित हो जाता है। हेक्स () और अक्टूबर () कार्यों
ये रूपांतरण आपके लिए करें. अधिक जानकारी के लिए perlfunc में "हेक्स" और perlfunc में "oct" देखें
विवरण।

हेक्साडेसिमल फ़्लोटिंग पॉइंट हेक्साडेसिमल शाब्दिक की तरह शुरू हो सकता है, और यह हो सकता है
इसके बाद एक वैकल्पिक भिन्नात्मक हेक्साडेसिमल भाग होगा, लेकिन इसके बाद "पी", ए होना चाहिए
वैकल्पिक चिह्न, और दो की घात। यह प्रारूप सटीक प्रस्तुतिकरण के लिए उपयोगी है
फ़्लोटिंग पॉइंट मान, दशमलव फ़्लोटिंग पॉइंट पर या उससे रूपांतरण से बचना, और
इसलिए परिशुद्धता में संभावित हानि से बचा जा सकता है। ध्यान दें कि अधिकांश मौजूदा प्लेटफ़ॉर्म
64-बिट IEEE 754 फ़्लोटिंग पॉइंट का उपयोग करें, सभी ऐसा नहीं करते। (कम-) का एक अन्य संभावित स्रोत
ऑर्डर) अंतर फ़्लोटिंग पॉइंट राउंडिंग मोड हैं, जो सीपीयू के बीच भिन्न हो सकते हैं,
ऑपरेटिंग सिस्टम, और कंपाइलर, और जिसे पर्ल नियंत्रित नहीं करता है।

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

$कीमत = '$100'; # प्रक्षेपित नहीं
प्रिंट करें "कीमत $Price है.\n"; #प्रक्षेपित

पर्ल में कोई दोहरा प्रक्षेप नहीं है, इसलिए $100 को वैसे ही छोड़ दिया जाता है।

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

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

$कौन = "लैरी";
प्रिंट PASSWD "${who}::0:0:Superuser:/:/bin/perl\n";
प्रिंट करें "हम ${who}बोलने का उपयोग तब करते हैं जब ${who} यहां होता है।\n";

ब्रेसिज़ के बिना, पर्ल ने एक $whospeak, एक $who::0, और एक "$who's" की तलाश की होती
चर। अंतिम दो (संभवतः) गैर में $0 और $s चर होंगे-
मौजूदा पैकेज "कौन"।

वास्तव में, ऐसे कर्लीज़ के भीतर एक साधारण पहचानकर्ता को एक स्ट्रिंग बनने के लिए मजबूर किया जाता है, और इसी तरह
एक हैश सबस्क्रिप्ट के भीतर। न ही उद्धृत करने की आवश्यकता है. हमारा पिछला उदाहरण, $days{'Feb'} हो सकता है
$days{Feb} के रूप में लिखा जाएगा और उद्धरण स्वचालित रूप से मान लिए जाएंगे। लेकिन और कुछ भी
सबस्क्रिप्ट में जटिल को अभिव्यक्ति के रूप में समझा जाएगा। उदाहरण के लिए इसका मतलब है
वह "$version{2.0}++" "$version{2}++" के बराबर है, न कि "$version{'2.0'}++" के।

विशिष्ट चल बिंदु: अनन्तता (जानकारी) और नहीं एक संख्या (NaN)

फ़्लोटिंग पॉइंट मानों में अनंत और नॉट-ए- के लिए विशेष मान "Inf" और "NaN" शामिल हैं।
संख्या। अनन्तता ऋणात्मक भी हो सकती है।

अनन्तता कुछ गणित परिचालनों का परिणाम है जो फ़्लोटिंग पॉइंट को ओवरफ़्लो करती है
रेंज, जैसे 9**9**9। जब परिणाम अपरिभाषित होता है तो नॉट-ए-नंबर परिणाम होता है
अप्रस्तुत. हालाँकि ध्यान दें कि आप कुछ सामान्य "अपरिभाषित" या से "NaN" प्राप्त नहीं कर सकते हैं
"सीमा से बाहर" ऑपरेशन जैसे शून्य से विभाजित करना, या किसी ऋणात्मक संख्या का वर्गमूल,
चूँकि पर्ल उनके लिए घातक त्रुटियाँ उत्पन्न करता है।

अनंत और गैर-संख्या के अपने विशेष अंकगणितीय नियम हैं। सामान्य नियम
क्या वे "संक्रामक" हैं: "इन्फ" प्लस वन "इन्फ" है, और "NaN" प्लस वन "NaN" है।
चीजें दिलचस्प तब होती हैं जब आप अनंत और गैर-संख्याओं को जोड़ते हैं: "इन्फ" माइनस
"Inf" और "Inf" को "INf" से विभाजित करने पर "NaN" प्राप्त होता है (जबकि "Inf" और "Inf" का योग "Inf" और "Inf" होता है)
कई बार "इन्फ" का मतलब "इन्फ" होता है)। "NaN" इस मायने में भी दिलचस्प है कि यह किसी भी संख्या के बराबर नहीं है,
समेत स्वयं: "NaN" != "NaN"।

पर्ल "Inf" और "NaN" को संख्यात्मक शाब्दिक के रूप में नहीं समझता है, लेकिन आप उन्हें इस रूप में ले सकते हैं
स्ट्रिंग्स, और पर्ल उन्हें आवश्यकतानुसार रूपांतरित करेगा: "इन्फ" + 1. (हालाँकि, आप उन्हें आयात कर सकते हैं
POSIX एक्सटेंशन से; "POSIX qw(Inf NaN) का उपयोग करें);" और फिर उन्हें शाब्दिक रूप में उपयोग करें।)

ध्यान दें कि इनपुट (स्ट्रिंग टू नंबर) पर पर्ल कई रूपों में "Inf" और "NaN" स्वीकार करता है। मामला
नजरअंदाज कर दिया जाता है, और Win32-विशिष्ट फॉर्म जैसे "1.#INF" को समझा जाता है, लेकिन आउटपुट पर
मानों को "Inf" और "NaN" के लिए सामान्यीकृत किया जाता है।

संस्करण स्ट्रिंग्स

"v1.20.300.4000" फ़ॉर्म का शाब्दिक रूप से वर्णों से बनी एक स्ट्रिंग के रूप में पार्स किया गया है
निर्दिष्ट अध्यादेश. यह फॉर्म, जिसे वी-स्ट्रिंग्स के नाम से जाना जाता है, एक और विकल्प प्रदान करता है
कुछ हद तक कम पठनीय का उपयोग करने के बजाय, स्ट्रिंग बनाने का पठनीय तरीका
प्रक्षेप प्रपत्र "\x{1}\x{14}\x{12c}\x{fa0}"। यह यूनिकोड का प्रतिनिधित्व करने के लिए उपयोगी है
स्ट्रिंग्स, और स्ट्रिंग तुलना ऑपरेटरों, "सीएमपी" का उपयोग करके संस्करण "संख्याओं" की तुलना करने के लिए,
"जीटी", "एलटी" आदि। यदि शाब्दिक रूप से दो या दो से अधिक बिंदु हैं, तो अग्रणी "वी" हो सकता है
छोड़ा गया

प्रिंट v9786; # स्माइली प्रिंट करता है, "\x{263a}"
प्रिंट v102.111.111; # "फू" प्रिंट करता है
प्रिंट 102.111.111; # वही

ऐसे शाब्दिक संस्करण की जाँच करने के लिए "आवश्यकता" और "उपयोग" दोनों द्वारा स्वीकार किए जाते हैं। टिप्पणी
IPv4 पतों के लिए वी-स्ट्रिंग्स का उपयोग तब तक पोर्टेबल नहीं है जब तक कि आप इसका भी उपयोग नहीं करते
inet_aton()/inet_ntoa() सॉकेट पैकेज की दिनचर्या।

ध्यान दें कि पर्ल 5.8.1 के बाद से एकल-संख्या वी-स्ट्रिंग्स (जैसे "v65") वी-स्ट्रिंग्स नहीं हैं
"=>" ऑपरेटर से पहले (जिसका उपयोग आमतौर पर हैश कुंजी को हैश मान से अलग करने के लिए किया जाता है);
इसके बजाय उनकी व्याख्या शाब्दिक स्ट्रिंग्स ('v65') के रूप में की जाती है। वे पर्ल से वी-स्ट्रिंग्स थे
5.6.0 से पर्ल 5.8.0, लेकिन इससे फायदे की बजाय अधिक भ्रम और टूट-फूट हुई। बहुसंख्या
"v65.66" और 65.66.67 जैसे वी-स्ट्रिंग्स हमेशा वी-स्ट्रिंग्स बने रहते हैं।

विशिष्ट साहित्य

विशेष अक्षर __FILE__, __LINE__, और __PACKAGE__ वर्तमान फ़ाइल नाम का प्रतिनिधित्व करते हैं,
आपके प्रोग्राम में उस बिंदु पर लाइन नंबर और पैकेज का नाम। __SUB__ का संदर्भ देता है
वर्तमान सबरूटीन. उनका उपयोग केवल अलग टोकन के रूप में किया जा सकता है; वे नहीं होंगे
तारों में प्रक्षेपित। यदि कोई वर्तमान पैकेज नहीं है (खाली "पैकेज" के कारण;)
निर्देश), __PACKAGE__ अपरिभाषित मान है। (लेकिन खाली "पैकेज" अब नहीं है
संस्करण 5.10 के अनुसार समर्थित।) सबरूटीन के बाहर, __SUB__ अपरिभाषित मान है।
__SUB__ केवल 5.16 या उच्चतर में उपलब्ध है, और केवल "v5.16 का उपयोग करें" या "उपयोग सुविधा" के साथ
"current_sub"" घोषणा।

दो नियंत्रण वर्ण ^D और ^Z, और टोकन __END__ और __DATA__ का उपयोग किया जा सकता है
फ़ाइल के वास्तविक अंत से पहले स्क्रिप्ट के तार्किक अंत को इंगित करें। कोई भी निम्नलिखित पाठ
नजरअंदाज कर दिया है।

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

__DATA__ के अधिक विवरण और इसके उपयोग के उदाहरण के लिए सेल्फलोडर देखें। ध्यान दें कि आप
BEGIN ब्लॉक में DATA फ़ाइलहैंडल से नहीं पढ़ा जा सकता: BEGIN ब्लॉक जल्द ही निष्पादित हो जाता है
जैसा कि (संकलन के दौरान) देखा जाता है, किस बिंदु पर संबंधित __DATA__ (या __END__)
टोकन अभी तक नहीं देखा गया है.

नंगे शब्द

जिस शब्द की व्याकरण में कोई अन्य व्याख्या नहीं है, उसके साथ ऐसा व्यवहार किया जाएगा मानो वह कोई शब्द हो
उद्धृत स्ट्रिंग. इन्हें "नंगे शब्द" के रूप में जाना जाता है। फ़ाइल हैंडल और लेबल की तरह, a
नंगे शब्द जिसमें पूरी तरह से छोटे अक्षर होते हैं, भविष्य में आरक्षित के साथ टकराव का जोखिम उठाते हैं
शब्द, और यदि आप "चेतावनियों का उपयोग करें" प्राग्मा या का उपयोग करते हैं -w स्विच करें, पर्ल आपको इसके बारे में चेतावनी देगा
ऐसे कोई भी शब्द. पर्ल नंगे शब्दों (पहचानकर्ताओं की तरह) को लगभग 250 वर्णों तक सीमित करता है। भविष्य
पर्ल के संस्करणों से इन मनमानी सीमाओं को ख़त्म करने की संभावना है।

हो सकता है कि कुछ लोग अनाप-शनाप शब्दों को पूरी तरह से गैरकानूनी घोषित करना चाहें। अगर आप कहते हैं

सख्त 'उप' का प्रयोग करें;

फिर कोई भी शब्द जिसकी व्याख्या सबरूटीन कॉल के रूप में नहीं की जाएगी, एक संकलन तैयार करता है-
इसके बजाय समय त्रुटि. प्रतिबंध संलग्न ब्लॉक के अंत तक रहता है। एक भीतरी
ब्लॉक "कोई सख्त 'सदस्य' नहीं" कहकर इसका प्रतिवाद कर सकता है।

ऐरे प्रक्षेप

तत्वों को जोड़कर ऐरे और स्लाइस को डबल-उद्धृत स्ट्रिंग में प्रक्षेपित किया जाता है
$" वेरिएबल में निर्दिष्ट सीमांकक ($LIST_SEPARATOR यदि "अंग्रेजी का उपयोग करें;" है
निर्दिष्ट), डिफ़ॉल्ट रूप से स्थान। निम्नलिखित समतुल्य हैं:

$temp = जुड़ें($", @ARGV);
सिस्टम "इको $टेम्प";

सिस्टम "इको @ARGV";

खोज पैटर्न के भीतर (जिसमें डबल-कोटिश प्रतिस्थापन भी होता है) एक है
दुर्भाग्यपूर्ण अस्पष्टता: क्या "/$foo[bar]/" की व्याख्या "/${foo}[bar]/" के रूप में की जाएगी (जहाँ
"[बार]" रेगुलर एक्सप्रेशन के लिए एक वर्ण वर्ग है) या "/${foo[bar]}/" के रूप में (जहां
"[बार]" सरणी @foo की सबस्क्रिप्ट है)? यदि @foo अन्यथा अस्तित्व में नहीं है, तो यह है
जाहिर तौर पर एक चरित्र वर्ग। यदि @foo मौजूद है, तो पर्ल "[बार]" के बारे में अच्छा अनुमान लगाता है, और
लगभग हमेशा सही होता है. यदि इसका अनुमान गलत है, या यदि आप सीधे तौर पर व्याकुल हैं, तो आप ऐसा कर सकते हैं
ऊपर बताए अनुसार घुंघराले ब्रेसिज़ के साथ सही व्याख्या को बल दें।

यदि आप यहां दस्तावेज़ों का उपयोग करने के तरीके के बारे में जानकारी ढूंढ रहे हैं, जो पहले यहां हुआ करते थे,
इसे पर्लोप में "कोट और कोट-लाइक ऑपरेटर्स" में स्थानांतरित कर दिया गया है।

सूची मूल्य कंस्ट्रक्टर्स
सूची मानों को अलग-अलग मानों को अल्पविराम से अलग करके (और सूची को संलग्न करके) दर्शाया जाता है
कोष्ठक में जहां पूर्वता की आवश्यकता है):

(सूची)

किसी संदर्भ में सूची मान की आवश्यकता नहीं होती है, जो सूची शाब्दिक प्रतीत होती है उसका मान होता है
बस अंतिम तत्व का मान, जैसा कि C अल्पविराम ऑपरेटर के साथ होता है। उदाहरण के लिए,

@फू = ('सीसी', '-ई', $बार);

संपूर्ण सूची मान को सरणी @foo पर निर्दिष्ट करता है, लेकिन

$foo = ('cc', '-E', $bar);

स्केलर वेरिएबल $foo को वेरिएबल $bar का मान निर्दिष्ट करता है। ध्यान दें कि a का मान
अदिश संदर्भ में वास्तविक सरणी सरणी की लंबाई है; निम्नलिखित मान निर्दिष्ट करता है
3 से $foo:

@फू = ('सीसी', '-ई', $बार);
$फू = @फू; # $foo को 3 मिलते हैं

आपके पास किसी सूची के शाब्दिक समापन कोष्ठक से पहले एक वैकल्पिक अल्पविराम हो सकता है, ताकि
आप कह सकते हैं:

@फू = (
1,
2,
3,
);

किसी सरणी, प्रति तत्व एक पंक्ति निर्दिष्ट करने के लिए यहां-दस्तावेज़ का उपयोग करने के लिए, आप एक दृष्टिकोण का उपयोग कर सकते हैं
इस तरह:

@सॉस = <
सामान्य टमाटर
मसालेदार टमाटर
हरी मिर्च
pesto
व्हाइट वाइन
अंत_पंक्तियाँ

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

(@foo,@bar,&SomeSub,%glarch)

इसमें @foo के सभी तत्व, उसके बाद @bar के सभी तत्व, उसके बाद सभी शामिल हैं
SomSub नाम के सबरूटीन द्वारा लौटाए गए तत्वों को सूची संदर्भ में बुलाया गया, उसके बाद
%ग्लार्च की कुंजी/मूल्य जोड़े। एक सूची संदर्भ बनाने के लिए जो करता है नहीं प्रक्षेप करना, देखना
perlref.

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

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

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

# स्टेट सूची मूल्य लौटाता है।
$समय = (स्टेट($फ़ाइल))[8];

#यहां सिंटैक्स त्रुटि.
$समय = स्टेट($फ़ाइल)[8]; #उफ़, कोष्ठक भूल गए

# एक षट्कोणीय अंक खोजें.
$हेक्सडिजिट = ('ए','बी','सी','डी','ई','एफ')[$डिजिट-10];

# एक "रिवर्स कॉमा ऑपरेटर"।
वापसी (पॉप (@foo), पॉप (@foo))[0];

सूचियाँ केवल तभी सौंपी जा सकती हैं जब सूची के प्रत्येक तत्व को सौंपा जाना स्वयं कानूनी हो:

($ए, $बी, $सी) = (1, 2, 3);

($मानचित्र{'लाल'}, $मानचित्र{'नीला'}, $मानचित्र{'हरा'}) = (0x00f, 0x0f0, 0xf00);

इसका एक अपवाद यह है कि आप किसी सूची में "अनडिफ़" असाइन कर सकते हैं। ये इसके लिए उपयोगी है
किसी फ़ंक्शन के कुछ रिटर्न मानों को फेंकना:

($देव, $इनो, undef, undef, $uid, $gid) = stat($file);

पर्ल 5.22 के अनुसार, आप "अनडेफ़, अनडेफ़" के बजाय "(अनडेफ़)x2" का भी उपयोग कर सकते हैं। (आप भी कर सकते हैं
"($x) x 2", जो कम उपयोगी है, क्योंकि यह एक ही वेरिएबल को दो बार असाइन करता है,
असाइन किए गए पहले मान को क्लॉब करना।)

स्केलर संदर्भ में सूची असाइनमेंट द्वारा उत्पादित तत्वों की संख्या लौटाता है
असाइनमेंट के दाईं ओर अभिव्यक्ति:

$x = (($foo,$bar) = (3,2,1)); # $x को 3 पर सेट करें, 2 पर नहीं
$x = (($foo,$bar) = f()); # $x को f() की रिटर्न संख्या पर सेट करें

यह तब उपयोगी होता है जब आप बूलियन संदर्भ में सूची असाइनमेंट करना चाहते हैं, क्योंकि अधिकांश
सूची फ़ंक्शन समाप्त होने पर एक शून्य सूची लौटाता है, जिसे असाइन करने पर 0 उत्पन्न होता है
गलत के रूप में व्याख्या की गई है।

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

$गिनती = () = $स्ट्रिंग =~ /\d+/g;

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

$गिनती = $स्ट्रिंग =~ /\d+/g;

काम नहीं किया होगा, क्योंकि अदिश संदर्भ में एक पैटर्न मिलान केवल सत्य या लौटाएगा
मिलानों की गिनती के बजाय गलत।

सूची असाइनमेंट का अंतिम तत्व एक सरणी या हैश हो सकता है:

($a, $b, @rest) = विभाजन;
मेरा($ए, $बी, %बाकी) = @_;

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

एक हैश को शाब्दिक सूची का उपयोग करके प्रारंभ किया जा सकता है जिसमें व्याख्या की जाने वाली वस्तुओं के जोड़े शामिल हैं
एक कुंजी और एक मान:

# उपरोक्त मानचित्र असाइनमेंट के समान
%map = ('red',0x00f,'blue',0x0f0,'green',0xf00);

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

कुंजी/मान जोड़े के बीच "=>" ऑपरेटर का उपयोग करना अक्सर अधिक पठनीय होता है। "=>"
ऑपरेटर ज्यादातर अल्पविराम के लिए एक अधिक दृष्टिगत रूप से विशिष्ट पर्यायवाची है, लेकिन यह भी
यदि यह एक नंगे शब्द है तो इसके बाएं हाथ के ऑपरेंड को एक स्ट्रिंग के रूप में व्याख्या करने की व्यवस्था करता है
एक कानूनी सरल पहचानकर्ता होगा. "=>" यौगिक पहचानकर्ताओं को उद्धृत नहीं करता है, जिसमें शामिल है
दोहरा कोलन. यह हैश प्रारंभ करने के लिए इसे अच्छा बनाता है:

%मानचित्र = (
लाल => 0x00f,
नीला => 0x0f0,
हरा => 0xf00,
);

या रिकॉर्ड के रूप में उपयोग किए जाने वाले हैश संदर्भों को प्रारंभ करने के लिए:

$rec = {
डायन => 'मेबल द मर्सीलेस',
बिल्ली => 'शराबी क्रूर',
दिनांक => '10/31/1776',
};

या जटिल कार्यों के लिए कॉल-बाय-नेम-पैरामीटर का उपयोग करने के लिए:

$फ़ील्ड = $क्वेरी->रेडियो_ग्रुप(
नाम => 'समूह_नाम',
मान => ['ईनी', 'मीनी', 'मिनी'],
डिफ़ॉल्ट => 'मीनी',
लाइनब्रेक => 'सही',
लेबल => \% लेबल
);

ध्यान दें कि सिर्फ इसलिए कि एक हैश को उस क्रम में आरंभ किया गया है इसका मतलब यह नहीं है कि वह बाहर आ गया है
उस क्रम में। आउटपुट की व्यवस्था कैसे करें, इसके उदाहरणों के लिए perlfunc में "सॉर्ट" देखें
आदेश।

यदि कोई कुंजी हैश की इनिशियलाइज़र सूची में एक से अधिक बार दिखाई देती है, तो अंतिम घटना
जीतता है:

%वृत्त = (
केंद्र => [5],
केंद्र => [27],
त्रिज्या => 100,
रंग => [0xDF, 0xFF, 0x00],
त्रिज्या => 54,
);

# के समान
%वृत्त = (
केंद्र => [27],
रंग => [0xDF, 0xFF, 0x00],
त्रिज्या => 54,
);

इसका उपयोग ओवररिडेबल कॉन्फ़िगरेशन डिफ़ॉल्ट प्रदान करने के लिए किया जा सकता है:

%args में # मान %config_defaults पर प्राथमिकता लेते हैं
%config = (%config_defaults, %args);

सबस्क्रिप्ट
एक सरणी को एक डॉलर चिह्न ("$") निर्दिष्ट करके एक समय में एक स्केलर तक पहुँचा जा सकता है, फिर
सरणी का नाम (अग्रणी "@" के बिना), फिर वर्गाकार कोष्ठक के अंदर सबस्क्रिप्ट।
उदाहरण के लिए:

@मायर्रे = (5, 50, 500, 5000);
प्रिंट करें "तीसरा तत्व है", $myarray[2], "\n";

सरणी सूचकांक 0 से शुरू होते हैं। एक नकारात्मक सबस्क्रिप्ट अंत से अपना मान पुनः प्राप्त करता है।
हमारे उदाहरण में, $myarray[-1] 5000 होता, और $myarray[-2] 500 होता।

हैश सबस्क्रिप्ट समान हैं, केवल वर्गाकार कोष्ठक के स्थान पर घुंघराले कोष्ठक का उपयोग किया जाता है। के लिए
उदाहरण:

% वैज्ञानिक =
(
"न्यूटन" => "आइज़ैक",
"आइंस्टीन" => "अल्बर्ट",
"डार्विन" => "चार्ल्स",
"फेनमैन" => "रिचर्ड",
);

प्रिंट करें "डार्विन का पहला नाम है", $वैज्ञानिकों{"डार्विन"}, "\n";

आप किसी सूची से एक तत्व प्राप्त करने के लिए उसे सबस्क्रिप्ट भी कर सकते हैं:

$dir = (getpwnam("डेमन"))[7];

बहुआयामी सरणी अनुकरण
किसी सूची के साथ हैश को सबस्क्रिप्ट करके बहुआयामी सरणियों का अनुकरण किया जा सकता है। अवयव
सूची के सभी भाग सबस्क्रिप्ट विभाजक के साथ जुड़े हुए हैं (पर्लवर में "$;" देखें)।

$foo{$a,$b,$c}

के बराबर है

$foo{join($;, $a, $b, $c)}

डिफ़ॉल्ट सबस्क्रिप्ट विभाजक "\034" है, जो SUBSEP के समान है awk.

स्लाइस
एक स्लाइस एक सूची, एक सरणी, या एक हैश के कई तत्वों तक एक साथ पहुँचता है
सबस्क्रिप्ट की सूची. यह अलग-अलग तत्वों को एक के रूप में लिखने से अधिक सुविधाजनक है
अलग-अलग अदिश मानों की सूची।

($उसे, $उसे) = @लोग[0,-1]; # सरणी टुकड़ा
@उन्हें = @लोग[0 ..3]; # सरणी टुकड़ा
($कौन, $घर) = @ENV{"उपयोगकर्ता", "घर"}; # हैश स्लाइस
($uid, $dir) = (getpwnam("डेमन"))[2,7]; # सूची टुकड़ा

चूँकि आप वेरिएबल्स की सूची को असाइन कर सकते हैं, आप किसी ऐरे या हैश को भी असाइन कर सकते हैं
टुकड़ा।

@दिन[3..5] = qw/बुध गुरु शुक्र/;
@रंग{'लाल','नीला','हरा'}
= (0xff0000, 0x0000ff, 0x00ff00);
@लोग[0, -1] = @लोग[-1, 0];

पिछले असाइनमेंट बिल्कुल समकक्ष हैं

($दिन[3], $दिन[4], $दिन[5]) = qw/बुध गुरु शुक्र/;
($रंग{'लाल'}, $रंग{'नीला'}, $रंग{'हरा'})
= (0xff0000, 0x0000ff, 0x00ff00);
($लोग[0], $लोग[-1]) = ($लोग[-1], $लोग[0]);

चूँकि एक स्लाइस बदलने से मूल सरणी या हैश बदल जाता है जिसे वह स्लाइस कर रहा है, एक "foreach"
निर्माण सरणी या हैश के कुछ--या यहां तक ​​कि सभी--मानों को बदल देगा।

foreach (@array[4 ..10 ]) { s/पीटर/पॉल/ }

foreach (@hash{qw[key1 key2]}) {
s/^\s+//; # प्रमुख रिक्त स्थान को ट्रिम करें
s/\s+$//; # अनुगामी रिक्त स्थान को ट्रिम करें
s/(\w+)/\u\L$1/g; # "टाइटलकेस" शब्द
}

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

@ए = ()[0,1]; # @a में कोई तत्व नहीं है
@बी = (@ए)[0,1]; # @b में कोई तत्व नहीं है
@सी = (उप{}->())[0,1]; # @c में कोई तत्व नहीं है
@डी = ('ए','बी')[0,1]; # @d में दो तत्व हैं
@e = (@d)[0,1,8,9]; # @ई के चार तत्व हैं
@f = (@d)[8,9]; # @f के दो तत्व हैं

इससे लूप लिखना आसान हो जाता है जो शून्य सूची वापस आने पर समाप्त हो जाते हैं:

जबकि ($ होम, $ उपयोगकर्ता) = (getpwent) [7,0] ) {
प्रिंटफ "%-8s %s\n", $user, $home;
}

जैसा कि इस दस्तावेज़ में पहले उल्लेख किया गया है, सूची असाइनमेंट का अदिश भाव की संख्या है
असाइनमेंट के दाईं ओर के तत्व। शून्य सूची में कोई तत्व नहीं है, इसलिए
जब पासवर्ड फ़ाइल समाप्त हो जाती है, तो परिणाम 0 होता है, 2 नहीं।

स्केलर संदर्भ में स्लाइस, स्लाइस का अंतिम आइटम लौटाते हैं।

@a = qw/पहला दूसरा तीसरा/;
%h = (पहला => 'ए', दूसरा => 'बी');
$t = @a[0, 1]; # $t अब 'दूसरा' है
$u = @h{'पहला', 'दूसरा'}; # $u अब 'B' है

यदि आप इस बात को लेकर असमंजस में हैं कि आप हैश स्लाइस पर '%' के बजाय '@' का उपयोग क्यों करते हैं, तो सोचें
इसका इस तरह. ब्रैकेट का प्रकार (वर्ग या घुंघराले) यह नियंत्रित करता है कि यह एक सरणी है या नहीं
हैश को देखा जा रहा है। दूसरी ओर, सरणी पर अग्रणी प्रतीक ('$' या '@') या
हैश इंगित करता है कि क्या आप एकवचन मान (एक अदिश) या बहुवचन मान वापस पा रहे हैं (ए)।
सूची)।

मौलिक मूल्य हैश स्लाइस

पर्ल 5.20 से शुरू होकर, % प्रतीक के साथ एक हैश स्लाइस ऑपरेशन स्लाइस का एक प्रकार है
ऑपरेशन केवल मानों के बजाय कुंजी/मूल्य जोड़े की सूची लौटा रहा है:

%h = (ब्लांक => 2, फू => 3, स्क्विंक => 5, बार => 8);
%subset = %h{'foo', 'bar'}; # कुंजी/मान हैश स्लाइस
# %उपसमुच्चय अब है (foo => 3, bar => 8)

हालाँकि, ऐसे स्लाइस के परिणाम को स्थानीयकृत, हटाया या असाइनमेंट में उपयोग नहीं किया जा सकता है।
ये अन्यथा @ प्रतीक का उपयोग करने वाले हैश स्लाइस के साथ बहुत सुसंगत हैं।

सूचकांक/मूल्य ऐरे स्लाइस

कुंजी/मूल्य हैश स्लाइस के समान (और पर्ल 5.20 में भी पेश किया गया), % सरणी स्लाइस
सिंटैक्स सूचकांक/मूल्य जोड़े की एक सूची लौटाता है:

@ए = "ए"। "जेड";
@सूची = %a[3,4,6];
# @सूची अब है (3, "डी", 4, "ई", 6, "जी")

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

आधुनिक पर्ल में टाइपग्लोब का मुख्य उपयोग प्रतीक तालिका उपनाम बनाना है। यह असाइनमेंट:

*यह = *वह;

$this को $that के लिए उपनाम बनाता है, @this को @that के लिए उपनाम बनाता है, %this को %that के लिए उपनाम बनाता है, &this
&that, आदि के लिए एक उपनाम। किसी संदर्भ का उपयोग करना अधिक सुरक्षित है। यह:

स्थानीय *यहां::नीला = \$वहां::हरा;

अस्थायी रूप से $Here::blue को $When::green के लिए उपनाम बनाता है, लेकिन @Here::blue को उपनाम नहीं बनाता है
@वहां::हरा के लिए उपनाम, या %यहां::नीला, %वहां::हरा आदि के लिए उपनाम। "प्रतीक" देखें
इसके अधिक उदाहरणों के लिए perlmod में टेबल्स"। हालांकि यह अजीब लग सकता है, यह है
संपूर्ण मॉड्यूल आयात/निर्यात प्रणाली के लिए आधार।

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

$fh = *STDOUT;

या शायद वास्तविक संदर्भ के रूप में, इस तरह:

$fh = \*STDOUT;

फ़ंक्शंस में अप्रत्यक्ष फ़ाइल हैंडल के रूप में इनका उपयोग करने के उदाहरणों के लिए पर्लसब देखें।

टाइपग्लोब्स का उपयोग करके स्थानीय फ़ाइलहैंडल बनाने का एक तरीका भी है स्थानीय () ऑपरेटर। इन
तब तक रहेगा जब तक उनका ब्लॉक बाहर नहीं निकल जाता, लेकिन वापस भेजा जा सकता है। उदाहरण के लिए:

उप नया खुला {
मेरा $पथ = बदलाव;
स्थानीय *एफएच; # मेरा नहीं!
खुला (एफएच, $ पथ) या अपरिभाषित लौटें;
वापसी *एफएच;
}
$fh = newopen('/ Etc / पासवर्ड');

अब जबकि हमारे पास *foo{THING} नोटेशन है, फ़ाइलहैंडल के लिए टाइपग्लोब का उतना उपयोग नहीं किया जाता है
हेरफेर, हालाँकि बिल्कुल नई फ़ाइल और निर्देशिका हैंडल को पास करने के लिए उनकी अभी भी आवश्यकता है
कार्यों में या बाहर। ऐसा इसलिए है क्योंकि *HANDLE{IO} केवल तभी काम करता है जब HANDLE पहले से मौजूद हो
एक हैंडल के रूप में उपयोग किया गया है। दूसरे शब्दों में, नई प्रतीक तालिका बनाने के लिए *FH का उपयोग किया जाना चाहिए
प्रविष्टियाँ; *foo{THING} नहीं कर सकता। जब संदेह हो, तो *FH का उपयोग करें।

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

उप myopen {
मेरा $fh खोलें, "@_"
या मरें "'@_' नहीं खोल सकते: $!";
वापसी $fh;
}

{
मेरा $f = myopen("
प्रिंट <$f>;
# $f यहां परोक्ष रूप से बंद है
}

ध्यान दें कि यदि इसके बजाय प्रारंभिक स्केलर वैरिएबल का उपयोग किया जाता है तो परिणाम अलग होता है: "my
$fh='zzz'; open($fh, ...)" "open( *{'zzz'}, ...)" के बराबर है। "सख्त 'रेफ्स' का उपयोग करें"
ऐसी प्रथा पर रोक लगाता है।

अनाम फ़ाइलहैंडल बनाने का दूसरा तरीका सिंबल मॉड्यूल या इसके साथ है
IO::हैंडल मॉड्यूल और उसके जैसे। इन मॉड्यूलों का फायदा यह है कि वे अलग-अलग चीजें नहीं छिपाते
के दौरान एक ही नाम के प्रकार स्थानीय (). एक के लिए perlfunc में "ओपन" के नीचे देखें
उदाहरण।

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