कौन सा लूप तेज है, जबकि या इसके लिए?

Question

आप के लिए के साथ एक ही उत्पादन प्राप्त कर सकते हैं और while लूप:

जबकि:

$i = 0; 
while ($i <= 10){ 
    print $i."\n"; 
    $i++; 
}; 

के लिए:

for ($i = 0; $i <= 10; $i++){ 
    print $i."\n"; 
} 

लेकिन जो एक तेज है?

Answer 1

कि स्पष्ट रूप से विशिष्ट भाषा का दुभाषिया/संकलक की विशेष कार्यान्वयन पर निर्भर करता है।

जिसके अनुसार, सैद्धांतिक रूप से, किसी भी समझदार कार्यान्वयन अन्य के मामले में एक को लागू करने में सक्षम होने की संभावना है, तो यह तेजी से इतना अंतर ज्यादा से ज्यादा नगण्य होना चाहिए था।

_{बेशक, मैंने while और for व्यवहार किया जैसा कि वे सी और इसी तरह की भाषाओं में करते हैं। आप while के लिए पूरी तरह से अलग अर्थ विज्ञान के साथ एक भाषा बना सकते हैं और for}

Answer 2

भाषा और सबसे अधिक संभावना अपने संकलक पर निर्भर करता है, लेकिन वे सबसे अधिक भाषाओं में बराबर होना चाहिए।

Answer 3

वे बराबर होना चाहिए। पाश के लिए आप ने लिखा बिल्कुल वही बात है कि जब तक पाश कर रहा है कर रहा है:, $i=0 की स्थापना मुद्रण $i, और लूप के अंत में $i incrementing।

Answer 4

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

Answer 5

इससे कोई फर्क नहीं पड़ता कि यह तेज़ है। यदि इससे कोई फर्क पड़ता है तो इसे अपने असली कोड का उपयोग करके बेंचमार्क करें और अपने लिए देखें।

यह अन्य प्रश्न के उत्तर के साथ-साथ उपयोगी हो सकता है: How to write more efficient code

Answer 6

कहा पाश, संकलक की भाषा कार्यान्वयन और नहीं क्या पर निर्भर करेगा।

अधिकांश संकलक सीआईएल (.NET) में उदाहरण के लिए ठीक उसी निष्पादन योग्य कोड को संकलित कर देगा वे निश्चित रूप से कर रहे हैं।

स्रोत: vcsjones @http://forums.asp.net/t/1041090.aspx

किसी भी तरह से, लूप के शरीर जहां प्रसंस्करण समय नहीं जिस तरह से आप पुनरावृति खर्च किया जाएगा।

Answer 7

लूप पुनरावृत्तियों को 10,000 पर सेट करें।

मिलीसेकेंड में समय का पता लगाएं> चलाएँ लूप> मिलीसेकेंड में समय लगता है और पहली टाइमर घटाना।

दोनों कोड, जो भी एक न्यूनतम मिलीसेकेंड यह तेजी से चलाता है के लिए यह मत करो। परीक्षण को प्रभावित करने वाली पृष्ठभूमि प्रक्रियाओं की संभावना को कम करने के लिए आप कई बार परीक्षण चलाने और उन्हें औसत से बाहर करना चाहते हैं।

आपको दोनों पर वास्तव में समान समय मिल सकता है, लेकिन मुझे यह देखने में दिलचस्पी है कि कोई हमेशा थोड़ा तेज होता है या नहीं।

Answer 8

जैसा कि अन्य ने कहा है, इसके नमक के किसी भी कंपाइलर व्यावहारिक रूप से समान कोड उत्पन्न करेगा। प्रदर्शन में कोई अंतर नगण्य है - आप सूक्ष्म अनुकूलन कर रहे हैं।

वास्तविक सवाल यह है कि, और अधिक पठनीय क्या है? और यह for लूप (कम से कम IMHO) है।

Answer 9

मुझे लगता है सबसे तेजी से पाश एक रिवर्स जबकि पाश, उदा है:

var i = myArray.length; 
while(i--){ 
    // Do something 
} 

Answer 10

सी # में, पाश के लिए थोड़ा तेज है।

लूप औसत 2.95 से 3.02 एमएस के लिए।

जबकि लूप औसत 3.05 से 3.37 एमएस औसत था।

त्वरित थोड़ा सांत्वना अनुप्रयोग साबित करने के लिए:

