Cách tốt nhất để lặp qua mảng Perl

Cách triển khai nào tốt nhất (về tốc độ và sử dụng bộ nhớ) để lặp qua mảng Perl? Có cách nào tốt hơn không? ( @Arraykhông cần giữ lại).

Thực hiện 1

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

Thực hiện 2

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

Thực hiện 3

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

Thực hiện 4

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

Thực hiện 5

map { SubRoutine($_) } @Array ;

• Về tốc độ: # 1 và # 4, nhưng không nhiều trong hầu hết các trường hợp.

  Bạn có thể viết một điểm chuẩn để xác nhận, nhưng tôi nghi ngờ bạn sẽ thấy # 1 và # 4 nhanh hơn một chút vì công việc lặp được thực hiện bằng C thay vì Perl và không cần sao chép các phần tử mảng. ( $_được đặt biệt danh cho phần tử trong # 1, nhưng # 2 và # 3 thực sự sao chép các đại lượng vô hướng từ mảng.)

  # 5 có thể tương tự.

• Về sử dụng bộ nhớ: Tất cả chúng đều giống nhau ngoại trừ # 5.

  for (@a)là lớp vỏ đặc biệt để tránh làm phẳng mảng. Vòng lặp lặp qua các chỉ mục của mảng.

• Về khả năng đọc: # 1.

• Về tính linh hoạt: # 1 / # 4 và # 5.

  # 2 không hỗ trợ các phần tử sai. # 2 và # 3 là hủy diệt.

Nếu bạn chỉ quan tâm đến các yếu tố của @Array, hãy sử dụng:

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

hoặc là

Nếu các chỉ số quan trọng, hãy sử dụng:

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

Hoặc, kể từ perl5.12.1, bạn có thể sử dụng:

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

Nếu bạn cần cả phần tử và chỉ mục của nó trong phần thân của vòng lặp, Tôi mong chờ sử dụng each nhanh nhất, nhưng sau đóbạn sẽ từ bỏ khả năng tương thích với phiên bản trước 5.12.1 perl.

Một số mẫu khác ngoài những mẫu này có thể phù hợp trong những trường hợp nhất định.

IMO, triển khai số 1 là điển hình và ngắn gọn và dễ hiểu đối với Perl hơn hẳn những người khác về điều đó. Điểm chuẩn của ba lựa chọn có thể cung cấp cho bạn cái nhìn sâu sắc về tốc độ, ít nhất.

1 về cơ bản khác với 2 và 3, vì nó giữ nguyên mảng, trong khi hai mảng còn lại để trống.

Tôi muốn nói rằng # 3 là khá lập dị và có lẽ kém hiệu quả hơn, vì vậy hãy quên điều đó đi.

Cái nào để lại cho bạn vị trí # 1 và # 2, và chúng không làm điều tương tự, vì vậy cái nào không thể "tốt hơn" cái kia. Nếu mảng lớn và bạn không cần phải giữ nó, nói chung phạm vi sẽ giải quyết nó ( nhưng xem LƯU Ý ), vì vậy , nói chung , # 1 vẫn là phương pháp rõ ràng và đơn giản nhất. Di chuyển từng phần tử sẽ không tăng tốc bất cứ điều gì. Ngay cả khi cần giải phóng mảng khỏi tham chiếu, tôi chỉ cần đi:

undef @Array;

khi hoàn thành.

• LƯU Ý : Chương trình con chứa phạm vi của mảng thực sự giữ nguyên mảng và sử dụng lại khoảng trống vào lần sau. Nói chung , điều đó sẽ ổn (xem phần bình luận).

Trong một dòng để in phần tử hoặc mảng.

print $ _ for (@array);

LƯU Ý: hãy nhớ rằng $ _ đang tham chiếu nội bộ đến phần tử của @array trong vòng lặp. Mọi thay đổi được thực hiện trong $ _ sẽ phản ánh trong @array; Ví dụ.

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

đầu ra: 2 4 6

Cách tốt nhất để quyết định những câu hỏi như thế này để đánh giá chúng:

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

Và chạy điều này trên perl 5, phiên bản 24, subversion 1 (v5.24.1) được xây dựng cho x86_64-linux-gnu-thread-multi

Tôi có:

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)

Vì vậy, 'foreach (@Array)' nhanh gấp đôi so với những cái khác. Tất cả những cái khác đều rất giống nhau.

@ikegami cũng chỉ ra rằng có khá nhiều điểm khác biệt trong những áp lực này ngoài tốc độ.