एक लूप के लिए <या <= का उपयोग करना चाहिए [बंद]

124

यदि आपको 7 बार लूप के माध्यम से पुनरावृत्त करना पड़ा, तो क्या आप उपयोग करेंगे:

for (int i = 0; i < 7; i++)

या:

for (int i = 0; i <= 6; i++)

दो विचार हैं:

  • प्रदर्शन
  • पठनीयता

प्रदर्शन के लिए मैं जावा या सी # मान रहा हूं। क्या यह मायने रखता है कि "से कम" या "से कम या बराबर" का उपयोग किया जाता है? यदि आपके पास एक अलग भाषा के लिए अंतर्दृष्टि है, तो कृपया संकेत दें कि कौन सा है।

पठनीयता के लिए मैं 0-आधारित सरणियाँ मान रहा हूँ।

UPD: 0-आधारित सरणियों के मेरे उल्लेख में उलझन भरी बातें हो सकती हैं। मैं सरणी तत्वों के माध्यम से पुनरावृत्ति के बारे में बात नहीं कर रहा हूँ। बस एक सामान्य लूप।

एक निरंतर का उपयोग करने के बारे में नीचे एक अच्छा बिंदु है जो यह बताता है कि यह जादू नंबर क्या है। इसलिए अगर मेरे पास " int NUMBER_OF_THINGS = 7" " i <= NUMBER_OF_THINGS - 1" होता तो अजीब लगता, नहीं।

performance  conventions  readability 
— यूजीन काट्ज़
स्रोत
मैं कहूंगा: यदि आप पूरे ऐरे से चलते हैं, तो कभी भी बाईं ओर किसी भी संख्या को घटाएं या जोड़ें नहीं।
— लेटरमैन

जवाबों:

287

पहला अधिक मुहावरेदार है । विशेष रूप से, यह इंगित करता है (0-आधारित अर्थ में) पुनरावृत्तियों की संख्या। 1-आधारित (जैसे JDBC, IIRC) का उपयोग करते समय मुझे <= का उपयोग करने के लिए लुभाया जा सकता है। इसलिए:

for (int i=0; i < count; i++) // For 0-based APIs

for (int i=1; i <= count; i++) // For 1-based APIs

मुझे उम्मीद है कि वास्तविक विश्व कोड में प्रदर्शन का अंतर बहुत कम होगा।

— जॉन स्कीट
स्रोत
30
आपको लगभग गारंटी है कि प्रदर्शन अंतर नहीं होगा। कई आर्किटेक्चर, x86 की तरह, "पिछली तुलना में कम या बराबर पर कूदते हैं" निर्देश। सबसे अधिक संभावना है कि आप एक प्रदर्शन अंतर देखेंगे जो किसी तरह की व्याख्या की गई भाषा में होगा जिसे खराब तरीके से लागू किया गया था।
— वेज
3
क्या आप इसके बजाय = का उपयोग करने पर विचार करेंगे? मैं कहूंगा कि सबसे स्पष्ट रूप से मैं पाश काउंटर के रूप में स्थापित करता हूं और कुछ नहीं।
— युंगचिन
21
मैं आमतौर पर नहीं होता। यह अभी बहुत अपरिचित है। यह बहुत जोखिम में है, बहुत लंबा लूप यदि कोई गलती से लूप के दौरान बढ़ जाता है।
— जॉन स्कीट
5
एसटीएल पुनरावृत्तियों के साथ सामान्य प्रोग्रामिंग! = का उपयोग अनिवार्य करता है। यह (आकस्मिक दोहरा वेतन वृद्धि) मेरे लिए कोई समस्या नहीं है। मैं इस बात से सहमत हूं कि सूचकांकों के लिए <(या> अवरोही के लिए) अधिक स्पष्ट और पारंपरिक हैं।
— जोनाथन ग्रेहल
2
याद रखें, यदि आप <का उपयोग करके किसी सरणी की लंबाई पर लूप करते हैं, तो JIT सरणी एक्सेस (बाउंड चेक हटाता है) का अनुकूलन करता है। तो यह तेज होना चाहिए कि <= का उपयोग कर। मैंने इसकी जाँच नहीं की है
— विन्यासकर्ता
72

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

