`@ $ array` और अन्य संरचनाओं का अर्थ

Question

मैं अभी भी पर्ल 6 सीख रहा हूं। कृपया मेरी अज्ञानता को क्षमा करें। मैं Operators page पढ़ रहा हूँ और मैं एक मेज के शुरू में कुछ अपरिचित निर्माणों पाया:

A Level Examples 
N Terms 42 3.14 "eek" qq["foo"] $x :!verbose @$array 

मैं कक्षा सरणी और वर्ग अदिश फिर से पढ़ा लेकिन मैं उन वर्गों में @$xyz निर्माण खोजने में असमर्थ हूँ। :! और @$ का क्या अर्थ है? क्या कोई सुविधाजनक स्थान है जो इन सभी प्रतीकात्मक संरचनाओं को एकत्र और समझाता है?

बहुत बहुत धन्यवाद !!

Answer 1

@$foo@($foo), जहां $foo एक आइटम चर और @(...) वाक्य रचना बस अपने तर्क पर .list प्रणाली को बुलाती है के लिए कम है। विधि और वाक्य रचनात्मक रूप दोनों को कभी-कभी "सूची/सरणी संदर्भकर्ता" कहा जाता है, हालांकि मुझे यह नहीं पता कि आधिकारिक पर्ल 6 दस्तावेज़ों में सिंटैक्टिक फ़ॉर्म कहां से दस्तावेज किया गया है।

इसके लिए एक उपयोग, जब आप किसी आइटम कंटेनर में संग्रहीत एक ऐरे पर पुनरावृत्ति करना चाहते हैं। एक आइटम कंटेनर .list बुला इसके आसपास के आइटम कंटेनर बिना सादे सरणी रिटर्न पर जबकि, निर्मित-इन, जैसे for छोरों के रूप में से एक आइटम माना जाता है (यानी "बलों मूल्य सूची संदर्भ में व्याख्या की जा करने के लिए"):

my $foo = [1, 2, 3]; 

say $foo.perl;  # $[1, 2, 3] 
say $foo.list.perl; # [1, 2, 3] 
say @$foo.perl;  # [1, 2, 3] 

for $foo { ... }  # One iteration 
for $foo.list { ... } # Three iterations 
for @$foo { ... }  # Three iterations (identical to the previous line) 

---

:!foo:foo(False) के लिए कम है, यानीएक named argument मूल्य False है:

sub do-something (:$verbose = True) { say $verbose; } 

do-something;   # True 
do-something :verbose; # True 
do-something :!verbose; # False 

जब अवधि की स्थिति में नहीं बल्कि एक तर्क सूची का एक तर्क के रूप में लिखा है, यह एक Pair वस्तु का निर्माण:

say (:!verbose);  # verbose => False 

Answer 2

:verbose पैरामीटर का उपयोग Bool पर colon pair के साथ तर्क सेट करने का एक अच्छा तरीका होगा। यह :verbose(True) के बराबर है। :!verbose बस इसकी अस्वीकृति है, इसे False पर सेट करें, :verbose(False) के समतुल्य।

@$ sigil $ वाले स्केलर वेरिएबल से container दूर करने के लिए @ उपसर्ग का उपयोग करने का एक तरीका है।

पर विचार करें:

my $x = (1, 2, 3); 
.say for $x; 

आउटपुट:

(1 2 3) 

बनाम

my $x = (1, 2, 3); 
.say for @$x; 

आउटपुट:

1 
2 
3 

अधिकांश ऑपरेटरों को सीधे खोजा जा सकता है। विशेष रूप से ये दो मामले व्यक्तिगत ऑपरेटरों नहीं हैं, लेकिन संयोजन में प्रतीकों का उपयोग करने के मामले हैं। वे आसानी से थोड़ा और मुश्किल इकट्ठा होते हैं, लेकिन दस्तावेज़ हर दिन सुधार रहे हैं।