Perl Language
Des listes

Tableau comme liste

Le tableau est l'un des types de variables de base de Perl. Il contient une liste, qui est une séquence ordonnée de zéro ou plusieurs scalaires. Le tableau est la variable contenant (et donnant accès aux) données de liste, comme cela est documenté dans perldata .

Vous pouvez affecter une liste à un tableau:

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

Vous pouvez utiliser un tableau partout où une liste est attendue:

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

Certains opérateurs ne fonctionnent qu'avec des tableaux car ils modifient la liste contenue dans un tableau:

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

Assigner une liste à un hachage

Les listes peuvent également être affectées à des variables de hachage. Lors de la création d'une liste qui sera assignée à une variable de hachage, il est recommandé d'utiliser la virgule grasse => entre les clés et les valeurs pour afficher leur relation:

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

Le => n'est en réalité qu'une virgule spéciale qui cite automatiquement l'opérande à sa gauche. Donc, vous pouvez utiliser des virgules normales, mais la relation n'est pas aussi claire:

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

Vous pouvez également utiliser des chaînes entre guillemets pour l'opérande gauche de la virgule grasse => , ce qui est particulièrement utile pour les clés contenant des espaces.

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

Pour plus de détails, voir Opérateur de virgule à perldoc perlop .

Les listes peuvent être transmises en sous-programmes

Pour transmettre la liste à un sous-programme, vous spécifiez le nom du sous-programme, puis vous lui fournissez la liste:

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

En interne, Perl crée des alias pour ces arguments et les place dans le tableau @_ disponible dans le sous-programme:

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

Vous accédez à des arguments de sous-routine comme ceci:

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

L'aliasing vous permet de modifier la valeur d'origine de l'argument passé à la sous-routine:

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

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

Pour éviter les modifications involontaires des valeurs d'origine transmises à votre sous-routine, vous devez les copier:

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

Pour tester le nombre d'arguments passés dans le sous-programme, vérifiez la taille de @_

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

Si vous passez des arguments de tableau dans un sous-programme, ils seront tous aplatis :

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

Si votre test_some_subroutine contient l'instruction $_[4] = 'd' , pour l'appel ci-dessus, $y[0] aura la valeur d après:

print "@y"; # d b c

Liste de retour du sous-programme

Vous pouvez bien sûr renvoyer des listes de sous-marins:

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

    return    ( @list1, @list2 );
}

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

Mais ce n'est pas la façon recommandée de le faire à moins que vous sachiez ce que vous faites.

Bien que cela soit correct lorsque le résultat est dans un contexte LIST , dans le contexte SCALAR , les choses ne sont pas claires. Regardons la ligne suivante:

print scalar foo();  # 2

Pourquoi 2 ? Que se passe-t-il?

1. foo() évalué dans le contexte SCALAR , cette liste ( @list1, @list2 ) également évaluée dans le contexte SCALAR
2. Dans le contexte SCALAR , LIST renvoie son dernier élément. Ici c'est @list2
3. Toujours dans le contexte SCALAR , array @list2 renvoie le nombre de ses éléments. Ici c'est 2 .

Dans la plupart des cas, la bonne stratégie renverra des références aux structures de données .
Donc, dans notre cas, nous devrions plutôt faire ce qui suit:

 return    ( \@list1, \@list2 );

Ensuite, l'appelant fait quelque chose comme ça pour recevoir les deux tableaux retournés:

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

Utiliser arrayref pour passer le tableau à sub

Le tableau RAF pour @foo est \@foo . C'est pratique si vous devez passer un tableau et d'autres choses à une sous-routine. Passer @foo c'est comme passer plusieurs scalaires. Mais passer \@foo est un scalaire unique. Dans la sous-routine:

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

Hash comme liste

Dans le contexte de la liste, le hachage est aplati.

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

Le tableau @bar est initialisé par la liste de deux %hash hachages de %hash

• les deux %hash sont aplatis
• nouvelle liste est créée à partir d'éléments aplatis
• @bar tableau @bar est initialisé par cette liste

Il est garanti que les paires clé-valeur vont ensemble. Les clés sont toujours indexées, les valeurs - impaires. Il n'est pas garanti que les paires clé-valeur soient toujours aplaties dans le même ordre:

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