— स्टीव लश
स्रोत
मुझे याद है जब मैंने पहली बार जावा सीखना शुरू किया था। मुझे 0-आधारित इंडेक्स की अवधारणा से नफरत है क्योंकि मैंने हमेशा 1-आधारित इंडेक्स का उपयोग किया है। इसलिए मैं हमेशा <= 6 वेरिएंट (जैसा कि प्रश्न में दिखाया गया है) का उपयोग करूंगा। अपने स्वयं के प्रतिवाद के लिए, क्योंकि यह मुझे और अधिक भ्रमित करेगा जब लूप वास्तव में बाहर निकलता है। यह सिर्फ 21 <
— जेम्स Haug
55

मुझे अपने उन दिनों से याद है जब हमने कॉलेज में 8086 विधानसभा की थी, ऐसा करने के लिए और अधिक प्रदर्शन किया था:

for (int i = 6; i > -1; i--)

जैसा कि वहाँ था JNS ऑपरेशन था जिसका मतलब है कि जंप अगर नो साइन। इसका उपयोग करने का मतलब यह था कि तुलना मूल्य प्राप्त करने के लिए प्रत्येक चक्र के बाद कोई मेमोरी लुकअप नहीं था और इसकी तुलना भी नहीं थी। इन दिनों अधिकांश कंपाइलर रजिस्टर उपयोग का अनुकूलन करते हैं, इसलिए मेमोरी चीज़ अब महत्वपूर्ण नहीं है, लेकिन आपको अभी भी एक गैर-आवश्यक तुलना मिलती है।

वैसे अपने पाश में 7 या 6 डालने से एक " जादू नंबर " शुरू हो रहा है। बेहतर पठनीयता के लिए आपको एक इरादे का खुलासा नाम के साथ एक निरंतर का उपयोग करना चाहिए। ऐशे ही:

const int NUMBER_OF_CARS = 7;
for (int i = 0; i < NUMBER_OF_CARS; i++)

संपादित करें: लोगों को विधानसभा की चीज़ नहीं मिल रही है इसलिए पूरी तरह से उदाहरण की आवश्यकता है:

यदि हम ऐसा करते हैं (i = 0; मैं <= 10; i ++) आपको यह करने की आवश्यकता है:

    mov esi, 0
loopStartLabel:
                ; Do some stuff
    inc esi
                ; Note cmp command on next line
    cmp esi, 10
    jle exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

अगर हम करते हैं (int i = 10; i> -1; i--) तो आप इससे दूर हो सकते हैं:

    mov esi, 10
loopStartLabel:
                ; Do some stuff
    dec esi
                ; Note no cmp command on next line
    jns exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

मैंने अभी-अभी जाँच की है और Microsoft का C ++ कंपाइलर यह अनुकूलन नहीं करता है, लेकिन यदि आप ऐसा करते हैं:

for (int i = 10; i >= 0; i--)

तो नैतिक है अगर आप Microsoft C ++ Microsoft का उपयोग कर रहे हैं, और आरोही या अवरोही को कोई फर्क नहीं पड़ता है, तो एक त्वरित लूप प्राप्त करने के लिए जिसे आपको उपयोग करना चाहिए:

for (int i = 10; i >= 0; i--)

इन दोनों के बजाय:

for (int i = 10; i > -1; i--)
for (int i = 0; i <= 10; i++)

लेकिन स्पष्ट रूप से "for (int i = 0; i <= 10; i ++)" की पठनीयता आमतौर पर एक प्रोसेसर कमांड को याद करने से कहीं अधिक महत्वपूर्ण है।

† अन्य संकलक अलग-अलग काम कर सकते हैं।

