दिलचस्प पोस्ट
एक्शन बार पर टेक्स्ट कैसे बदल सकता है जावास्क्रिप्ट में ब्रेसेंहम एल्गोरिदम मैं रूट विशेषाधिकारों के बिना पर्ल मॉड्यूल कैसे स्थापित कर सकता हूं? मैं एक 2 डी स्ट्रिंग सरणी कैसे घोषित करूं? RODBC के साथ पैरामीटर्स की गई क्वेरीज़ क्या दस्तावेज़ में कई XML घोषणाएं अच्छी तरह से बनाई गई XML हो सकती हैं? मुख्य थ्रेड UI थ्रेड के समान है? एंड्रॉइड में फ़ोल्डर बनाएं मैं Ubuntu पर OpenSSL पुस्तकालय कैसे स्थापित करूं? पायथन में बाहरी कमांड कॉल करना सूची दृश्य में आइटम को अक्षम कैसे करें? कैसे MySQL विचारों की एक सूची प्राप्त करने के लिए? पार्सलेट योग्य, सामग्री दृश्य या सामग्री प्रविष्टि से अधिसूचना टेक्स्ट निकालें Setuptools / वितरण के साथ पैकेज डेटा को कैसे शामिल किया जाए? Dispatch_async फ़ंक्शन में कमजोर स्वयं का उपयोग करना

JavaScript में सरणी के माध्यम से लूप का सबसे तेज़ तरीका क्या है?

मैंने पुस्तकों से सीखा है कि आपको इस तरह पाश के लिए लिखना चाहिए:

