Perl dizisi aracılığıyla yinelemenin en iyi yolu

Bir Perl dizisi aracılığıyla yineleme yapmak için en iyi uygulama (hız ve bellek kullanımı açısından) hangisidir? Daha iyi bir yol var mı? ( @Arraysaklanmasına gerek yoktur).

Uygulama 1

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

Uygulama 2

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

Uygulama 3

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

Uygulama 4

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

Uygulama 5

map { SubRoutine($_) } @Array ;

• Hız açısından: # 1 ve # 4, ancak çoğu durumda fazla değil.

  Doğrulamak için bir kıyaslama yazabilirsiniz, ancak # 1 ve # 4'ü biraz daha hızlı bulacağınızdan şüpheleniyorum çünkü yineleme çalışması Perl yerine C'de yapılıyor ve dizi öğelerinin gereksiz kopyalanması gerçekleşmiyor. ( $_Olup takma ad 1. eleman, ancak # 2 ve # 3, aslında kopya diziden skalarlar.)

  # 5 benzer olabilir.

• Bellek kullanımı açısından: # 5 dışında hepsi aynı.

  for (@a)dizinin düzleşmesini önlemek için özel kasalıdır. Döngü, dizinin indeksleri üzerinde yinelenir.

• Okunabilirlik açısından: # 1.

• Esneklik açısından: # 1 / # 4 ve # 5.

  # 2, yanlış olan öğeleri desteklemez. # 2 ve # 3 yıkıcıdır.

Yalnızca öğelerini önemsiyorsanız @Array, kullanın:

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

veya

Endeksler önemliyse şunu kullanın:

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

Veya perl5.12.1'den itibaren şunları kullanabilirsiniz:

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

Döngünün gövdesinde hem öğeye hem de dizinine ihtiyacınız varsa, Beklemek isterim kullanma each en hızlı olmak, ama sonra5.12.1 öncesi ile uyumluluktan vazgeçeceksiniz perl.

Bunlardan başka bazı modeller belirli koşullar altında uygun olabilir.

IMO, uygulama # 1 tipiktir ve Perl için kısa ve deyimsel olması, yalnızca bunun için diğerlerinden üstündür. Üç seçeneğin bir karşılaştırması, en azından size hız hakkında fikir verebilir.

1, diziyi dokunmadan bıraktığı için 2 ve 3'ten büyük ölçüde farklıdır, oysa diğer ikisi diziyi boş bırakır.

# 3'ün oldukça tuhaf ve muhtemelen daha az verimli olduğunu söyleyebilirim, bu yüzden unutun bunu.

Bu sizi # 1 ve # 2 olarak bırakır ve aynı şeyi yapmazlar, bu nedenle biri diğerinden "daha iyi" olamaz. Dizi büyüktür ve bunu tutmak gerek yoksa, genellikle bununla başa (edecek kapsam ancak bkz NOT ), bu yüzden genel olarak , 1. hala açık ve basit bir yöntemdir. Her bir öğeyi kaydırmak hiçbir şeyi hızlandırmaz. Diziyi referanstan serbest bırakma ihtiyacı olsa bile, şöyle yapardım:

undef @Array;

bittiğinde.

• NOT : Dizinin kapsamını içeren alt yordam aslında diziyi korur ve bir dahaki sefere alanı yeniden kullanır. Genel olarak bu iyi olmalıdır (yorumlara bakın).

Öğeyi veya diziyi yazdırmak için tek satırda.

(@array) için $ _ yazdır;

NOT: $ _'ın dahili olarak döngüdeki @array öğesine başvurduğunu unutmayın. $ _ İçinde yapılan herhangi bir değişiklik @array'e yansır; ör.

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

çıktı: 2 4 6

Karşılaştırmak için buna benzer sorulara karar vermenin en iyi yolu:

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,
});

Ve bunu x86_64-linux-gnu-thread-multi için oluşturulmuş perl 5, version 24, subversion 1 (v5.24.1) üzerinde çalıştırmak

Alırım:

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)

Yani 'foreach (@Array)' diğerlerinden yaklaşık iki kat daha hızlıdır. Diğerleri çok benzer.

@ikegami, bu ifadelerde hız dışında epeyce farklılık olduğuna da dikkat çekiyor.