Perl Language
चर
खोज…
वाक्य - विन्यास
- मेरी # लेक्सिकल घोषणा
- हमारी # वैश्विक घोषणा
- $ फू # स्केलर
- @ फ़ू # अर्रे
- $ # फू # अर्रे लास्ट-इंडेक्स
- % फू # हश
- $ {$ foo} # स्केलर डी-संदर्भ
- @ {$ foo} # ऐरे डी-संदर्भ
- $ # {$ foo} # ऐरे-डेफ लास्ट-इंडेक्स
- % {$ foo} # हैश डे-रेफरेंस
- $ फू [$ इंडेक्स] # ऐरे इंडेक्स हो जाते हैं
- $ {$ foo} [$ इंडेक्स] # ऐरे डी-रेफरेंस और इंडेक्स प्राप्त करें।
- $ foo -> [$ इंडेक्स] # ऐरे-रेफरेंस और इंडेक्सेड (सरलीकृत)
- $ फू {$ कुंजी} # हैश को कुंजी के लिए मूल्य मिलता है
- $ {$ foo} {$ key} # हैश डेरेफेरेंस और कुंजी के लिए मूल्य प्राप्त करें
- $ फू -> {$ कुंजी} # हैश डेरेफेरेंस और कुंजी के लिए मूल्य प्राप्त करें (सरलीकृत)
- $ $ # स्केलर का संदर्भ
- \ _x # एरे का संदर्भ
- हश के लिए \% x # संदर्भ
- = [] # बेनामी एरे का संदर्भ (इनलाइन)
- = {} # बेनामी हैश (इनलाइन) का संदर्भ
Scalars
स्केलर्स पर्ल के सबसे बुनियादी डेटा प्रकार हैं। वे सतर्क $ के साथ चिह्नित हैं और तीन प्रकारों में से एक का एक ही मूल्य रखते हैं:
- एक संख्या (
3,42,3.141, आदि) - एक स्ट्रिंग (
'hi',"abc", आदि) - एक चर का संदर्भ (अन्य उदाहरण देखें)।
my $integer = 3; # number
my $string = "Hello World"; # string
my $reference = \$string; # reference to $string
पर्ल एक विशेष ऑपरेटर की अपेक्षा के आधार पर, मक्खी पर संख्या और तार के बीच धर्मान्तरित होता है।
my $number = '41'; # string '41'
my $meaning = $number + 1; # number 42
my $sadness = '20 apples'; # string '20 apples'
my $danger = $sadness * 2; # number '40', raises warning
एक स्ट्रिंग को संख्या में परिवर्तित करते समय, पर्ल स्ट्रिंग के सामने से उतने ही अंक ले सकता है - जितना कि अंतिम पंक्ति में 20 20 apples को 20 में परिवर्तित किया 20 apples है।
इस आधार पर कि क्या आप स्केलर की सामग्री को एक स्ट्रिंग या एक संख्या के रूप में व्यवहार करना चाहते हैं, आपको विभिन्न ऑपरेटरों का उपयोग करने की आवश्यकता है। उन्हें मत मिलाओ।
# String comparison # Number comparison
'Potato' eq 'Potato'; 42 == 42;
'Potato' ne 'Pomato'; 42 != 24;
'Camel' lt 'Potato'; 41 < 42;
'Zombie' gt 'Potato'; 43 > 42;
# String concatenation # Number summation
'Banana' . 'phone'; 23 + 19;
# String repetition # Number multiplication
'nan' x 3; 6 * 7;
संख्याओं पर स्ट्रिंग संचालन का उपयोग करने का प्रयास चेतावनी नहीं बढ़ाएगा; गैर-संख्यात्मक स्ट्रिंग्स पर संख्या संचालन का उपयोग करने का प्रयास करेंगे। ध्यान रहे कि कुछ गैर-अंक के तार जैसे 'inf' , 'nan' , '0 but true' संख्याओं के रूप में गिने जाते हैं।
Arrays
Arrays मानों के एक क्रमबद्ध क्रम को संग्रहीत करता है। आप अनुक्रमणिका द्वारा सामग्री तक पहुँच सकते हैं, या उन पर पुनरावृति कर सकते हैं। आपके द्वारा उन्हें भरे जाने के क्रम में मूल्य बने रहेंगे।
my @numbers_to_ten = (1,2,3,4,5,6,7,8,9,10); # More conveniently: (1..10)
my @chars_of_hello = ('h','e','l','l','o');
my @word_list = ('Hello','World');
# Note the sigil: access an @array item with $array[index]
my $second_char_of_hello = $chars_of_hello[1]; # 'e'
# Use negative indices to count from the end (with -1 being last)
my $last_char_of_hello = $chars_of_hello[-1];
# Assign an array to a scalar to get the length of the array
my $length_of_array = @chars_of_hello; # 5
# You can use $# to get the last index of an array, and confuse Stack Overflow
my $last_index_of_array = $#chars_of_hello; # 4
# You can also access multiple elements of an array at the same time
# This is called "array slice"
# Since this returns multiple values, the sigil to use here on the RHS is @
my @some_chars_of_hello = @chars_of_hello[1..3]; # ('H', 'e', 'l')
my @out_of_order_chars = @chars_of_hello[1,4,2]; # ('e', 'o', 'l')
# In Python you can say array[1:-1] to get all elements but first and last
# Not so in Perl: (1..-1) is an empty list. Use $# instead
my @empty_list = @chars_of_hello[1..-1]; # ()
my @inner_chars_of_hello = @chars_of_hello[1..$#chars_of_hello-1]; # ('e','l','l')
# Access beyond the end of the array yields undef, not an error
my $undef = $chars_of_hello[6]; # undef
सरणियाँ परस्पर हैं:
use utf8; # necessary because this snippet is utf-8
$chars_of_hello[1] = 'u'; # ('h','u','l','l','o')
push @chars_of_hello, ('!', '!'); # ('h','u','l','l','o','!','!')
pop @chars_of_hello; # ('h','u','l','l','o','!')
shift @chars_of_hello; # ('u','l','l','o','!')
unshift @chars_of_hello, ('¡', 'H'); # ('¡','H','u','l','l','o','!')
@chars_of_hello[2..5] = ('O','L','A'); # ('¡','H','O','L','A',undef,'!') whoops!
delete $chars_of_hello[-2]; # ('¡','H','O','L','A', '!')
# Setting elements beyond the end of an array does not result in an error
# The array is extended with undef's as necessary. This is "autovivification."
my @array; # ()
my @array[3] = 'x'; # (undef, undef, undef, 'x')
अंत में, आप किसी सरणी की सामग्री पर लूप कर सकते हैं:
use v5.10; # necessary for 'say'
for my $number (@numbers_to_ten) {
say $number ** 2;
}
जब बूलियन के रूप में उपयोग किया जाता है, तो सरणियां सच होती हैं यदि वे खाली नहीं हैं।
हैश
हैशिंग को लुकअप-टेबल के रूप में समझा जा सकता है। आप उनमें से प्रत्येक के लिए एक कुंजी निर्दिष्ट करके इसकी सामग्री तक पहुँच सकते हैं। कुंजी तार होना चाहिए। यदि वे नहीं हैं, तो उन्हें तार में बदल दिया जाएगा।
यदि आप हैश को केवल एक ज्ञात कुंजी देते हैं, तो यह आपको उसका मूल्य प्रदान करेगा।
# Elements are in (key, value, key, value) sequence
my %inhabitants_of = ("London", 8674000, "Paris", 2244000);
# You can save some typing and gain in clarity by using the "fat comma"
# syntactical sugar. It behaves like a comma and quotes what's on the left.
my %translations_of_hello = (spanish => 'Hola', german => 'Hallo', swedish => 'Hej');
निम्नलिखित उदाहरण में, कोष्ठक और सर्जन पर ध्यान दें: आप $hash{key} का उपयोग करके %hash एक तत्व का उपयोग करते हैं क्योंकि आप जो मूल्य चाहते हैं वह एक अदिश राशि है। कुछ इसे कुंजी को उद्धृत करने के लिए अच्छा अभ्यास मानते हैं जबकि अन्य इस शैली को नेत्रहीन पाते हैं। उद्धरण केवल उन कुंजियों के लिए आवश्यक है जो $hash{'some-key'} जैसी अभिव्यक्तियों के लिए गलत हो सकती हैं $hash{'some-key'}
my $greeting = $translations_of_hello{'spanish'};
जबकि पर्ल डिफ़ॉल्ट रूप से स्ट्रिंग्स के रूप में नंगे पासवर्ड का उपयोग करने की कोशिश करेगा, + पर्ल को इंगित करने के लिए + संशोधक का उपयोग भी किया जा सकता है कि कुंजी को प्रक्षेपित नहीं किया जाना चाहिए, लेकिन निष्पादन के परिणाम के साथ निष्पादित किया जा सकता है:
my %employee = ( name => 'John Doe', shift => 'night' );
# this example will print 'night'
print $employee{shift};
# but this one will execute [shift][1], extracting first element from @_,
# and use result as a key
print $employee{+shift};
सरणियों की तरह, आप एक ही समय में कई हैश तत्वों का उपयोग कर सकते हैं। इसे हैश स्लाइस कहा जाता है। परिणामी मूल्य एक सूची है, इसलिए @ sigil का उपयोग करें:
my @words = @translations_of_hello{'spanish', 'german'}; # ('Hola', 'Hallo')
के साथ एक हैश की चाबियाँ पर पुनरावृति keys keys एक यादृच्छिक क्रम में आइटम वापस आ जाएगी। आप चाहें तो छाँट के साथ sort ।
for my $lang (sort keys %translations_of_hello) {
say $translations_of_hello{$lang};
}
आप वास्तव में पिछले उदाहरण में तरह कुंजी की जरूरत नहीं है, values हैश के मूल्यों सीधे आकर:
for my $translation (values %translations_of_hello) {
say $translation;
}
तुम भी हैश पर पुनरावृति करने के लिए each साथ एक समय लूप का उपयोग कर सकते हैं। इस तरह, आपको एक ही समय में एक अलग मूल्य की खोज के बिना, कुंजी और मूल्य दोनों मिलेंगे। हालांकि इसका उपयोग हतोत्साहित किया जाता है, क्योंकि each गलत तरीके से टूट सकता है।
# DISCOURAGED
while (my ($lang, $translation) = each %translations_of_hello) {
say $translation;
}
परेशान तत्वों की पहुंच अपरिभाषित है, त्रुटि नहीं:
my $italian = $translations_of_hello{'italian'}; # undef
map और सूची चपटे का उपयोग सरणियों से बाहर हैश बनाने के लिए किया जा सकता है। यह मानों का एक 'सेट' बनाने का एक लोकप्रिय तरीका है, उदाहरण के लिए जल्दी से यह जांचने के लिए कि क्या मान @elems । यह ऑपरेशन आमतौर पर O (n) समय (यानी तत्वों की संख्या के अनुपात में) लेता है, लेकिन सूची को हैश में बदलकर निरंतर समय (O (1)) में किया जा सकता है:
@elems = qw(x y x z t);
my %set = map { $_ => 1 } @elems; # (x, 1, y, 1, t, 1)
my $y_membership = $set{'y'}; # 1
my $w_membership = $set{'w'}; # undef
इसके लिए कुछ स्पष्टीकरण की आवश्यकता है। @elems की सामग्री एक सूची में पढ़ी जाती है, जिसे map द्वारा संसाधित किया जाता है। map एक कोड ब्लॉक को स्वीकार करता है जिसे इसकी इनपुट सूची के प्रत्येक मूल्य के लिए कहा जाता है; तत्व का मूल्य $_ में उपयोग के लिए उपलब्ध है। हमारा कोड ब्लॉक प्रत्येक इनपुट तत्व के लिए दो सूची तत्व देता है: $_ , इनपुट तत्व, और 1 , बस कुछ मूल्य। एक बार जब आप सूची चपटा करने के लिए खाते हैं, तो परिणाम यह है कि map { $_ => 1 } @elems qw(xyxzt) में बदल जाता है (x => 1, y => 1, x => 1, z => 1, t => 1) ।
जैसे-जैसे उन तत्वों को हैश में असाइन किया जाता है, विषम तत्व हैश कीज़ बन जाते हैं और यहां तक कि तत्व हैश मान बन जाते हैं। जब किसी कुंजी को एक हैश को सौंपा जाने वाली सूची में कई बार निर्दिष्ट किया जाता है, तो अंतिम मान जीत जाता है। यह प्रभावी रूप से डुप्लिकेट को त्याग देता है।
एक हैश में सूची को चालू करने का एक तेज़ तरीका हैश स्लाइस को असाइनमेंट का उपयोग करता है। यह @elems के आकार से एकल-तत्व सूची (1) को गुणा करने के लिए x ऑपरेटर का उपयोग करता है, इसलिए बाएं हाथ की तरफ स्लाइस में प्रत्येक कुंजी के लिए 1 मान है:
@elems = qw(x y x z t);
my %set;
@set{@elems} = (1) x @elems;
हैश के निम्नलिखित अनुप्रयोग इस तथ्य का भी फायदा उठाते हैं कि हैश और सूचियों को अक्सर नामांकित फ़ंक्शन आरेखों को लागू करने के लिए परस्पर उपयोग किया जा सकता है:
sub hash_args {
my %args = @_;
my %defaults = (foo => 1, bar => 0);
my %overrides = (__unsafe => 0);
my %settings = (%defaults, %args, %overrides);
}
# This function can then be called like this:
hash_args(foo => 5, bar => 3); # (foo => 5, bar => 3, __unsafe ==> 0)
hash_args(); # (foo => 1, bar => 0, __unsafe ==> 0)
hash_args(__unsafe => 1) # (foo => 1, bar => 0, __unsafe ==> 0)
जब बूलियन के रूप में उपयोग किया जाता है, तो वे खाली नहीं होने पर हैश असली होते हैं।
स्केलर संदर्भ
एक संदर्भ एक अदिश चर ( $ से उपसर्ग) है जो "कुछ अन्य डेटा" को संदर्भित करता है।
my $value = "Hello";
my $reference = \$value;
print $value; # => Hello
print $reference; # => SCALAR(0x2683310)
संदर्भित डेटा प्राप्त करने के लिए, आप इसे डी- रेफर करते हैं।
say ${$reference}; # Explicit prefix syntax
say $$reference; # The braces can be left out (confusing)
नया उपसर्ग dereference सिंटैक्स, v5.24 से डिफ़ॉल्ट रूप से उपलब्ध है
use v5.24;
say $reference->$*; # New postfix notation
यह "डी-संदर्भित मान" तब बदला जा सकता है जैसे यह मूल चर था।
${$reference} =~ s/Hello/World/;
print ${$reference}; # => World
print $value; # => World
एक संदर्भ हमेशा सत्य होता है - भले ही इसका संदर्भ मूल्य मिथ्या हो (जैसे 0 या "" )।
आप एक स्केलर संदर्भ चाह सकते हैं यदि:
आप किसी फ़ंक्शन के लिए एक स्ट्रिंग पास करना चाहते हैं, और क्या यह आपके लिए उस स्ट्रिंग को संशोधित करता है, बिना रिटर्न वैल्यू के।
आप स्पष्ट रूप से पर्ल से स्पष्ट रूप से बचने की इच्छा रखते हैं ताकि आपके फ़ंक्शन के किसी बिंदु पर एक बड़े स्ट्रिंग की सामग्री की नकल की जा सके (विशेषकर कॉपी-ऑन-राइट स्ट्रिंग्स के बिना पुराने पर्ल्स पर प्रासंगिक)
आप उदाहरण के लिए, सामग्री को व्यक्त करने वाले तार से, विशिष्ट अर्थ के साथ स्ट्रिंग-जैसे मानों की अवहेलना करना चाहते हैं:
- फ़ाइल सामग्री से फ़ाइल का नाम हटाएं
- किसी दिए गए त्रुटि स्ट्रिंग से सामग्री लौटा दी गई
आप ऑब्जेक्ट मॉडल के अंदर एक हल्का लागू करना चाहते हैं, जहाँ कॉलिंग कोड को सौंपी गई वस्तुएं उपयोगकर्ता को दिखाई देने वाला मेटाडेटा नहीं देती हैं:
our %objects; my $next_id = 0; sub new { my $object_id = $next_id++; $objects{ $object_id } = { ... }; # Assign data for object my $ref = \$object_id; return bless( $ref, "MyClass" ); }
ऐरे सन्दर्भ
Array References स्केलर ( $ ) हैं जो Arrays को संदर्भित करते हैं।
my @array = ("Hello"); # Creating array, assigning value from a list
my $array_reference = \@array;
इन्हें निम्न प्रकार से अधिक छोटा बनाया जा सकता है:
my $other_array_reference = ["Hello"];
सरणी संदर्भों को संशोधित / उपयोग करते हुए उन्हें पहले डीफ्रेंसिंग की आवश्यकता होती है।
my @contents = @{ $array_reference }; # Prefix notation
my @contents = @$array_reference; # Braces can be left out
नया उपसर्ग dereference सिंटैक्स, v5.24 से डिफ़ॉल्ट रूप से उपलब्ध है
use v5.24;
my @contents = $array_reference->@*; # New postfix notation
अनुक्रमणिका द्वारा अरैरिज़ की सामग्री तक पहुँचते समय आप -> संश्लिष्ट चीनी का उपयोग कर सकते हैं।
my @array = qw(one two three); my $arrayref = [ qw(one two three) ]
my $one = $array[0]; my $one = $arrayref->[0];
सरणियों के विपरीत, सरणी को नेस्टेड किया जा सकता है:
my @array = ( (1, 0), (0, 1) ) # ONE array of FOUR elements: (1, 0, 0, 1)
my @matrix = ( [1, 0], [0, 1] ) # an array of two arrayrefs
my $matrix = [ [0, 1], [1, 0] ] # an arrayref of arrayrefs
# There is no namespace conflict between scalars, arrays and hashes
# so @matrix and $matrix _both_ exist at this point and hold different values.
my @diagonal_1 = ($matrix[0]->[1], $matrix[1]->[0]) # uses @matrix
my @diagonal_2 = ($matrix->[0]->[1], $matrix->[1]->[0]) # uses $matrix
# Since chained []- and {}-access can only happen on references, you can
# omit some of those arrows.
my $corner_1 = $matrix[0][1]; # uses @matrix;
my $corner_2 = $matrix->[0][1]; # uses $matrix;
जब बूलियन के रूप में उपयोग किया जाता है, तो संदर्भ हमेशा सच होते हैं।
हैश संदर्भ
हैश संदर्भ स्केलर होते हैं जिनमें एक हैश के डेटा वाले मेमोरी लोकेशन के लिए एक पॉइंटर होता है। क्योंकि स्केलर सीधे हैश की ओर इशारा करता है, जब इसे एक सबरूटीन को पास किया जाता है, तो हैश में किए गए बदलाव सबरूटीन के लिए एक नियमित हैश के साथ स्थानीय नहीं होते हैं, बल्कि वैश्विक होते हैं।
पहले, आइए देखें कि जब आप एक सामान्य हैश को एक सबरूटीन में पास करते हैं और इसे वहां संशोधित करते हैं:
use strict;
use warnings;
use Data::Dumper;
sub modify
{
my %hash = @_;
$hash{new_value} = 2;
print Dumper("Within the subroutine");
print Dumper(\%hash);
return;
}
my %example_hash = (
old_value => 1,
);
modify(%example_hash);
print Dumper("After exiting the subroutine");
print Dumper(\%example_hash);
जिसके परिणामस्वरूप:
$VAR1 = 'Within the subroutine';
$VAR1 = {
'new_value' => 2,
'old_value' => 1
};
$VAR1 = 'After exiting the subroutine';
$VAR1 = {
'old_value' => 1
};
ध्यान दें कि हम सबरूटिन से बाहर निकलने के बाद, हैश अनछुए रहते हैं; यह सब परिवर्तन स्थानीय सबरूटीन के लिए स्थानीय थे, क्योंकि हमने हैश की एक प्रति पारित की थी, न कि स्वयं हैश की।
इसकी तुलना में, जब आप एक हैशरेप पास करते हैं, तो आप मूल हैश को पता दे रहे हैं, इसलिए सबरूटीन के भीतर किए गए कोई भी परिवर्तन मूल हैश में किए जाएंगे:
use strict;
use warnings;
use Data::Dumper;
sub modify
{
my $hashref = shift;
# De-reference the hash to add a new value
$hashref->{new_value} = 2;
print Dumper("Within the subroutine");
print Dumper($hashref);
return;
}
# Create a hashref
my $example_ref = {
old_value => 1,
};
# Pass a hashref to a subroutine
modify($example_ref);
print Dumper("After exiting the subroutine");
print Dumper($example_ref);
इसका परिणाम यह होगा:
$VAR1 = 'Within the subroutine';
$VAR1 = {
'new_value' => 2,
'old_value' => 1
};
$VAR1 = 'After exiting the subroutine';
$VAR1 = {
'new_value' => 2,
'old_value' => 1
};
टाइपग्लोब, टाइपग्लोब रिफ, फाइलहैंडल और स्थिरांक
एक टाइपग्लोब *foo उस नाम के साथ वैश्विक चर की सामग्री का संदर्भ रखता है: $foo , @foo , $foo , &foo , आदि। आप इसे हैश की तरह एक्सेस कर सकते हैं और सीधे प्रतीक तालिकाओं में हेरफेर करने का काम कर सकते हैं (बुराई!)।
use v5.10; # necessary for say
our $foo = "foo";
our $bar;
say ref *foo{SCALAR}; # SCALAR
say ${ *foo{SCALAR} }; # bar
*bar = *foo;
say $bar; # bar
$bar = 'egg';
say $foo; # egg
फ़ाइलों के साथ काम करते समय टाइपग्लोब को अधिक सामान्यतः नियंत्रित किया जाता है। open , उदाहरण के लिए, एक typeglob के लिए एक संदर्भ जब एक गैर वैश्विक filehandle बनाने के लिए कहा पैदा करता है:
use v5.10; # necessary for say
open(my $log, '> utf-8', '/tmp/log') or die $!; # open for writing with encoding
say $log 'Log opened';
# You can dereference this globref, but it's not very useful.
say ref $log; # GLOB
say (*{$log}->{IO} // 'undef'); # undef
close $log or die $!;
ग्लोबल रीड-ओनली वैरिएबल बनाने के लिए टाइपग्लोब का भी उपयोग किया जा सकता है, हालांकि use constant उपयोग व्यापक उपयोग में है।
# Global constant creation
*TRUE = \('1');
our $TRUE;
say $TRUE; # 1
$TRUE = ''; # dies, "Modification of a read-only value attempted"
# use constant instead defines a parameterless function, therefore it's not global,
# can be used without sigils, can be imported, but does not interpolate easily.
use constant (FALSE => 0);
say FALSE; # 0
say &FALSE; # 0
say "${\FALSE}"; # 0 (ugh)
say *FALSE{CODE}; # CODE(0xMA1DBABE)
# Of course, neither is truly constant when you can manipulate the symbol table...
*TRUE = \('');
use constant (EVIL => 1);
*FALSE = *EVIL;
sigils
पर्ल के पास कई सिगिल हैं:
$scalar = 1; # individual value
@array = ( 1, 2, 3, 4, 5 ); # sequence of values
%hash = ('it', 'ciao', 'en', 'hello', 'fr', 'salut'); # unordered key-value pairs
&function('arguments'); # subroutine
*typeglob; # symbol table entry
ये दिखने में sigils की तरह हैं, लेकिन ये नहीं हैं:
\@array; # \ returns the reference of what's on the right (so, a reference to @array)
$#array; # this is the index of the last element of @array
यदि आप इतने इच्छुक होना चाहिए तो आप सतर्क के बाद ब्रेसिज़ का उपयोग कर सकते हैं। कभी-कभी, यह पठनीयता में सुधार करता है।
say ${value} = 5;
जब आप विभिन्न प्रकारों के चर को परिभाषित करने के लिए अलग-अलग sigils का उपयोग करते हैं, तो उसी चर को आपके द्वारा उपयोग किए जाने वाले sigils के आधार पर विभिन्न तरीकों से एक्सेस किया जा सकता है।
%hash; # we use % because we are looking at an entire hash
$hash{it}; # we want a single value, however, that's singular, so we use $
$array[0]; # likewise for an array. notice the change in brackets.
@array[0,3]; # we want multiple values of an array, so we instead use @
@hash{'it','en'}; # similarly for hashes (this gives the values: 'ciao', 'hello')
%hash{'it','fr'}; # we want an hash with just some of the keys, so we use %
# (this gives key-value pairs: 'it', 'ciao', 'fr', 'salut')
यह संदर्भों के लिए विशेष रूप से सच है। संदर्भित मान का उपयोग करने के लिए आप सिगिल को एक साथ जोड़ सकते हैं।
my @array = 1..5; # This is an array
my $reference_to_an_array = \@array; # A reference to an array is a singular value
push @array, 6; # push expects an array
push @$reference_to_an_array, 7; # the @ sigil means what's on the right is an array
# and what's on the right is $reference_to_an_array
# hence: first a @, then a $
यहाँ इसके बारे में सोचने का शायद कम भ्रमित तरीका है। जैसा कि हमने पहले देखा था, आप एक सजग के दाईं ओर क्या है इसे लपेटने के लिए ब्रेसिज़ का उपयोग कर सकते हैं। तो आप @{} में कुछ सोच सकते हैं जो एक सरणी संदर्भ लेता है और आपको संदर्भित सरणी देता है।
# pop does not like array references
pop $reference_to_an_array; # ERROR in Perl 5.20+
# but if we use @{}, then...
pop @{ $reference_to_an_array }; # this works!
जैसा कि यह पता चला है, @{} वास्तव में एक अभिव्यक्ति स्वीकार करता है:
my $values = undef;
say pop @{ $values }; # ERROR: can't use undef as an array reference
say pop @{ $values // [5] } # undef // [5] gives [5], so this prints 5
... और यही चाल अन्य सिगिल के लिए भी काम करती है।
# This is not an example of good Perl. It is merely a demonstration of this language feature
my $hashref = undef;
for my $key ( %{ $hashref // {} } ) {
"This doesn't crash";
}
... लेकिन अगर एक सर्जन के लिए "तर्क" सरल है, तो आप ब्रेसिज़ को दूर छोड़ सकते हैं।
say $$scalar_reference;
say pop @$array_reference;
for keys (%$hash_reference) { ... };
चीजें अत्यधिक असाधारण हो सकती हैं। यह काम करता है, लेकिन जिम्मेदारी से पर्ल कृपया।
my %hash = (it => 'ciao', en => 'hi', fr => 'salut');
my $reference = \%hash;
my $reference_to_a_reference = \$reference;
my $italian = $hash{it}; # Direct access
my @greets = @$reference{'it', 'en'}; # Dereference, then access as array
my %subhash = %$$reference_to_a_reference{'en', 'fr'} # Dereference ×2 then access as hash
अधिकांश सामान्य उपयोग के लिए, आप बस सबरूटिन नामों का उपयोग बिना किसी सजग के कर सकते हैं। (बिना सर्जन के चर को आम तौर पर "नंगे पासवर्ड" कहा जाता है।) & sigil सीमित मामलों में ही उपयोगी होता है।
एक सबरूटीन का संदर्भ बनाना:
sub many_bars { 'bar' x $_[0] } my $reference = \&many_bars; say $reference->(3); # barbarbarकिसी फ़ंक्शन को उसके प्रोटोटाइप को अनदेखा करना।
गोटो के साथ मिलकर, एक अजीब अजीब फ़ंक्शन कॉल के रूप में जिसमें कॉलर के साथ वर्तमान कॉल फ़्रेम है। लिनक्स
exec()एपीआई कॉल के बारे में सोचें, लेकिन कार्यों के लिए।