Passer deux ou plusieurs tableaux à un sous-programme Perl

J'ai du mal à passer et la lecture des arguments à l'intérieur de la sous-routine qui devrait avoir deux tableaux.

sub two_array_sum { # two_array_sum ( (1 2 3 4), (2, 4, 0, 1) ) -> (3, 6, 3, 5)
  # I would like to use parameters @a and @b as simply as possible
}

# I would like to call two_array_sum here and pass two arrays, @c and @d

J'ai vu et essayé plusieurs exemples sur le web, mais aucun d'entre eux travaillaient pour moi.

source d'informationauteur eold | 2011-04-15

28

Il y a deux façons dont vous pouvez faire ceci:
1. par prototype
2. par référence
Mais avant d'aborder ces-si ce que vous montrez dans votre question au sujet de l'ampleur de ce que vous voulez faire--permettez-moi de suggérer Liste::MoreUtils::pairwise

Ainsi, lorsque vous écrivez ceci:
```
my @sum = two_array_sum( @a, @b )
```
Vous pouvez simplement écrire ceci:
```
my @sum = pairwise { $a + $b } @a, @b;
```
Par prototype

Cela fonctionne comme push. (Et juste comme push il demande à avoir un @ sigil sur quelque chose)
```
sub two_array_sub (\@\@) { 
    my ( $aref, $bref ) = @_;
    ...
}
```
De cette façon, lorsque vous faites cela
```
two_array_sub( @a, @b );
```
il fonctionne. Alors que normalement, il suffit de se présenter dans votre sous comme une longue liste. Ils ne sont pas pour tout le monde comme vous le verrez dans ma discussion ci-dessous.

Par référence

C'est ce que tout le monde est à vous montrer.
```
some_sub( \@a, \@b );
```
Sur des prototypes

Ils sont capricieux. Cela ne fonctionnera pas si vous avez des refs:
```
two_array_sub( $arr_ref, $brr_ref );
```
Vous devez passer comme ça:
```
two_array_sub( @$arr_ref, @$brr_ref );
```
Cependant, puisque le fait de "tableau les expressions" obtient vraiment laid rapidement avec des tableaux imbriqués profonde, j'ai souvent éviter de Perl les pleurs que vous pouvez surcharger le type de référence Perl prendra en le mettant dans un "caractère de classe" de construire. \[$@] signifie que la référence peut être un scalaire ou un tableau.
```
sub new_two_array_sub (\[$@]\[$@]) { 
    my $ref = shift;
    my $arr = ref( $ref ) eq 'ARRAY' ? $ref : $$ref; # ref -> 'REF';
    $ref    = shift;
    my $brr = ref( $ref ) eq 'ARRAY' ? $ref : $$ref;
    ...
}
```
De sorte que tous ces travaux:
```
new_two_array_sub( @a, $self->{a_level}{an_array} );
new_two_array_sub( $arr, @b );
new_two_array_sub( @a, @b );
new_two_array_sub( $arr, $self->{a_level}{an_array} );
```
Cependant, Perl est toujours pointilleux à ce sujet... pour une raison:
```
new_two_array_sub( \@a, $b );
OR 
new_two_array_sub( $a, [ 1..3 ] );
```
Ou tout autre "constructeur" qui pouvait encore être considéré comme une référence à un tableau. Heureusement, vous pouvez fermer Perl place à ce sujet avec l'ancien Perl 4 &
```
&new_two_array_sub( \@a, [ 1..3 ] );
```
Puis le mux-ing code dans la sous-prend en charge deux références de tableau.
7

Passer des références de vos tableaux à la fonction:
```
two_array_sum( \@a, \@b )
```
et n'utilisez pas a ou b comme noms de variable, car $a et $b spéciales (pour tri).

Je vais citer man perlref mais vous devriez lire toutes les:

   Making References

   References can be created in several ways.

   1.  By using the backslash operator on a variable, subroutine, or
       value.  (This works much like the & (address-of) operator in C.)
       This typically creates another reference to a variable, because
       there's already a reference to the variable in the symbol table.
       But the symbol table reference might go away, and you'll still have
       the reference that the backslash returned.  Here are some examples:

           $scalarref = $foo;
           $arrayref  = \@ARGV;
           $hashref   = \%ENV;
           $coderef   = \&handler;
           $globref   = \*foo;

