Meilleur moyen d'itérer dans un tableau Perl

Quelle est la meilleure implémentation (en termes de vitesse et d'utilisation de la mémoire) pour itérer dans un tableau Perl? Y a-t-il une meilleure façon? ( @Arrayne doit pas être conservé).

Mise en œuvre 1

foreach (@Array)
{
      SubRoutine($_);
}

Mise en œuvre 2

while($Element=shift(@Array))
{
      SubRoutine($Element);
}

Mise en œuvre 3

while(scalar(@Array) !=0)
{
      $Element=shift(@Array);
      SubRoutine($Element);
}

Mise en œuvre 4

for my $i (0 .. $#Array)
{
      SubRoutine($Array[$i]);
}

Mise en œuvre 5

map { SubRoutine($_) } @Array ;

• En termes de vitesse: # 1 et # 4, mais pas de beaucoup dans la plupart des cas.

  Vous pourriez écrire un benchmark pour confirmer, mais je suppose que vous trouverez que les n ° 1 et 4 sont légèrement plus rapides car le travail d'itération est effectué en C au lieu de Perl, et aucune copie inutile des éléments du tableau ne se produit. ( $_est aliasé sur l'élément dans # 1, mais # 2 et # 3 copient en fait les scalaires du tableau.)

  # 5 pourrait être similaire.

• En termes d'utilisation de la mémoire: ils sont tous les mêmes sauf pour # 5.

  for (@a)est un boîtier spécial pour éviter d'aplatir le tableau. La boucle itère sur les index du tableau.

• En termes de lisibilité: # 1.

• En termes de flexibilité: # 1 / # 4 et # 5.

  # 2 ne prend pas en charge les éléments qui sont faux. Les n ° 2 et 3 sont destructeurs.

Si vous ne vous souciez que des éléments de @Array, utilisez:

for my $el (@Array) {
# ...
}

ou

Si les indices comptent, utilisez:

for my $i (0 .. $#Array) {
# ...
}

Ou, à partir de la version perl5.12.1, vous pouvez utiliser:

while (my ($i, $el) = each @Array) {
# ...
}

Si vous avez besoin à la fois de l'élément et de son index dans le corps de la boucle, Je m'attendrais en utilisant each être le plus rapide, mais alorsvous renoncerez à la compatibilité avec les versions antérieures à 5.12.1 perl.

Un autre modèle que ceux-ci pourrait être approprié dans certaines circonstances.

IMO, la mise en œuvre n ° 1 est typique et étant courte et idiomatique pour Perl l'emporte sur les autres pour cela seul. Un benchmark des trois choix pourrait vous offrir au moins un aperçu de la vitesse.

1 est sensiblement différent de 2 et 3, car il laisse le réseau intact, tandis que les deux autres le laissent vide.

Je dirais que le n ° 3 est assez farfelu et probablement moins efficace, alors oubliez cela.

Ce qui vous laisse avec le n ° 1 et le n ° 2, et ils ne font pas la même chose, donc l'un ne peut pas être "meilleur" que l'autre. Si le tableau est volumineux et que vous n'avez pas besoin de le conserver, la portée le traitera généralement ( mais voir NOTE ), donc généralement , # 1 est toujours la méthode la plus claire et la plus simple. Décaler chaque élément n'accélérera rien. Même s'il est nécessaire de libérer le tableau de la référence, j'irais simplement:

undef @Array;

lorsque vous avez terminé.

• REMARQUE : le sous-programme contenant la portée du tableau conserve en fait le tableau et réutilise l'espace la prochaine fois. En général , cela devrait être bien (voir les commentaires).

En une seule ligne pour imprimer l'élément ou le tableau.

print $ _ pour (@array);

NOTE: rappelez-vous que $ _ fait référence en interne à l'élément de @array en boucle. Toutes les modifications apportées à $ _ seront reflétées dans @array; ex.

my @array = qw( 1 2 3 );
for (@array) {
        $_ = $_ *2 ;
}
print "@array";

sortie: 2 4 6

La meilleure façon de décider de questions comme celle-ci pour les comparer:

use strict;
use warnings;
use Benchmark qw(:all);

our @input_array = (0..1000);

my $a = sub {
    my @array = @{[ @input_array ]};
    my $index = 0;
    foreach my $element (@array) {
       die unless $index == $element;
       $index++;
    }
};

my $b = sub {
    my @array = @{[ @input_array ]};
    my $index = 0;
    while (defined(my $element = shift @array)) {
       die unless $index == $element;
       $index++;
    }
};

my $c = sub {
    my @array = @{[ @input_array ]};
    my $index = 0;
    while (scalar(@array) !=0) {
       my $element = shift(@array);
       die unless $index == $element;
       $index++;
    }
};

my $d = sub {
    my @array = @{[ @input_array ]};
    foreach my $index (0.. $#array) {
       my $element = $array[$index];
       die unless $index == $element;
    }
};

my $e = sub {
    my @array = @{[ @input_array ]};
    for (my $index = 0; $index <= $#array; $index++) {
       my $element = $array[$index];
       die unless $index == $element;
    }
};

my $f = sub {
    my @array = @{[ @input_array ]};
    while (my ($index, $element) = each @array) {
       die unless $index == $element;
    }
};

my $count;
timethese($count, {
   '1' => $a,
   '2' => $b,
   '3' => $c,
   '4' => $d,
   '5' => $e,
   '6' => $f,
});

Et l'exécuter sur perl 5, version 24, subversion 1 (v5.24.1) construit pour x86_64-linux-gnu-thread-multi

Je reçois:

Benchmark: running 1, 2, 3, 4, 5, 6 for at least 3 CPU seconds...
         1:  3 wallclock secs ( 3.16 usr +  0.00 sys =  3.16 CPU) @ 12560.13/s (n=39690)
         2:  3 wallclock secs ( 3.18 usr +  0.00 sys =  3.18 CPU) @ 7828.30/s (n=24894)
         3:  3 wallclock secs ( 3.23 usr +  0.00 sys =  3.23 CPU) @ 6763.47/s (n=21846)
         4:  4 wallclock secs ( 3.15 usr +  0.00 sys =  3.15 CPU) @ 9596.83/s (n=30230)
         5:  4 wallclock secs ( 3.20 usr +  0.00 sys =  3.20 CPU) @ 6826.88/s (n=21846)
         6:  3 wallclock secs ( 3.12 usr +  0.00 sys =  3.12 CPU) @ 5653.53/s (n=17639)

Ainsi, le 'foreach (@Array)' est environ deux fois plus rapide que les autres. Tous les autres sont très similaires.

@ikegami souligne également qu'il existe de nombreuses différences dans ces implémentations autres que la vitesse.