class Program 
    { 
     static void Main(string[] args) 
     { 
      int max = 1000000000; 
      Stopwatch stopWatch = new Stopwatch(); 

      if (args.Length == 1 && args[0].ToString() == "While") 
      { 
       Console.WriteLine("While Loop: "); 
       stopWatch.Start(); 
       WhileLoop(max); 
       stopWatch.Stop(); 
       DisplayElapsedTime(stopWatch.Elapsed); 
      } 
      else 
      { 
       Console.WriteLine("For Loop: "); 
       stopWatch.Start(); 
       ForLoop(max); 
       stopWatch.Stop(); 
       DisplayElapsedTime(stopWatch.Elapsed); 
      } 
     } 

     private static void WhileLoop(int max) 
     { 
      int i = 0; 
      while (i <= max) 
      { 
       //Console.WriteLine(i); 
       i++; 
      }; 
     } 

     private static void ForLoop(int max) 
     { 
      for (int i = 0; i <= max; i++) 
      { 
       //Console.WriteLine(i); 
      } 
     } 

     private static void DisplayElapsedTime(TimeSpan ts) 
     { 
      // Format and display the TimeSpan value. 
      string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", 
       ts.Hours, ts.Minutes, ts.Seconds, 
       ts.Milliseconds/10); 
      Console.WriteLine(elapsedTime, "RunTime"); 
     } 
    } 

Answer 11

कुछ के अनुकूलन compilers बेहतर पाश के लिए एक साथ unrolling पाश करने में सक्षम हो जाएगा, लेकिन हालात यह है कि आप कुछ कर रहे हैं कि unrolled किया जा सकता है, एक हैं कंपाइलर को अनलोल करने के लिए पर्याप्त स्मार्ट शायद आपके लूप की लूप स्थिति की व्याख्या करने के लिए पर्याप्त स्मार्ट है, जो कुछ भी अनलॉक कर सकता है।

Answer 12

तकनीकी रूप से एक ऐसा करने के लिए नहीं है?

उदा।

for (int i = 0; i < length; ++i) 
{ 
    //Code Here. 
} 

होगा ...

int i = 0; 
do 
{ 
    //Code Here. 
} while (++i < length); 

मैं गलत हो सकता है, हालांकि ...

इसके अलावा जब यह छोरों के लिए आता है। यदि आप केवल डेटा पुनर्प्राप्त करने और डेटा को संशोधित करने की योजना नहीं बनाते हैं तो आपको एक foreach का उपयोग करना चाहिए। यदि आपको किसी कारण से वास्तविक अनुक्रमणिका की आवश्यकता है तो आपको वृद्धि करने की आवश्यकता होगी ताकि आपको लूप के लिए नियमित रूप से उपयोग करना चाहिए।

for (Data d : data) 
{ 
     d.doSomething(); 
} 

तुलना में तेजी से होना चाहिए ...

for (int i = 0; i < data.length; ++i) 
{ 
     data[i].doSomething(); 
} 

Answer 13

मैं एक ही बात सोच रहा था तो मैं googled और यहाँ समाप्त हो गया। मैं अजगर (अत्यंत सरल) में एक छोटे से परीक्षण किया था देखने के लिए और इस मैं क्या मिल गया है:

के लिए:

def for_func(n = 0): 
    for n in range(500): 
     n = n + 1 

अजगर -m timeit "आयात for_func; for_func.for_func() "> for_func.txt

10000 लूप, 3: 40 का सर्वश्रेष्ठ।पाश प्रति

जबकि 5 usec:

def while_func(n = 0): 
    while n < 500: 
     n = n + 1 

अजगर -m timeit "आयात while_func; while_func.while_func()"> while_func.txt

10000 छोरों, का सबसे अच्छा 3: 45 usec प्रति लूप

Answer 14

मैंने ठोस पर लूप के लिए उपयोग किया था परीक्षण मशीन (कोई गैर-मानक तृतीय पक्ष पृष्ठभूमि प्रक्रिया चल रही है)। मैंने for loop बनाम while loop चलाया क्योंकि यह 10,000 <button> नोड्स की स्टाइल प्रॉपर्टी को बदलने से संबंधित है।

यहाँ बहुत सरल जावास्क्रिप्ट मैं इस उद्देश्य के लिए बनाया

function runPerfTest() { 
    "use strict"; 

    function perfTest(fn, ns) { 
     console.time(ns); 
     fn(); 
     console.timeEnd(ns); 
    } 

    var target = document.getElementsByTagName('button'); 

    function whileDisplayNone() { 
     var x = 0; 
     while (target.length > x) { 
      target[x].style.display = 'none'; 
      x++; 
     } 
    } 

    function forLoopDisplayNone() { 
     for (var i = 0; i < target.length; i++) { 
      target[i].style.display = 'none'; 
     } 
    } 

    function reset() { 
     for (var i = 0; i < target.length; i++) { 
      target[i].style.display = 'inline-block'; 
     } 
    } 

    perfTest(function() { 
     whileDisplayNone(); 
    }, 'whileDisplayNone'); 

    reset(); 

    perfTest(function() { 
     forLoopDisplayNone(); 
    }, 'forLoopDisplayNone'); 

    reset(); 
}; 

$(function(){ 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    setTimeout(function(){ 
     console.log('cool run'); 
     runPerfTest(); 
    }, 1500); 
}); 

यहाँ:

परीक्षण 1 रन क्रियान्वयन से पहले 1500 मिलीसेकंड के लिए टाइम आउट हो गया साथ लगातार 10 बार चलाया गया था है, क्या परिणाम

