Perl Language
सूचियाँ

सूची के रूप में सरणी

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

आप एक सरणी के लिए एक सूची प्रदान कर सकते हैं:

my @foo = ( 4, 5, 6 );

जहाँ भी सूची अपेक्षित है, आप एक सरणी का उपयोग कर सकते हैं:

join '-', ( 4, 5, 6 );
join '-', @foo;

कुछ ऑपरेटर केवल सरणियों के साथ काम करते हैं क्योंकि वे सूची में एक सरणी को शामिल करते हैं:

shift @array;
unshift @array, ( 1, 2, 3 );
pop @array;
push @array, ( 7, 8, 9 );

किसी हैश को एक सूची सौंपना

सूचियाँ हैश चर को भी दी जा सकती हैं। जब एक हैश चर को सौंपा जाएगा एक सूची बनाने के लिए, यह अपने रिश्ते को दिखाने के लिए कुंजी और मूल्यों के बीच वसा अल्पविराम => का उपयोग करने की सिफारिश की जाती है:

my %hash = ( foo => 42, bar => 43, baz => 44 );

The => वास्तव में केवल एक विशेष अल्पविराम है जो स्वचालित रूप से ओपेरा को इसके बाईं ओर उद्धृत करता है। तो, आप सामान्य अल्पविराम का उपयोग कर सकते हैं, लेकिन संबंध उतना स्पष्ट नहीं है:

my %hash = ( 'foo', 42, 'bar', 43, 'baz', 44 );

आप वसा कॉमा => के बाएं हाथ के ऑपरेंड के लिए उद्धृत स्ट्रिंग्स का भी उपयोग कर सकते हैं, जो विशेष रूप से रिक्त स्थान वाली कुंजियों के लिए उपयोगी है।

my %hash = ( 'foo bar' => 42, 'baz qux' => 43 );

विवरण के लिए, perldoc perlop पर कोमा ऑपरेटर देखें।

सूचियों को सबरूटीन्स में पारित किया जा सकता है

एक सबरूटीन में सूची को पास करने के लिए, आप सबरूटीन का नाम निर्दिष्ट करते हैं और फिर उस सूची को आपूर्ति करते हैं:

test_subroutine( 'item1', 'item2' );
test_subroutine  'item1', 'item2';     # same

आंतरिक रूप से पर्ल उन तर्कों को उपनाम देता है और उन्हें सरणी में @_ जो कि सबरूटीन के भीतर उपलब्ध है:

@_ =  ( 'item1', 'item2' ); # Done internally by perl

आप इस तरह सबरूटिन तर्क तक पहुँचते हैं:

sub test_subroutine {
    print $_[0]; # item1
    print $_[1]; # item2
}

अलियासिंग आपको तर्क को मूल मान को बदलने की क्षमता देता है जो सबरूटीन को दिया गया है:

sub test_subroutine {
    $_[0] +=  2;
}

my $x =  7;
test_subroutine( $x );
print $x; # 9

अपने सबरूटीन में पारित मूल मूल्यों के अनजाने परिवर्तनों को रोकने के लिए, आपको उन्हें कॉपी करना चाहिए:

sub test_subroutine {
    my( $copy_arg1, $copy_arg2 ) =  @_;
    $copy_arg1 += 2;
}

my $x =  7;
test_subroutine $x; # in this case $copy_arg2 will have `undef` value
print $x; # 7

यह जांचने के लिए कि उप- @_ में कितने तर्क पारित किए गए हैं, @_ का आकार @_

sub test_subroutine {
    print scalar @_, ' argument(s) passed into subroutine';
}

यदि आप एक उप-तर्क में सरणी तर्क पास करते हैं तो वे सभी चपटा हो जाएंगे:

my @x =  ( 1, 2, 3 );
my @y =  qw/ a b c /; # ( 'a', 'b', 'c' )
test_some_subroutine @x, 'hi', @y; # 7 argument(s) passed into subroutine
# @_ =  ( 1, 2, 3, 'hi', 'a', 'b', 'c' ) # Done internally for this call

यदि आपके test_some_subroutine में $_[4] = 'd' कथन है, तो उपरोक्त कॉल के लिए $y[0] का कारण होगा जिसके बाद d :

print "@y"; # d b c

सबरूटीन से वापसी सूची

आप निश्चित रूप से, उप से सूची वापस कर सकते हैं:

sub foo {
    my @list1 =  ( 1, 2, 3 );
    my @list2 =  ( 4, 5 );

    return    ( @list1, @list2 );
}

my @list =  foo();
print @list;          # 12345

लेकिन ऐसा करने के लिए अनुशंसित तरीका नहीं है, जब तक कि आप नहीं जानते कि आप क्या कर रहे हैं।

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

print scalar foo();  # 2

2 क्यों? क्या हो रहा है?

1. क्योंकि SCALAR संदर्भ में foo() मूल्यांकन किया गया, इस सूची ( @list1, @list2 ) भी SCALAR संदर्भ में मूल्यांकन किया गया
2. SCALAR के संदर्भ में, LIST अपना अंतिम तत्व लौटाता है। यहाँ यह @list2
3. SCALAR संदर्भ में, array @list2 अपने तत्वों की संख्या लौटाता है। यहाँ यह 2 ।

ज्यादातर मामलों में सही रणनीति डेटा संरचनाओं के संदर्भ में वापस आ जाएगी ।
इसलिए हमारे मामले में हमें इसके बजाय निम्नलिखित करना चाहिए:

 return    ( \@list1, \@list2 );

तब कॉलर कुछ इस तरह से दो लौटे सरणी प्राप्त करने के लिए करता है:

 my ($list1, $list2) = foo(...);

सरणी को उप से पास करने के लिए arrayref का उपयोग करना

@Foo के लिए @foo \@foo । यह आसान है अगर आपको एक सरणी और अन्य चीजों को एक सबरूटीन पास करने की आवश्यकता है। @foo पास करना कई @foo पास करने @foo है। लेकिन \@foo करना एक एकल स्केलर है। सबरूटीन के अंदर:

xyz(\@foo, 123);
...
sub xyz {
    my ($arr, $etc) = @_;
    print $arr->[0]; # using the first item in $arr. It is like $foo[0]

सूची के रूप में हैश

सूची के संदर्भ में हैश चपटा है।

my @bar =  ( %hash, %hash );

सरणी @bar को दो %hash हैश की सूची द्वारा आरंभ किया गया है

• दोनों %hash चपटा है
• नई सूची चपटी वस्तुओं से बनाई गई है
• @bar सरणी को उस सूची से आरंभ किया जाता है

यह गारंटी है कि कुंजी-मूल्य जोड़े एक साथ जाते हैं। कुंजी हमेशा अनुक्रमित होती है, मान - विषम। यह गारंटी नहीं है कि कुंजी-मूल्य जोड़े हमेशा एक ही क्रम में चपटा होते हैं:

my %hash =  ( a => 1, b => 2 );
print %hash; # Maybe 'a1b2' or 'b2a1'