Cara terbaik untuk melakukan iterasi melalui larik Perl

Manakah implementasi terbaik (dalam hal kecepatan dan penggunaan memori) untuk iterasi melalui larik Perl? Apakah ada cara yang lebih baik? ( @Arraytidak perlu disimpan).

Implementasi 1

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

Implementasi 2

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

Implementasi 3

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

Implementasi 4

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

Implementasi 5

map { SubRoutine($_) } @Array ;

• Dalam hal kecepatan: # 1 dan # 4, tetapi tidak banyak dalam banyak kasus.

  Anda dapat menulis patokan untuk mengonfirmasi, tetapi saya curiga Anda akan menemukan # 1 dan # 4 menjadi sedikit lebih cepat karena pekerjaan iterasi dilakukan di C, bukan di Perl, dan tidak ada penyalinan elemen array yang tidak perlu terjadi. ( $_adalah alias elemen di # 1, tetapi # 2 dan # 3 sebenarnya menyalin skalar dari array.)

  # 5 mungkin serupa.

• Dalam hal penggunaan memori: Semuanya sama kecuali # 5.

  for (@a)dilapisi khusus untuk menghindari perataan array. Perulangan melakukan iterasi pada indeks array.

• Dalam hal keterbacaan: # 1.

• Dalam hal fleksibilitas: # 1 / # 4 dan # 5.

  # 2 tidak mendukung elemen yang salah. # 2 dan # 3 bersifat merusak.

Jika Anda hanya peduli tentang elemen @Array, gunakan:

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

atau

Jika indeks penting, gunakan:

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

Atau, pada perl 5.12.1, Anda dapat menggunakan:

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

Jika Anda membutuhkan elemen dan indeksnya di badan loop, Saya harapkan menggunakan each menjadi yang tercepat, tapi kemudianAnda akan melepaskan kompatibilitas dengan pra-5.12.1 perls.

Beberapa pola lain selain ini mungkin sesuai dalam keadaan tertentu.

IMO, implementasi # 1 adalah tipikal dan pendek dan idiomatis karena Perl mengalahkan yang lain untuk itu saja. Tolok ukur dari tiga pilihan mungkin menawarkan Anda wawasan tentang kecepatan, setidaknya.

1 secara substansial berbeda dari 2 dan 3, karena meninggalkan array dengan bijaksana, sedangkan dua lainnya membiarkannya kosong.

Saya akan mengatakan # 3 cukup aneh dan mungkin kurang efisien, jadi lupakan itu.

Yang membuat Anda mendapat # 1 dan # 2, dan mereka tidak melakukan hal yang sama, jadi yang satu tidak bisa "lebih baik" dari yang lain. Jika arraynya besar dan Anda tidak perlu menyimpannya, umumnya scope akan menghadapinya ( tapi lihat CATATAN ), jadi secara umum , # 1 masih merupakan metode yang paling jelas dan paling sederhana. Mematikan setiap elemen tidak akan mempercepat apa pun. Bahkan jika ada kebutuhan untuk membebaskan array dari referensi, saya hanya akan pergi:

undef @Array;

ketika selesai.

• CATATAN : Subrutin yang berisi ruang lingkup larik sebenarnya menyimpan larik dan menggunakan kembali ruang di lain waktu. Secara umum , itu seharusnya bagus (lihat komentar).

Dalam satu baris untuk mencetak elemen atau larik.

cetak $ _ untuk (@array);

CATATAN: ingat bahwa $ _ secara internal merujuk ke elemen @array dalam perulangan. Setiap perubahan yang dibuat di $ _ akan terlihat di @array; ex.

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

keluaran: 2 4 6

Cara terbaik untuk memutuskan pertanyaan seperti ini untuk membandingkannya:

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

Dan menjalankan ini pada perl 5, versi 24, subversi 1 (v5.24.1) dibangun untuk x86_64-linux-gnu-thread-multi

Saya mendapat:

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)

Jadi 'foreach (@Array)' kira-kira dua kali lebih cepat dari yang lain. Semua yang lain sangat mirip.

@ikegami juga menunjukkan bahwa ada beberapa perbedaan dalam implimentasi ini selain kecepatan.