pen.js:8 whileDisplayNone: 36.987ms 
pen.js:8 forLoopDisplayNone: 20.825ms 

pen.js:8 whileDisplayNone: 19.072ms 
pen.js:8 forLoopDisplayNone: 25.701ms 

pen.js:8 whileDisplayNone: 21.534ms 
pen.js:8 forLoopDisplayNone: 22.570ms 

pen.js:8 whileDisplayNone: 16.339ms 
pen.js:8 forLoopDisplayNone: 21.083ms 

pen.js:8 whileDisplayNone: 16.971ms 
pen.js:8 forLoopDisplayNone: 16.394ms 

pen.js:8 whileDisplayNone: 15.734ms 
pen.js:8 forLoopDisplayNone: 21.363ms 

pen.js:8 whileDisplayNone: 18.682ms 
pen.js:8 forLoopDisplayNone: 18.206ms 

pen.js:8 whileDisplayNone: 19.371ms 
pen.js:8 forLoopDisplayNone: 17.401ms 

pen.js:8 whileDisplayNone: 26.123ms 
pen.js:8 forLoopDisplayNone: 19.004ms 

pen.js:61 cool run 
pen.js:8 whileDisplayNone: 20.315ms 
pen.js:8 forLoopDisplayNone: 17.462ms 

यहांहै

अद्यतन

एक अलग परीक्षण मैं का आयोजन किया है के नीचे स्थित है, जो 2 अलग ढंग से लिखा भाज्य एल्गोरिदम, 1 को लागू करता है अन्य थोड़ी देर के पाश का उपयोग कर, पाश के लिए एक का उपयोग कर।

function runPerfTest() { 
    "use strict"; 

    function perfTest(fn, ns) { 
     console.time(ns); 
     fn(); 
     console.timeEnd(ns); 
    } 

    function whileFactorial(num) { 
     if (num < 0) { 
      return -1; 
     } 
     else if (num === 0) { 
      return 1; 
     } 
     var factl = num; 
     while (num-- > 2) { 
      factl *= num; 
     } 
     return factl; 
    } 

    function forFactorial(num) { 
     var factl = 1; 
     for (var cur = 1; cur <= num; cur++) { 
      factl *= cur; 
     } 
     return factl; 
    } 

    perfTest(function(){ 
     console.log('Result (100000):'+forFactorial(80)); 
    }, 'forFactorial100'); 

    perfTest(function(){ 
     console.log('Result (100000):'+whileFactorial(80)); 
    }, 'whileFactorial100'); 
}; 

(function(){ 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    runPerfTest(); 
    console.log('cold run @1500ms timeout:'); 
    setTimeout(runPerfTest, 1500); 
})(); 

और भाज्य बेंचमार्क के लिए परिणाम:

pen.js:41 Result (100000):7.15694570462638e+118 
pen.js:8 whileFactorial100: 0.280ms 
pen.js:38 Result (100000):7.156945704626378e+118 
pen.js:8 forFactorial100: 0.241ms 
pen.js:41 Result (100000):7.15694570462638e+118 
pen.js:8 whileFactorial100: 0.254ms 
pen.js:38 Result (100000):7.156945704626378e+118 
pen.js:8 forFactorial100: 0.254ms 
pen.js:41 Result (100000):7.15694570462638e+118 
pen.js:8 whileFactorial100: 0.285ms 
pen.js:38 Result (100000):7.156945704626378e+118 
pen.js:8 forFactorial100: 0.294ms 
pen.js:41 Result (100000):7.15694570462638e+118 
pen.js:8 whileFactorial100: 0.181ms 
pen.js:38 Result (100000):7.156945704626378e+118 
pen.js:8 forFactorial100: 0.172ms 
pen.js:41 Result (100000):7.15694570462638e+118 
pen.js:8 whileFactorial100: 0.195ms 
pen.js:38 Result (100000):7.156945704626378e+118 
pen.js:8 forFactorial100: 0.279ms 
pen.js:41 Result (100000):7.15694570462638e+118 
pen.js:8 whileFactorial100: 0.185ms 
pen.js:55 cold run @1500ms timeout: 
pen.js:38 Result (100000):7.156945704626378e+118 
pen.js:8 forFactorial100: 0.404ms 
pen.js:41 Result (100000):7.15694570462638e+118 
pen.js:8 whileFactorial100: 0.314ms 

निष्कर्ष: कोई फर्क नहीं पड़ता नमूने का आकार या विशेष कार्य प्रकार का परीक्षण किया है, वहाँ कोई स्पष्ट विजेता है

यहाँ कोड है थोड़ी देर के बीच और लूप के प्रदर्शन के संदर्भ में। क्रोम सदाबहार पर ओएस एक्स मैवरिक्स के साथ मैकएयर पर परीक्षण किया गया।

Answer 15

के रूप में अनंत लूप पर for(;;) पाश while के बाद से while(1) से बेहतर है हर बार हालत का मूल्यांकन करता है, लेकिन फिर से यह संकलक पर निर्भर करता है।