— चलता है
स्रोत
4
"मैजिक नंबर" मामला अच्छी तरह से दिखाता है, क्यों आमतौर पर <= की तुलना में इसका उपयोग करना बेहतर है।
— रेने सारसो
11
एक और संस्करण "के लिए है (int i = 10; i--;)"। कुछ लोग "के लिए" (int i = 10; i -> 0;) का उपयोग करते हैं और दिखावा करते हैं कि संयोजन -> का अर्थ है।
— ज़ेनज़
2
विधानसभा कोड के लिए +1
— न्यूरो
1
लेकिन जब समय वास्तव में लूप काउंटर का उपयोग करने के लिए आता है, उदाहरण के लिए सरणी अनुक्रमण के लिए, तो आपको ऐसा करने की आवश्यकता है 7-iजो आपको पीछे की गिनती से मिलने वाली किसी भी अनुकूलन को स्वाहा करने जा रहा है।
— रयान
@ ठीक है, यह केवल तभी लागू होता है जब आपको वस्तुओं को आगे के क्रम में संसाधित करने की आवश्यकता होती है। इस तरह के लूप में अधिकांश संचालन के साथ आप उन्हें किसी भी क्रम में लूप में आइटम पर लागू कर सकते हैं। उदाहरण के लिए यदि आप एक मूल्य खोज रहे हैं तो इससे कोई फर्क नहीं पड़ता कि क्या आप सूची के अंत में शुरू करते हैं और सूची के शुरू होने पर या काम करते हैं और नीचे काम करते हैं (यह मानते हुए कि आप अनुमान नहीं लगा सकते हैं कि सूची आपके आइटम के किस छोर पर है होने की संभावना है और स्मृति कैशिंग एक मुद्दा नहीं है)।
— मार्टिन ब्राउन
27

मैं हमेशा <array.length का उपयोग करता हूं क्योंकि यह <= array.length-1 की तुलना में पढ़ना आसान है।

यह भी <7 होने और यह देखते हुए कि आप जानते हैं कि यह 0 इंडेक्स से शुरू हो रहा है, यह सहज होना चाहिए कि संख्या पुनरावृत्तियों की संख्या है।