...

   Using References

   That's it for creating references.  By now you're probably dying to
   know how to use references to get back to your long-lost data.  There
   are several basic methods.

   1.  Anywhere you'd put an identifier (or chain of identifiers) as part
       of a variable or subroutine name, you can replace the identifier
       with a simple scalar variable containing a reference of the correct
       type:

           $bar = $$scalarref;
           push(@$arrayref, $filename);
           $$arrayref[0] = "January";
           $$hashref{"KEY"} = "VALUE";
           &$coderef(1,2,3);
           print $globref "output\n";

my @sums = two_array_sum(\@aArray, \@bArray);

sub two_array_sum { # two_array_sum ( (1 2 3 4), (2, 4, 0, 1) ) -> (3, 6, 3, 5)
    my ($aRef, $bRef) = @_;
    my @result = ();

    my $idx = 0;
    foreach my $aItem (@{$aRef}) {
        my $bItem = $bRef->[$idx++];
        push (@result, $aItem + $bItem);
    }

    return @result;
}

2

Vous avez besoin pour passer des tableaux ou des hachages de votre sous-routine à l'aide de références, par exemple:
```
sub two_array_sum {
  my ($x, $y) = @_;
  #process $x, $y;
}
two_array_sum(\@a, \@b);
```
2

Vous ne pouvez pas passer des tableaux de fonctions. Les fonctions ne peuvent accepter une listes de scalaires pour l'argument. En tant que tel, vous devez passer les scalaires qui fournissent suffisamment de données pour recréer les tableaux.

Le moyen le plus simple de le faire est de passer des références à des tableaux.
```
sub two_array_sum {
   my ($array0, $array1) = @_;

   my @array0 = @$array0;
   my @array1 = @$array1;

   return map { $array0[$_] + $array1[$_] } 0..$#array0;
}
```
Vous pouvez même éviter la reconstruction de tableaux et de travailler avec les références directement.
```
sub two_array_sum {
   my ($array0, $array1) = @_;
   return map { $array0->[$_] + $array1->[$_] } 0..$#$array0;
}
```
Utilisation:
```
my @array0 = (1, 2, 3, 4);
my @array1 = (2, 4, 0, 1);
two_array_sum(\@array0, \@array1);
```
Crochets construire un tableau anonyme (remplie par le résultat de l'expression à l'intérieur) et renvoie une référence à ce tableau. Par conséquent, le ci-dessus peut aussi être écrite comme suit:
```
two_array_sum([1, 2, 3, 4], [2, 4, 0, 1]);
```
0

Ces méthodes sont canoniques. Une autre façon de faire:
```
use strict;
my $data;

@{$data->{array1}} = qw(foo bar baz);
@{$data->{array2}} = qw(works for me);
testsub($data);

sub testsub
{
    my ($data) = @_;
    print join "\t", @{$data->{array1}}, "\n";
    print join "\t", @{$data->{array2}}, "\n";
    $data->{array1}[3] = "newitem";
    delete $data->{array2};
    push @{$data->{newarray}}, (1, 2, 3);
    return $data;
}
```
Lorsque vous faites de cette façon, vous pouvez garder un contrôle beaucoup plus serré de vos variables, plutôt que de subir un rat nid de données du programme mêlés à des informations de configuration.

En général, je n'ai jamais plus de trois ou quatre variables dans n'importe quel programme.

Je garde aussi un système à cela, j'utilise un hachages de listes de valeurs de hachage de listes de chose.
```
$config->{server}[0]{prod}[0]{input}[0] = 'inputfile';
```
La raison en est que tant que je suis cohérente avec l'alternance dans chaque sens, Data::Dumper pouvez dump l'ensemble de la structure -- et je peux mieux contrôler la portée de données, et peuvent passer ensemble de structures autour de avec la facilité.

Je me retrouve souvent passer plusieurs structures de ce type pour les sous-routines. Comme les scalaires, ils passent assez bien, merci.

Vous devez vous connecter pour publier un commentaire.

Par prototype

Par référence

Sur des prototypes