एक पर्ल सरणी के माध्यम से पुनरावृति करने का सबसे अच्छा तरीका

Question 1

पर्ल सरणी के माध्यम से पुनरावृत्ति के लिए सबसे अच्छा कार्यान्वयन (गति और स्मृति उपयोग के संदर्भ में) कौन सा है? क्या कोई बेहतर तरीका है? ( @Arrayजरूरत नहीं बनाए रखा जाना चाहिए)।

कार्यान्वयन १

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

क्रियान्वयन २

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

क्रियान्वयन ३

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

क्रियान्वयन ४

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

क्रियान्वयन ५

map { SubRoutine($_) } @Array ;

Question 2

गति के संदर्भ में: # 1 और # 4, लेकिन अधिकांश उदाहरणों में ज्यादा नहीं।

आप पुष्टि करने के लिए एक बेंचमार्क लिख सकते हैं, लेकिन मुझे संदेह है कि आप # 1 और # 4 को थोड़ा तेज़ पाएंगे, क्योंकि इट्रिएशन का काम पर्ल के बजाय सी में किया जाता है, और सरणी तत्वों की कोई अनावश्यक नकल नहीं होती है। ( $_है एलियास # 1 में तत्व है, लेकिन # 2 और # 3 वास्तव में नकल सरणी से scalars।)

# 5 समान हो सकता है।
स्मृति उपयोग के संदर्भ में: वे # 5 को छोड़कर सभी समान हैं।

for (@a)सरणी को समतल करने से बचने के लिए विशेष आवरण है। लूप सरणी के अनुक्रमित पर पुनरावृत्त करता है।
पठनीयता के संदर्भ में: # 1।
लचीलेपन के संदर्भ में: # 1 / # 4 और # 5।

# 2 ऐसे तत्वों का समर्थन नहीं करता जो झूठे हैं। # 2 और # 3 विनाशकारी हैं।

Question 3

यदि आप केवल तत्वों के बारे में परवाह करते हैं @Array, तो उपयोग करें:

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

या

यदि इंडेक्स मायने रखता है, तो उपयोग करें:

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

या, perl5.12.1 के रूप में , आप उपयोग कर सकते हैं:

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

यदि आपको लूप के शरीर में तत्व और उसके सूचकांक दोनों की आवश्यकता है, ~~मुझे अपेक्षा होगी~~ का उपयोग करते हुए each ~~सबसे तेज़, लेकिन फिर~~आप पूर्व 5.12.1 perls के साथ संगतता छोड़ देंगे ।

इनकी तुलना में कुछ अन्य पैटर्न कुछ परिस्थितियों में उपयुक्त हो सकते हैं।

Question 4

IMO, कार्यान्वयन # 1 विशिष्ट है और पर्ल के लिए छोटा और मुहावरेदार होने के कारण दूसरों के लिए अकेले ही ट्रम्प करता है। तीन विकल्पों का एक बेंचमार्क आपको गति में अंतर्दृष्टि प्रदान कर सकता है, कम से कम।

Question 5

1 2 और 3 से काफी भिन्न होता है, क्योंकि यह सरणी को चातुर्य में छोड़ देता है, जबकि अन्य दो इसे खाली छोड़ देते हैं।

मैं कहूंगा कि # 3 बहुत निराला है और शायद कम कुशल है, इसलिए भूल जाते हैं।

जो आपको # 1 और # 2 के साथ छोड़ देता है, और वे एक ही काम नहीं करते हैं, इसलिए एक दूसरे से "बेहतर" नहीं हो सकता है। यदि सरणी बड़ी है और आपको इसे रखने की आवश्यकता नहीं है, तो आम तौर पर गुंजाइश इससे निपटेगी ( लेकिन नोट देखें ), इसलिए आमतौर पर , # 1 अभी भी सबसे स्पष्ट और सरल विधि है। प्रत्येक तत्व को बंद करने से कुछ भी गति नहीं होगी। यहां तक कि अगर सरणी को संदर्भ से मुक्त करने की आवश्यकता है, तो मैं अभी जाऊंगा:

undef @Array;

जब हो जाए।

ध्यान दें : सरणी के दायरे वाले सबरूटीन वास्तव में सरणी रखता है और अगली बार अंतरिक्ष का फिर से उपयोग करता है। आम तौर पर , यह ठीक होना चाहिए (टिप्पणियों को देखें)।

Question 6

तत्व या सरणी को मुद्रित करने के लिए एकल पंक्ति में।

$ (_array) के लिए $ _ प्रिंट करें;

नोट: याद रखें कि $ _ आंतरिक रूप से लूप में @ ऐरे के तत्व का उल्लेख कर रहा है। $ _ में किए गए कोई भी परिवर्तन @ श्रेणी में प्रतिबिंबित होंगे; पूर्व।

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

आउटपुट: 2 4 6

Question 7

उन्हें बेंचमार्क करने के लिए इस तरह से सवाल तय करने का सबसे अच्छा तरीका:

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)' दूसरों की तुलना में दोगुना तेज़ है। अन्य सभी बहुत समान हैं।

@ ईकगामी यह भी बताता है कि गति के अलावा इन निहितार्थों में काफी अंतर हैं।