— उमर कोहेजी
स्रोत
लूप में उनका उपयोग करते समय आपको लंबाई कार्यों की लागत की जांच करने के लिए हमेशा सावधान रहना चाहिए। उदाहरण के लिए यदि आप C / C ++ में स्ट्रैलेन का उपयोग करते हैं, तो आप तुलनात्मक रूप से उस समय को बढ़ाते जा रहे हैं जिसमें समय लगता है। इसका कारण यह है कि strlen को अपने उत्तर को खोजने के लिए पूरे स्ट्रिंग को पुनरावृत्त करना पड़ता है, जो कि आप अपने पाश के हर पुनरावृत्ति के बजाय केवल एक बार करना चाहते हैं।
— मार्टिन ब्राउन
2
@ मार्टिन ब्राउन: जावा में (और मेरा मानना ​​है कि C #), String.length और Array.length स्थिर है क्योंकि स्ट्रिंग अपरिवर्तनीय है और Array की अपरिवर्तनीय-लंबाई है। और चूंकि String.length और Array.length एक क्षेत्र है (एक फ़ंक्शन कॉल के बजाय), आप सुनिश्चित कर सकते हैं कि उन्हें O (1) होना चाहिए। सी ++ के मामले में, ठीक है, आप पहले स्थान पर सी-स्ट्रिंग का उपयोग क्यों कर रहे हैं?
— रयान
18

एक अनुकूलन दृष्टिकोण से देखा गया यह कोई फर्क नहीं पड़ता।

एक कोड शैली के दृष्टिकोण से देखा जाता है जिसे मैं पसंद करता हूं <। कारण:

for ( int i = 0; i < array.size(); i++ )

की तुलना में बहुत अधिक पठनीय है

for ( int i = 0; i <= array.size() -1; i++ )

भी <आप सीधे पुनरावृत्तियों की संख्या देता है।

<के लिए एक और वोट यह है कि आप बहुत सी आकस्मिक गलती को रोक सकते हैं।

— erlando
स्रोत
10

@ क्रिस, आपका कथन। .NET के बारे में महंगा होना वास्तव में असत्य है और सरल प्रकारों के मामले में सटीक विपरीत है।

int len = somearray.Length;
for(i = 0; i < len; i++)
{
  somearray[i].something();
}

वास्तव में की तुलना में धीमी है

for(i = 0; i < somearray.Length; i++)
{
  somearray[i].something();
}

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

— जेफ मैक
स्रोत
Java में .Length किसी मामले में महंगी पड़ सकती है। stackoverflow.com/questions/6093537/for-loop-optimization b'coz इसे .lenghtOR को कॉल करता है .size। मैं निश्चित नहीं हूं लेकिन आश्वस्त नहीं हूं लेकिन केवल सुनिश्चित करना चाहता हूं।
— रवि पारेख
6

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

— फिल राइट
स्रोत
5

मैं पसंद करता हूं:

for (int i = 0; i < 7; i++)

मुझे लगता है कि "लूप के माध्यम से 7 बार पुनरावृत्ति" करने के लिए अधिक आसानी से अनुवाद करता है।

मुझे प्रदर्शन के निहितार्थ के बारे में निश्चित नहीं है - मुझे संदेह है कि कोई भी मतभेद दूर हो जाएगा।

— डोमिनिक रॉजर
स्रोत
4

जावा 1.5 में आप बस कर सकते हैं

for (int i: myArray) {
    ...
}

तो सरणी मामले के लिए आपको चिंता करने की आवश्यकता नहीं है।

— JesperE
स्रोत
4

मुझे नहीं लगता कि प्रदर्शन में कोई अंतर है। दूसरा रूप निश्चित रूप से अधिक पठनीय है, हालांकि, आपको अंतिम पुनरावृत्ति संख्या खोजने के लिए मानसिक रूप से घटाना नहीं है।

संपादित करें: मैं दूसरों को असहमत देखता हूं। मेरे लिए व्यक्तिगत रूप से, मैं लूप संरचना में वास्तविक सूचकांक संख्याओं को देखना पसंद करता हूं। शायद यह इसलिए है क्योंकि यह पर्ल के 0..6सिंटैक्स की अधिक याद दिलाता है , जो मुझे पता है कि इसके बराबर है (0,1,2,3,4,5,6)। यदि मुझे 7 दिखाई देता है, तो मुझे उसके बाद के ऑपरेटर को देखना होगा कि वास्तव में, सूचकांक 7 कभी नहीं पहुंचा है।

— एडम बेलेयर
स्रोत
यह निर्भर करता है कि क्या आपको लगता है कि "अंतिम पुनरावृति संख्या" "पुनरावृत्तियों की संख्या" से अधिक महत्वपूर्ण है। 0-आधारित एपीआई के साथ, वे हमेशा 1 से अलग होंगे ...
— जॉन स्कीट
4

मैं कहूंगा कि "<7" संस्करण का उपयोग करें क्योंकि यही वह है जो अधिकांश लोग पढ़ेंगे - इसलिए यदि लोग आपके कोड को पढ़ रहे हैं, तो वे इसे गलत तरीके से व्याख्या कर सकते हैं।

मुझे इस बात की चिंता नहीं होगी कि "<" "<=" की तुलना में तेज है, बस पठनीयता के लिए जाएं।

यदि आप गति में वृद्धि के लिए जाना चाहते हैं, तो निम्नलिखित पर विचार करें:

for (int i = 0; i < this->GetCount(); i++)
{
  // Do something
}

प्रदर्शन बढ़ाने के लिए आप इसे थोड़ा पुनर्व्यवस्थित कर सकते हैं:

const int count = this->GetCount();
for (int i = 0; i < count; ++i)
{
  // Do something
}

लूप से GetCount () हटाने की सूचना दें (क्योंकि यह हर लूप में क्वेर किया जाएगा) और "i ++" का "++ i" में परिवर्तन।

— मार्क इनग्राम
स्रोत
मुझे दूसरा सबसे अच्छा लगता है क्योंकि यह पढ़ना आसान है लेकिन क्या यह वास्तव में इस-> GetCount () हर बार पुनर्गणना करता है? मैंने इसे बदलते समय पकड़ा है और यह गिनती मुझे ऐसा करने के लिए मजबूर करने के लिए बनी हुई है..इस तरह-> GetCount ()
— osp70
पहले उदाहरण में GetCount () को हर पुनरावृत्ति कहा जाएगा। इसे केवल दूसरे उदाहरण में एक बार कहा जाएगा। अगर आपको गेटकाउंट () की जरूरत है, तो हर बार इसे लूप में रखें, अगर आप इसे बाहर रखने की कोशिश नहीं करते हैं।
— मार्क इनग्राम
हां, मैंने इसे आजमाया है और आप सही हैं, मेरी क्षमायाचना।
— osp70।
++ i से i ++ का उपयोग करने पर क्या फर्क पड़ता है?
— रेने सारसो
किलों का उपयोग करते समय मामूली गति में वृद्धि होती है, लेकिन यदि आप अपनी कक्षाओं में वृद्धि कर रहे हैं तो वृद्धि बड़ी हो सकती है। मूल रूप से ++ मैं वास्तविक मूल्य बढ़ाता है, फिर वास्तविक मूल्य लौटाता है। i ++ एक अस्थायी संस्करण बनाता है, वास्तविक संस्करण बढ़ाता है, फिर अस्थायी देता है। ++ i के साथ कोई var निर्माण आवश्यक नहीं है।
— मार्क इनग्राम
4

सी ++ में, मैं उपयोग करना पसंद करता हूं !=, जो सभी एसटीएल कंटेनरों के साथ उपयोग करने योग्य है। सभी एसटीएल कंटेनर पुनरावृत्तियों तुलनात्मक से कम नहीं हैं।

— madmoose
स्रोत
यह मुझे थोड़ा डराता है क्योंकि बहुत कम मौका है कि कुछ मेरे इच्छित मूल्य पर काउंटर को पुन: व्यवस्थित कर सकता है जो फिर इसे एक अनंत लूप बनाता है। संभावना दूरस्थ हैं और आसानी से पता लगाया जा सकता है - लेकिन < सुरक्षित लगता है।
— रोब एलन
2
अगर आपके कोड में ऐसा कोई बग है, तो संभवतः दुर्घटनाग्रस्त होने और जलने से बेहतर है कि चुपचाप जारी रहें :-)
यह सही उत्तर है: यह आपके पुनरावृत्त पर कम मांग डालता है और यदि आपके कोड में कोई त्रुटि है तो यह दिखाने की अधिक संभावना है। <के लिए तर्क अदूरदर्शी है। हो सकता है कि 70 के दशक में जब आप सीपीयू समय के लिए भुगतान कर रहे थे, तब एक अनंत लूप खराब होगा। '! =' में बग छिपाने की संभावना कम होती है।
— डेविड नेहमे
1
पुनरावृत्तियों पर लूपिंग एक काउंटर के साथ लूपिंग से एक पूरी तरह से अलग मामला है। ! = पुनरावृत्तियों के लिए आवश्यक है।
— डीजेकवरवर्थ
4

