วิธีที่ดีที่สุดในการวนซ้ำผ่านอาร์เรย์ Perl

การใช้งานแบบใดที่ดีที่สุด (ในแง่ของความเร็วและการใช้หน่วยความจำ) สำหรับการทำซ้ำผ่านอาร์เรย์ Perl มีวิธีไหนที่ดีกว่านี้ไหม? (@Arrayไม่จำเป็นต้องเก็บรักษาไว้)

การนำไปใช้ 1

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

การนำไปใช้งาน 2

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

การนำไปใช้ 3

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

การนำไปใช้งาน 4

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

การนำไปใช้ 5

map { SubRoutine($_) } @Array ;

• ในแง่ของความเร็ว: # 1 และ # 4 แต่ไม่มากในกรณีส่วนใหญ่

  คุณสามารถเขียนเกณฑ์มาตรฐานเพื่อยืนยันได้ แต่ฉันสงสัยว่าคุณจะพบว่า # 1 และ # 4 จะเร็วขึ้นเล็กน้อยเนื่องจากงานการวนซ้ำจะทำใน C แทน Perl และไม่มีการคัดลอกองค์ประกอบอาร์เรย์โดยไม่จำเป็น ( $_มีนามแฝงเป็นองค์ประกอบใน # 1 แต่ # 2 และ # 3 คัดลอกสเกลาร์จากอาร์เรย์จริงๆ)

  # 5 อาจจะคล้ายกัน.

• ในแง่การใช้หน่วยความจำ: เหมือนกันทั้งหมดยกเว้น # 5

  for (@a)เป็นแบบพิเศษเพื่อหลีกเลี่ยงการแบนอาร์เรย์ ลูปจะวนซ้ำบนดัชนีของอาร์เรย์

• ในแง่ของการอ่าน: # 1.

• ในแง่ของความยืดหยุ่น: # 1 / # 4 และ # 5

  # 2 ไม่สนับสนุนองค์ประกอบที่เป็นเท็จ # 2 และ # 3 คือการทำลายล้าง

หากคุณสนใจเฉพาะองค์ประกอบของ@Arrayให้ใช้:

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

หรือ

หากดัชนีมีความสำคัญให้ใช้:

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

หรือ ณperl5.12.1 คุณสามารถใช้:

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

หากคุณต้องการทั้งองค์ประกอบและดัชนีในเนื้อหาของลูป ฉันคาดหวัง โดยใช้ each จะเร็วที่สุด แต่แล้วคุณจะเลิกใช้ความเข้ากันได้กับรุ่นก่อน 5.12.1 perlวินาที

รูปแบบอื่นนอกเหนือจากนี้อาจเหมาะสมในบางสถานการณ์

IMO การใช้งาน # 1 เป็นเรื่องปกติและสั้นและเป็นสำนวนสำหรับ Perl สำคัญกว่าคนอื่น ๆ สำหรับสิ่งนั้นเพียงอย่างเดียว เกณฑ์มาตรฐานของสามทางเลือกอาจให้ข้อมูลเชิงลึกเกี่ยวกับความเร็วอย่างน้อย

1 แตกต่างจาก 2 และ 3 อย่างมากเนื่องจากมันออกจากอาร์เรย์อย่างมีชั้นเชิงในขณะที่อีกสองตัวปล่อยให้ว่างไว้

ฉันจะบอกว่า # 3 ค่อนข้างแปลกและอาจมีประสิทธิภาพน้อยกว่าดังนั้นอย่าลืมว่า

ซึ่งทำให้คุณมี # 1 และ # 2 และพวกเขาไม่ได้ทำสิ่งเดียวกันดังนั้นจึงไม่สามารถ "ดีกว่า" ไปกว่าอีกอันได้ หากอาร์เรย์มีขนาดใหญ่และคุณไม่จำเป็นต้องเก็บไว้โดยทั่วไปขอบเขตจะจัดการกับมัน ( แต่ดู หมายเหตุ ) ดังนั้นโดยทั่วไปแล้ว # 1 ยังคงเป็นวิธีที่ชัดเจนและง่ายที่สุด การเลื่อนแต่ละองค์ประกอบออกจะไม่เร่งความเร็ว แต่อย่างใด แม้ว่าจะมีความจำเป็นที่จะต้องปลดปล่อยอาร์เรย์จากการอ้างอิงฉันจะไป:

undef @Array;

เมื่อทำเสร็จแล้ว.

• หมายเหตุ : รูทีนย่อยที่มีขอบเขตของอาร์เรย์จะเก็บอาร์เรย์ไว้และใช้พื้นที่ใหม่ในครั้งต่อไป โดยทั่วไปควรจะใช้ได้ (ดูความคิดเห็น)

ในบรรทัดเดียวเพื่อพิมพ์องค์ประกอบหรืออาร์เรย์

พิมพ์ $ _ สำหรับ (@array);

หมายเหตุ: โปรดจำไว้ว่า $ _ ภายในหมายถึงองค์ประกอบของ @array ในลูป การเปลี่ยนแปลงใด ๆ ที่ทำใน $ _ จะแสดงใน @array; เช่น

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

เอาต์พุต: 2 4 6

วิธีที่ดีที่สุดในการตัดสินคำถามเช่นนี้เพื่อเปรียบเทียบคำถามเหล่านี้:

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

และรันสิ่งนี้บน perl 5 เวอร์ชัน 24 การโค่นล้ม 1 (v5.24.1) ที่สร้างขึ้นสำหรับ x86_64-linux-gnu-thread-multi

ฉันเข้าใจ:

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)

ดังนั้น 'foreach (@Array)' จึงเร็วกว่าตัวอื่นประมาณสองเท่า คนอื่น ๆ ทั้งหมดคล้ายกันมาก

@ikegami ยังชี้ให้เห็นว่ามีความแตกต่างเล็กน้อยในการเลียนแบบเหล่านี้นอกเหนือจากความเร็ว