for(var i=0, len=arr.length; i < len; i++){ // blah blah } 

इसलिए arr.length प्रत्येक बार गणना नहीं की जाएगी।

दूसरों का कहना है कि संकलक इस पर कुछ अनुकूलन करेगा, ताकि आप बस लिख सकते हैं:

 for(var i=0; i < arr.length; i++){ // blah blah } 

मैं सिर्फ यह जानना चाहता हूं कि अभ्यास में सबसे अच्छा तरीका क्या है?

Solutions Collecting From Web of "JavaScript में सरणी के माध्यम से लूप का सबसे तेज़ तरीका क्या है?"

अधिकांश आधुनिक ब्राउज़रों के साथ इस परीक्षा के बाद …

http://jsben.ch/#/y3SpC

वर्तमान में , लूप का सबसे तेज़ रूप (और मेरी राय में सबसे ज्यादा वाक्य विन्यास)।

लंबाई कैशिंग के साथ लूप के लिए एक मानक

 for (var i = 0, len = myArray.length; i < len; i++) { } 

मैं कहूंगा कि यह निश्चित रूप से ऐसा मामला है जहां मैं जावास्क्रिप्ट इंजन डेवलपर्स को सराहा करता हूं। एक रन समय को स्पष्टता के लिए अनुकूलित किया जाना चाहिए, चतुराई नहीं है

एक जावास्क्रिप्ट सरणी के माध्यम से लूप के लिए सबसे तेज़ तरीका है:

 var len = arr.length; while (len--) { // blah blah } 

पूर्ण तुलना के लिए http://blogs.oracle.com/greimer/entry/best_way_to_code_a देखें

यदि आदेश महत्वपूर्ण नहीं है, तो मैं यह शैली पसंद करता हूं:

 for(var i = array.length; i--; ) 

यह लंबाई कैश और लिखने के लिए बहुत कम है। लेकिन यह रिवर्स ऑर्डर में सरणी पर फिर से काम करेगा।

2014 While वापस आ गया है

बस तर्कसंगत लगता है

इसे देखो

 for( var index = 0 , length = array.length ; index < length ; index++ ) { //do stuff } 
  1. कम से कम 2 चर (अनुक्रमणिका, लंबाई) बनाने की आवश्यकता है
  2. यह जांचने की आवश्यकता है कि क्या सूचकांक लंबाई से छोटा है
  3. सूचकांक को बढ़ाने की आवश्यकता है
  4. लूप के for 3 पैरामीटर हैं

अब मुझे बताएं कि यह क्यों होना चाहिए:

 var length = array.length; while( --length ) { //or length-- //do stuff } 
  1. एक चर
  2. कोई चेक नहीं
  3. सूचकांक में कमी आई है (मशीनें इसे पसंद करती हैं)
  4. while केवल एक पैरामीटर है

मैं पूरी तरह से उलझन में था जब क्रोम 28 ने दिखाया कि लूप के लिए समय की तुलना में तेज़ है। यह किसी प्रकार का बेन होना चाहिए

"उह, हर कोई लूप का उपयोग कर रहा है, चलो उस पर ध्यान केंद्रित करते हैं जब क्रोम के लिए विकास।"

लेकिन अब 2014 में क्रोम पर लूप वापस आ गया है। यह 2 गुना तेज है, दूसरे / पुराने ब्राउज़रों पर यह हमेशा तेज़ होता है

हाल ही में मैंने कुछ नए परीक्षण किए। अब असली दुनिया में एनोवाइमेंट में उन शॉर्ट कोड के लायक नहीं हैं और जेस्परफ वास्तव में लूप को ठीक से नहीं चला सकते हैं, क्योंकि यह सरणी को पुनः बनाने की आवश्यकता है। लम्बंदी जो समय भी लेता है।

आप jsperf पर थोड़ी देर की लूप की वास्तविक गति नहीं प्राप्त कर सकते हैं।

आपको अपना स्वयं का कस्टम फ़ंक्शन बनाने और window.performance.now() साथ जांचने की आवश्यकता है। window.performance.now()

और हाँ … कोई रास्ता नहीं है जबकि लूप बस तेज़ है।

वास्तव में समस्या वास्तव में डोम हेरफेर / समय प्रदान करने / रेखांकन समय है या फिर आप इसे कॉल करना चाहते हैं।

उदाहरण के लिए मेरे पास एक कैनवस दृश्य है जहां मुझे निर्देशांक और टक्करों की गणना करने की आवश्यकता है … यह 10-200 माइक्रोसेकंड (मिलिसेकंड नहीं) के बीच किया जाता है। यह वास्तव में सब कुछ रेंडर करने के लिए कई मिलीसेकेंड लेता है।

परंतु

कुछ मामलों में loop के लिए एक अन्य सुपर प्रदर्शनकारी तरीका है … उदाहरण के लिए एक सरणी कॉपी / क्लोन करने के लिए

 for( var i = array.length ; i > 0 ; arrayCopy[ --i ] = array[ i ] // doing stuff ); 

मापदंडों की स्थापना पर ध्यान दें:

  1. जबकि लूप में से एक के रूप में मैं केवल एक चर का उपयोग कर रहा हूँ
  2. यह देखने की आवश्यकता है कि सूचकांक 0 से बड़ा है;
  3. जैसा कि आप देख सकते हैं कि इस दृष्टिकोण का उपयोग अलग-अलग बनाम लूप के लिए सामान्य है, जैसा कि मैं 3 वें पैरामीटर में सामान करता हूं और मैं सीधे सरणी के अंदर भी कमी करता हूं।

कहा कि, यह पुष्टि करता है कि जैसे मशीनों –

लिखना है कि मैं इसे थोड़ा कम करने और कुछ बेकार सामान निकालने के लिए सोच रहा था और एक ही शैली का उपयोग कर यह एक लिखा था:

 for( var i = array.length ; i-- ; arrayCopy[ i ] = array[ i ] // doing stuff ); 

यहां तक ​​कि अगर यह छोटा होता है तो i लगता है कि i एक और समय का उपयोग करके सब कुछ धीमा करता i यह लूप के पिछले के मुकाबले 1/5 धीमी और एक while के while है।

नोट:; बिना लोहे के लिए बहुत महत्वपूर्ण है {}

यहां तक ​​कि अगर मैंने आपको यह भी बताया कि जेस्परफ़ स्क्रिप्ट का परीक्षण करने का सबसे अच्छा तरीका नहीं है I

http://jsperf.com/caching-array-length/40

और यहां जावास्क्रिप्ट में प्रदर्शन के बारे में एक और जवाब है

https://stackoverflow.com/a/21353032/2450730

यह जवाब जावास्क्रिप्ट लिखने के प्रदर्शनकारी तरीके दिखाने के लिए है इसलिए यदि आप इसे पढ़ नहीं सकते हैं, तो पूछें और आपको उत्तर मिलेगा या जावास्क्रिप्ट http://www.ecma-international.org/ecma-262/5.1/ के बारे में एक किताब पढ़ी जाएगी ।

जून 2016 तक , नवीनतम क्रोम में कुछ परीक्षण करने (मई 2016 में ब्राउज़र बाजार का 71%, और बढ़ रहा है):

  • सबसे तेज़ लूप एक लूप के लिए है , वास्तव में समान प्रदर्शन प्रदान करने वाले कैशिंग की लंबाई के साथ और बिना दोनों। (कैश की गई लंबाई के साथ लूप के लिए कभी-कभी बिना किसी कैशिंग के बेहतर परिणाम दिए जाते हैं, लेकिन अंतर लगभग नगण्य है, जिसका मतलब है कि इंजन पहले से मानक के पक्ष में अनुकूलित हो सकता है और संभवतः कैशिंग के बिना लूप के लिए सबसे सरल है)।
  • जबकि लूप के साथ लूप लगभग 1.5 गुना लूप के मुकाबले धीमी था।
  • एक कॉलबैक फ़ंक्शन (जैसे ईकाई के लिए मानक) का उपयोग करते हुए एक पाश, लूप के लिए लगभग 10 गुना धीमी थी।

मेरा मानना ​​है कि यह धागा बहुत पुराना है और यह प्रोग्रामर को भ्रमित करने के लिए लगता है कि उन्हें कैश की लंबाई की आवश्यकता होती है, या बेहतर प्रदर्शन प्राप्त करने के लिए कमी के साथ रिवर्स ट्रेवर्सिंग व्हाइल्स का उपयोग करना, लिखित कोड कम स्पष्ट होना और पाश के लिए सरल सरल से त्रुटियों की संभावना है। इसलिए, मैं सुझाता हूं:

  • अगर आपका ऐप बहुत सी मदों पर चलाता है या आपका लूप कोड एक फ़ंक्शन के अंदर होता है जिसका उपयोग अक्सर किया जाता है, तो लूप के लिए एक सीधा जवाब है:

     for (var i = 0; i < arr.length; i++) { // Do stuff with arr[i] or i } 
  • यदि आपका ऐप सचमुच बहुत सारे मदों के माध्यम से फिर से नहीं करता है या आपको यहां और वहां छोटे पुनरावृत्तियों की ज़रूरत है, तो अपने जेड लाइब्रेरी से चुनाव के लिए कुछ कॉलबैक या किसी भी समान फ़ंक्शन का उपयोग करना अधिक समझदार और त्रुटियों से कम हो सकता है, क्योंकि इंडेक्स वैरिएबल गुंजाइश बंद है और आपको ब्रैकेट्स का उपयोग करने की ज़रूरत नहीं है, सरणी मान को सीधे एक्सेस करना:

     arr.forEach(function(value, index) { // Do stuff with value or index }); 
  • यदि आपको वास्तव में अरबों की पंक्तियों और अपने सरणी की लंबाई के चलते कुछ मिलीसेकंड खरोंच करने की आवश्यकता है, तो आप अपने लूप में लंबाई को कैश करने पर विचार कर सकते हैं। हालांकि मुझे लगता है कि यह वास्तव में आजकल जरूरी नहीं है:

     for (var i = 0, len = arr.length; i < len; i++) { // Do stuff with arr[i] } 

http://jsperf.com/caching-array-length/60

परीक्षण का नवीनतम संशोधन, जिसे मैंने तैयार किया (पुराने का उपयोग करके), एक बात दिखाती है

कैशिंग की लंबाई इतना महत्वपूर्ण नहीं है, लेकिन इससे नुकसान नहीं होता है।

ऊपर जोड़े गए परीक्षण के हर पहले भाग (ताजा खोला टैब पर) मेरे डेबियन निचोड़ 64-बिट ( मेरे डेस्कटॉप हार्डवेयर में क्रोम, ओपेरा और फ़ायरफॉक्स में पिछले 4 स्निपेट्स (चार्ट में तीसरे, 5, 7 वें और 10 वें) के लिए अच्छे परिणाम देता है )। बाद के रन काफी अलग परिणाम देते हैं।

प्रदर्शन-वार निष्कर्ष सरल हैं:

  • पाश (आगे) के लिए और साथ में जाओ !==
  • यदि आपको बाद में सरणी का पुन: उपयोग करने की आवश्यकता नहीं है, तो घटते समय की लंबाई और विनाशकारी shift() -िंग एरे पर लूप भी कुशल है

tl; डॉ

आजकल (2011.10) पैटर्न के नीचे सबसे तेज़ लग रहा है

 for (var i = 0, len = arr.length; i !== len; i++) { ... } 

ध्यान दें कि कैशिंग arr.length यहाँ महत्वपूर्ण नहीं है, इसलिए आप बस i !== arr.length लिए परीक्षण कर सकते हैं और प्रदर्शन नहीं i !== arr.length , लेकिन आपको कम कोड मिलेगा।


पुनश्च: मुझे पता है कि shift() साथ स्निपेट में shift() इसका परिणाम 0 वीं तत्व तक पहुंचने के बजाय इस्तेमाल किया जा सकता है, लेकिन मुझे किसी तरह अनदेखी की गई है कि पिछले संशोधन (जो छोरों के दौरान गलत था) का पुन: उपयोग करने के बाद, और बाद में मैं पहले ही प्राप्त नहीं करना चाहता था परिणाम है।

शुद्ध प्रदर्शन के रूप में "सर्वश्रेष्ठ"? या प्रदर्शन और पठनीयता?

शुद्ध प्रदर्शन "सर्वोत्तम" यह है, जो कैश और ++ उपसर्ग ऑपरेटर का उपयोग करता है (मेरा डेटा: http://jsperf.com/caching-array-length/189 )

 for (var i = 0, len = myArray.length; i < len; ++i) { // blah blah } 

मैं तर्क दूंगा कि कैश-कम फॉर-लूप निष्पादन समय और प्रोग्रामर रीडिंग टाइम में सबसे अच्छा बैलेंस है I सी / सी ++ / जावा से शुरू होने वाले हर प्रोग्रामर ने एमएस को इस एक के माध्यम से पढ़ने के लिए बर्बाद नहीं किया होगा

 for(var i=0; i < arr.length; i++){ // blah blah } 

** लूप के अंदर सरणी की लंबाई को कैश करें, कुछ सेकंड का समय न मिलेगा। सरणी में मदों पर निर्भर करता है कि अगर अधिक मदों में सरणी हैं तो समय के एमएस के संबंध में बड़ा अंतर है *

**

 sArr; //Array[158]; for(var i = 0 ; i <sArr.length ; i++) { callArray(sArr[i]); //function call } ***end: 6.875ms*** 

**

**

 sArr; //Array[158]; for(var i = 0,len = sArr.length ; i < len ; i++) { callArray(sArr[i]); //function call } ***end: 1.354ms*** 

**

यह अब तक का सबसे तेज़ तरीका है …

 var el; while (el = arr.shift()) { el *= 2; } 

इस बात पर ध्यान दें कि यह सरणी का सेवन करेगा, खायेगा, और कुछ भी नहीं छोड़ेगी …

मैं हमेशा पहली शैली में लिखता हूं

यहां तक ​​कि अगर कोई कंपाइलर ऐरे के लिए इसे अनुकूलित करने के लिए पर्याप्त स्मार्ट है, लेकिन फिर भी यह स्मार्ट है अगर हम यहां डोमनेलोड या कुछ जटिल ऑब्जेक्ट को गणना लंबाई के साथ प्रयोग कर रहे हैं?

मुझे पता है कि सवाल एरे के बारे में क्या है, लेकिन मुझे लगता है कि यह एक शैली में आपके सभी छोरों को लिखने का एक अच्छा अभ्यास है।

यह वर्ष 2017 है

मैंने कुछ परीक्षण किए

https://jsperf.com/fastest-way-to-iterate-through-an-array/

ऐसा लगता है कि while क्रोम पर सबसे तेज़ तरीका है

लगता है कि बाएं कमी ( --i ) फ़ायरफ़ॉक्स पर दूसरों ( ++i , i++ , i++ ) की तुलना में बहुत तेज है।

यह दृष्टिकोण औसत पर उपवास है लेकिन यह उलट क्रम में सरणी को पुनरावृत्त करता है

 let i = array.length; while (--i >= 0) { doSomething(array[i]); } 

यदि अग्रिम आदेश महत्वपूर्ण है, तो इस दृष्टिकोण का उपयोग करें

 let ii = array.length; let i = 0; while (i < ii) { doSomething(array[i]); ++i; } 
 var arr = []; // The array var i = 0; while (i < arr.length) { // Do something with arr[i] i++; } 

i ++ ++ i, -i और i से अधिक तेज है I

इसके अलावा, आप आखिरी बार को एआरआर [i ++] को पिछली बार सहेज सकते हैं, जब तक मैं आपको एक्सेस करने की ज़रूरत होगी (लेकिन यह डिबग करना मुश्किल हो सकता है)।

आप इसे यहां जांच सकते हैं (अन्य पाश परीक्षणों के साथ): http://jsperf.com/for-vs-whilepop/5

मुझे पता है कि सबसे खूबसूरत समाधान मानचित्र का उपयोग कर रहा है।

 var arr = [1,2,3]; arr.map(function(input){console.log(input);}); 

मैंने एक विशाल सरणी को पुनरावृत्त करने के लिए कुछ अन्य तरीकों की कोशिश की है और पता चला है कि सरणी की लंबाई को कम करना और फिर एक ही लूप में दोनों हिस्सों को फिर से चलाना तेजी से होता है इस प्रदर्शन में अंतर देखा जा सकता है, जबकि विशाल सरणियों का प्रसंस्करण।

 var firstHalfLen =0; var secondHalfLen = 0; var count2=0; var searchterm = "face"; var halfLen = arrayLength/2; if(arrayLength%2==halfLen) { firstHalfLen = Math.ceil(halfLen); secondHalfLen=Math.floor(halfLen); } else { firstHalfLen=halfLen; secondHalfLen=halfLen; } for(var firstHalfCOunter=0,secondHalfCounter = arrayLength-secondHalfLen; firstHalfCOunter < firstHalfLen; firstHalfCOunter++) { if(mainArray[firstHalfCOunter].search(new RegExp(searchterm, "i"))> -1) { count2+=1; } if(secondHalfCounter < arrayLength) { if(mainArray[secondHalfCounter].search(new RegExp(searchterm, "i"))> -1) { count2+=1; } secondHalfCounter++; } } 

उपर्युक्त विधि के लिए कैश की गई लम्बाई के लिए लूप के बीच कुछ प्रदर्शन तुलना (टाइमर.जेएस का उपयोग करते हुए)।

http://jsfiddle.net/tejzpr/bbLgzxgo/

एक अन्य jsperf.com परीक्षण: http://jsperf.com/while-reverse-vs-for-cached-length

लूप करते समय रिवर्स सबसे तेज़ हो रहा है केवल समस्या यह है कि (-i) 0 पर बंद हो जाएगा। मैं अपने पाश में सरणी [0] तक कैसे पहुंच सकता हूं?

सितंबर 2017 तक इन जेएसपीएफ परीक्षण क्रोम 60 पर सबसे ज्यादा प्रदर्शन करने वाला निम्नलिखित पैटर्न दिखा रहे हैं:

 function foo(x) { x; }; arr.forEach(foo); 

क्या कोई भी पुन: उत्पन्न कर सकता है?

एक मूल जबकि लूप अक्सर सबसे तेज़ होता है इन प्रकार की अवधारणाओं का परीक्षण करने के लिए jsperf.com एक महान सैंडबॉक्स है

https://jsperf.com/fastest-array-loops-in-javascript/24