Perl Language
Sous-routines

Remarques

Créer des sous-routines

Les sous-routines sont créées en utilisant le mot-clé sub suivi d'un identifiant et d'un bloc de code entre accolades.

Vous pouvez accéder aux arguments en utilisant la variable spéciale @_ , qui contient tous les arguments sous forme de tableau.

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

Comme la fonction shift @_ défaut le décalage de @_ lorsqu'elle est utilisée dans un sous-programme, il est courant d'extraire les arguments séquentiellement dans des variables locales au début d'un sous-programme:

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
}

Les arguments de sous-routine sont transmis par référence (sauf ceux des signatures)

Les arguments de sous-routine en Perl sont transmis par référence, sauf s'ils se trouvent dans la signature. Cela signifie que les membres du tableau @_ dans le sous-ensemble ne sont que des alias aux arguments réels. Dans l'exemple suivant, $text dans le programme principal reste modifié après l'appel du sous-programme car $_[0] à l'intérieur du sous-marin n'est en fait qu'un nom différent pour la même variable. La seconde invocation génère une erreur car un littéral de chaîne n'est pas une variable et ne peut donc pas être modifié.

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

Pour éviter de frapper les variables de votre interlocuteur, il est donc important de copier @_ vers des variables localisées ( my ... ) comme décrit dans "Création de sous-routines".

Sous-routines

Les sous-programmes contiennent du code. Sauf indication contraire, ils sont définis globalement.

# 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

Certains builtins tels que l' print ou say sont des mots clés, pas les fonctions, donc par exemple &say est indéfini. Cela signifie également que vous pouvez les définir, mais vous devrez spécifier le nom du paquet pour les appeler réellement

# 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);