१ ९ where२ में आइड्सर डेज्क्ट्रा ने इस पीठ पर एक लेख लिखा, जिसमें उन्होंने कहा कि कम <= i <ऊपरी के लिए तर्क दें:

सबसे छोटी प्राकृतिक संख्या है। निम्न बाउंड-ब का बहिष्करण b) और d) - अप्राकृतिक संख्याओं के दायरे में उल्लिखित सबसे छोटी प्राकृतिक संख्या कम बाउंड पर शुरू होने वाली परवर्ती के लिए मजबूर करता है। यह बदसूरत है, इसलिए निचली सीमा के लिए हम a को a) और c) पसंद करते हैं। अब सबसे छोटी प्राकृतिक संख्या पर शुरू होने वाले पर विचार करें: ऊपरी बाउंड को शामिल करना तब बाद के समय को अप्राकृतिक होने के लिए मजबूर कर देगा, जब तक अनुक्रम खाली न हो जाए। यह बदसूरत है, इसलिए ऊपरी सीमा के लिए हम पसंद करते हैं <जैसा कि ए) और डी)। हम निष्कर्ष निकालते हैं कि सम्मेलन a) को प्राथमिकता दी जानी है।

— Martijn
स्रोत
3

सबसे पहले, 6 या 7 का उपयोग न करें।

उपयोग करने के लिए बेहतर:

int numberOfDays = 7;
for (int day = 0; day < numberOfDays ; day++){

}

इस मामले में यह उपयोग करने से बेहतर है

for (int day = 0; day <= numberOfDays  - 1; day++){

}

