Perl Language
सबरूटीन्स

टिप्पणियों

सबरूटीन बनाना

एक sub पहचानकर्ता और एक ब्रेसिज़ में संलग्न कोड ब्लॉक के बाद सबरूटीन्स का उपयोग किया जाता है।

आप विशेष चर @_ का उपयोग करके तर्कों का उपयोग कर सकते हैं, जिसमें एक सरणी के रूप में सभी तर्क शामिल हैं।

sub function_name {
    my ($arg1, $arg2, @more_args) = @_;
    # ...
}

चूंकि फ़ंक्शन shift चूक @_ को शिफ्ट करने के लिए किया जाता है, जब एक सबरूटीन के अंदर उपयोग किया जाता है, तो यह एक सामान्य पैटर्न है जो सबरूटीन की शुरुआत में क्रमिक रूप से स्थानीय चर में तर्क निकालने के लिए है:

sub function_name {
    my $arg1 = shift;
    my $arg2 = shift;
    my @more_args = @_;
    # ...
}

# emulate named parameters (instead of positional)
sub function_name {
    my %args = (arg1 => 'default', @_);
    my $arg1 = delete $args{arg1};
    my $arg2 = delete $args{arg2};
    # ...
}

sub {
    my $arg1 = shift;
    # ...
}->($arg);

use feature "signatures";

sub function_name($arg1, $arg2, @more_args) {
    # ...
}

use feature "signatures";

sub function_name($arg1=1, $arg2=2) {
    # ...
}

sub function_name($arg1=1, $arg2=$arg1+1) {
    # ...
}

sub function_name($arg1=$arg2, $arg2=1) {
    print $arg1;  # => <nothing>
    print $arg2;  # => 1
}

सबरूटीन तर्क को संदर्भ के द्वारा पारित किया जाता है (हस्ताक्षर में उन लोगों को छोड़कर)

जब तक वे हस्ताक्षर में नहीं होते हैं, तब तक पर्ल में सबरूटीन तर्क को पारित कर दिया जाता है। इसका मतलब यह है कि उप के अंदर @_ सरणी के सदस्य वास्तविक तर्क के लिए केवल उपनाम हैं। निम्नलिखित उदाहरण में, मुख्य कार्यक्रम में $text को उप- $text कॉल के बाद संशोधित किया गया है क्योंकि उप के अंदर $_[0] वास्तव में एक ही चर के लिए एक अलग नाम है। दूसरा आह्वान एक त्रुटि फेंकता है क्योंकि एक स्ट्रिंग शाब्दिक एक चर नहीं है और इसलिए इसे संशोधित नहीं किया जा सकता है।

use feature 'say';

sub edit {
    $_[0] =~ s/world/sub/;
}

my $text = "Hello, world!";
edit($text);
say $text;      # Hello, sub!

edit("Hello, world!"); # Error: Modification of a read-only value attempted

अपने कॉलर के चर को देखने से बचने के लिए इसलिए " @_ उप-निर्माण बनाना "के तहत स्थानीय रूप से स्कोप किए गए चर ( my ... ) को कॉपी करना महत्वपूर्ण है।

सबरूटीन्स

सबरूटीन्स कोड रखते हैं। जब तक अन्यथा निर्दिष्ट न हो, वे विश्व स्तर पर परिभाषित हैं।

# Functions do not (have to) specify their argument list
sub returns_one {
  # Functions return the value of the last expression by default
  # The return keyword here is unnecessary, but helps readability.
  return 1;
}

# Its arguments are available in @_, however
sub sum {
  my $ret = 0;
  for my $value (@_) {
    $ret += $value
  }
  return $ret;
}

# Perl makes an effort to make parens around argument list optional
say sum 1..3;     # 6

# If you treat functions as variables, the & sigil is mandatory.
say defined ∑ # 1

कुछ बिल जैसे print या यूं say कि कीवर्ड हैं, फ़ंक्शंस नहीं हैं, इसलिए उदा &say अपरिभाषित हैं। इसका मतलब यह भी है कि आप उन्हें परिभाषित कर सकते हैं, लेकिन आपको पैकेज का नाम वास्तव में उन्हें कॉल करने के लिए निर्दिष्ट करना होगा

# This defines the function under the default package, 'main'
sub say {
  # This is instead the say keyword
  say "I say, @_";
}

# ...so you can call it like this: 
main::say('wow'); # I say, wow.

use feature 'lexical_subs';
my $value;
{
  # Nasty code ahead
  my sub prod {
    my $ret = 1;
    $ret *= $_ for @_;
    $ret;
  }
  $value = prod 1..6; # 720 
  say defined ∏ # 1
}
say defined ∏ # 0

use feature 'signatures';
sub greet($name) {
  say "Hello, $name";
}

# This prototype makes it a compilation error to call this function with anything 
# that isn't an array. Additionally, arrays are automatically turned into arrayrefs
sub receives_arrayrefs(\@\@) {
   my $x = shift;
   my $y = shift;
}

my @a = (1..3);
my @b = (1..4);
receives_arrayrefs(@a, @b);    # okay,   $x = \@a, $y = \@b, @_ = ();
receives_arrayrefs(\@a, \@b);  # compilation error, "Type … must be array …"
BEGIN { receives_arrayrefs(\@a, \@b); }

# Specify the sigil to ignore the prototypes. 
&receives_arrayrefs(\@a, \@b); # okay,   $x = \@a, $y = \@b, @_ = ();
&receives_arrayrefs(@a, @b);   # ok, but $x = 1,   $y = 2,   @_ = (3,1,2,3,4);