इससे भी बेहतर (Java / C #):

for(int day = 0; day < dayArray.Length; i++){

}

और भी बेहतर (सी #)

foreach (int day in days){// day : days in Java

}

रिवर्स लूप वास्तव में तेज़ है, लेकिन चूंकि इसे पढ़ना मुश्किल है (यदि आपके द्वारा अन्य प्रोग्रामर द्वारा नहीं), तो इससे बचना बेहतर है। विशेष रूप से सी #, जावा में ...

— कैर्रा
स्रोत
2

मैं यह कहते हुए भीड़ से सहमत हूं कि 7 इस मामले में समझ में आता है, लेकिन मैं यह जोड़ूंगा कि मामले में जहां 6 महत्वपूर्ण है, कहते हैं कि आप स्पष्ट करना चाहते हैं कि आप केवल 6 वीं सूचकांक तक की वस्तुओं पर काम कर रहे हैं, फिर <= बेहतर है क्योंकि यह देखने में 6 आसान बनाता है।

— tloach
स्रोत
इसलिए, मैं <आकार की तुलना में <= LAST_FILLED_ARRAY_SLOT
— क्रिस
2

कॉलेज में वापस आते समय, मुझे सीपीयू पर गणना समय में समान होने वाले इन दो ऑपरेशनों के बारे में कुछ याद है। बेशक, हम विधानसभा स्तर पर बात कर रहे हैं।

हालाँकि, अगर आप C # या Java की बात कर रहे हैं, तो मुझे नहीं लगता कि कोई दूसरे पर गति बढ़ाने वाला है, आपके द्वारा प्राप्त किए जाने वाले कुछ नैनोसेकंड आपके द्वारा पेश किए जाने वाले किसी भ्रम के लायक नहीं हैं।

व्यक्तिगत रूप से, मैं उस कोड को लिखूंगा जो एक व्यवसाय कार्यान्वयन दृष्टिकोण से समझ में आता है, और सुनिश्चित करें कि यह पढ़ना आसान है।

— casademora
स्रोत
2

यह सीधे "मेकिंग गलत कोड लुक गलत" की श्रेणी में आता है ।

शून्य-आधारित अनुक्रमण भाषाओं में, जैसे कि जावा या सी # लोग पर भिन्नता के आदी हैं index < count हालत हैं। इस प्रकार, इस डिफैक्टो सम्मेलन का लाभ उठाने से एक-एक त्रुटियां अधिक स्पष्ट हो जाएंगी।

प्रदर्शन के बारे में: इसके मेमोरी फुटप्रिंट के लायक कोई भी अच्छा संकलक इस तरह के गैर-मुद्दे के रूप में प्रस्तुत करना चाहिए।

— रेयान डेलूची
स्रोत
2

एक तरफ के रूप में, जब एक सरणी या .Net में अन्य संग्रह के माध्यम से पाशन, मुझे लगता है

foreach (string item in myarray)
{
    System.Console.WriteLine(item);
}

लूप के लिए संख्यात्मक की तुलना में अधिक पठनीय होना। यह निश्चित रूप से मानता है कि वास्तविक काउंटर Int ही लूप कोड में उपयोग नहीं किया जाता है। मुझे नहीं पता कि प्रदर्शन में कोई बदलाव है या नहीं।

— रोब एलन
स्रोत
इसके लिए यह भी आवश्यक है कि आप लूप के दौरान संग्रह का आकार संशोधित न करें।
— जेफ बी
तो फॉर (i = 0, i <myarray.count, i ++)
— रोब एलन
1

I <7 लिखने के कई अच्छे कारण हैं। लूप में संख्या 7 होने से जो 7 बार पुनरावृत्त करता है वह अच्छा है। प्रदर्शन प्रभावी रूप से समान है। लगभग हर कोई i <7 लिखता है। यदि आप पठनीयता के लिए लिख रहे हैं, तो उस फॉर्म का उपयोग करें जिसे हर कोई तुरंत पहचान लेगा।

— DJClayworth
स्रोत
1

मैंने हमेशा पसंद किया है:

for ( int count = 7 ; count > 0 ; -- count )
— केनी
स्रोत
आपका औचित्य क्या है? मुझे सही मायने में दिलचस्पी है।
— क्रिस कूडमोर
रिवर्स लूपिंग के लिए यह पूरी तरह से ठीक है .. अगर आपको कभी ऐसी चीज की जरूरत है
— शूलेस ऑक्ट
1
एक कारण uP स्तर पर 0 की तुलना में तेज है। एक और यह है कि यह मेरे लिए अच्छी तरह से पढ़ता है और गिनती मुझे एक आसान संकेत देती है कि कितने और समय बाकी हैं।
— केनी
1

उपयोग की आदत बनाना <यह आपको और पाठक दोनों के लिए सुसंगत बना देगा जब आप किसी सरणी के माध्यम से पुनरावृत्ति कर रहे हैं। मानक सम्मेलन करना सभी के लिए सरल होगा। और यदि आप 0-आधारित सरणियों के साथ भाषा का उपयोग कर रहे हैं, तो <कन्वेंशन है।

यह लगभग निश्चित रूप से <और <= के बीच किसी भी प्रदर्शन अंतर से अधिक मायने रखता है। पहले कार्यक्षमता और पठनीयता के लिए लक्ष्य, फिर अनुकूलन करें।

एक और नोट यह है कि I ++ के बजाय ++ i करने की आदत में रहना बेहतर होगा, क्योंकि भ्रूण और वेतन वृद्धि के लिए अस्थायी और वेतन वृद्धि की आवश्यकता होती है और भ्रूण नहीं होता है। पूर्णांक के लिए, आपका कंपाइलर शायद अस्थायी रूप से दूर का अनुकूलन करेगा, लेकिन यदि आपका पुनरावृत्ति प्रकार अधिक जटिल है, तो यह सक्षम नहीं हो सकता है।

— JohnMcG
स्रोत
1

जादू नंबर का उपयोग न करें।

यह 7 क्यों है? (या उस मामले के लिए 6)।

जिस संख्या का आप उपयोग करना चाहते हैं, उसके लिए सही प्रतीक का उपयोग करें ...

जिस स्थिति में मुझे लगता है कि इसका उपयोग करना बेहतर है

for ( int i = 0; i < array.size(); i++ )
— Krakkos
स्रोत
1

'<' और '<=' ऑपरेटर बिल्कुल समान प्रदर्शन लागत हैं।

'<' ऑपरेटर शून्य-आधारित लूप में पढ़ने के लिए एक मानक और आसान है।

I ++ के बजाय ++ i का उपयोग C ++ में प्रदर्शन में सुधार करता है, लेकिन C # में नहीं - मुझे जावा के बारे में नहीं पता है।

— जेफ बी
स्रोत
1

जैसा कि लोगों ने देखा है, आपके द्वारा बताए गए दोनों विकल्पों में से किसी में कोई अंतर नहीं है। बस इसकी पुष्टि करने के लिए, मैंने जावास्क्रिप्ट में कुछ सरल बेंचमार्किंग की।

आप यहां परिणाम देख सकते हैं । इससे जो स्पष्ट नहीं है वह यह है कि अगर मैं 1 और 2 के परीक्षण की स्थिति को स्वैप करता हूं, तो उन 2 परीक्षणों के परिणाम स्वैप होते हैं, यह स्पष्ट रूप से एक मेमोरी मुद्दा है। हालाँकि तीसरा परीक्षण, एक जहाँ मैं पुनरावृत्ति के क्रम को स्पष्ट रूप से तेज करता हूं।

— डेविड वेस
स्रोत
आप दूसरे मामले में i = 1 से क्यों शुरू करते हैं?
— यूजीन काट्ज
ह्म्म्म, शायद एक मूर्खतापूर्ण गलती? मैं इसे बहुत जल्दी मार दिया, शायद 15 मिनट।
— डेविड वीस
1

जैसा कि सभी कहते हैं, यह 0-अनुक्रमित पुनरावृत्तियों का उपयोग सरणियों से बाहर की चीजों के लिए भी करने के लिए प्रथागत है। यदि सब कुछ शुरू होता है 0और समाप्त होता है n-1, और निचले-सीमा हमेशा होते हैं <=और ऊपरी सीमा हमेशा होती है <, तो कोड की समीक्षा करते समय बहुत कम सोच होती है जो आपको करना पड़ता है।

— ephemient
स्रोत
1

बड़ा सवाल है। मेरा उत्तर: टाइप ए ('<') का उपयोग करें

  • आप स्पष्ट रूप से देखें कि आपके पास कितने पुनरावृत्तियाँ हैं (7)।
  • दो समापन बिंदुओं के बीच का अंतर सीमा की चौड़ाई है
  • कम पात्र इसे अधिक पठनीय बनाते हैं
  • आपके पास अक्सर अंतिम तत्वi < strlen(s) के सूचकांक के बजाय तत्वों की कुल संख्या होती है इसलिए एकरूपता महत्वपूर्ण है।

एक और समस्या इस पूरे निर्माण के साथ है। iइसमें 3 बार दिखाई देता है, इसलिए इसे गलत माना जा सकता है। फॉर-लूप निर्माण कहता है कि कैसे करना है इसके बजाय क्या करना है । मैं इसे अपनाने का सुझाव देता हूं:

BOOST_FOREACH(i, IntegerInterval(0,7))

यह अधिक स्पष्ट है, एक ही asm निर्देश आदि को समाप्त करने के लिए संकलित करता है, आदि मुझे इंटेगरइंटरवल के कोड के लिए पूछें यदि आप इसे पसंद करते हैं।

— पावेल रेड्ज़विलोव्स्की
स्रोत
1

इतने सारे उत्तर ... लेकिन मेरा मानना ​​है कि मुझे कुछ जोड़ना है।

मेरी प्राथमिकता शाब्दिक संख्याओं को स्पष्ट रूप से यह दिखाने के लिए है कि "i" क्या मूल्यों को लूप में ले जाएगा । एक शून्य आधारित सरणी हालांकि पुनरावृति के मामले में:

for (int i = 0; i <= array.Length - 1; ++i)

और अगर आप सिर्फ लूपिंग कर रहे हैं, तो एक सरणी के माध्यम से पुनरावृत्ति नहीं, 1 से 7 तक की गिनती बहुत सहज है:

for (int i = 1; i <= 7; ++i)

जब तक आप इसे प्रोफाइल नहीं करते हैं, तब तक रीडायबिलिटी ट्रंप का प्रदर्शन होता है, क्योंकि आपको शायद पता नहीं होता है कि कंपाइलर या रनटाइम तब तक आपके कोड के साथ क्या करने वाला है।

— निक वेस्टगेट
स्रोत
1

तुम भी !=बजाय उपयोग कर सकते हैं । इस तरह, आपको एक अनंत लूप मिलेगा यदि आप आरंभीकरण में कोई त्रुटि करते हैं, जिससे त्रुटि पहले देखी जा सकती है और किसी भी समस्या के कारण इसे लूप में फंसने के लिए सीमित किया जा सकता है (बजाय एक समस्या होने के बहुत बाद और नहीं मिल रहा है यह)।

— ब्रायन
स्रोत
0

मुझे लगता है कि या तो ठीक है, लेकिन जब आपने चुना है, तो एक या दूसरे से चिपके रहें। यदि आप <= का उपयोग करने के लिए उपयोग किए जाते हैं, तो कोशिश करें कि <और इसके विपरीत का उपयोग न करें।

मैं <= पसंद करता हूं, लेकिन उन स्थितियों में जहां आप अनुक्रमित के साथ काम कर रहे हैं जो शून्य पर शुरू होते हैं, मैं शायद कोशिश करूंगा और उपयोग करूंगा <। हालांकि यह सभी व्यक्तिगत पसंद है।

— seanyboy
स्रोत
0

एक तार्किक दृष्टिकोण से, आपको यह सोचना < countहोगा कि उस <= countसटीक कारण की तुलना में अधिक कुशल <=होगा जो समानता के लिए परीक्षण करेगा।

— हेनरी बी
स्रोत
मुझे ऐसा नहीं लगता, असेंबलर में यह cmp eax, 7 jl LOOP_START या cmp eax, 6 jle LOOP_START दोनों को समान मात्रा में चक्र की आवश्यकता होती है।
— ट्रेब
<= के रूप में लागू किया जा सकता है! (>)
— JohnMcG
! (>) अभी भी दो निर्देश हैं, लेकिन ट्रेब सही है कि JLE और JL दोनों समान संख्या में घड़ी चक्रों का उपयोग करते हैं, इसलिए <और <= समान समय लेते हैं।
— जैकब क्राल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.