दिलचस्प पोस्ट
डुप्लिकेट कुंजी त्रुटियों को सुरक्षित रूप से insert_many का उपयोग करने से कैसे अनदेखा करें अन्य स्रोत के लिए पायथन खोज पथ का विस्तार करें जावा में कचरा कलेक्टर – एक ऑब्जेक्ट नल सेट करें कैसे इसे नीचे घूम द्वारा जावा में एक int करने के लिए एक डबल डाली? जांचें कि क्या पेज को फिर से लोड किया गया है या फिर जावास्क्रिप्ट में रीफ्रेश किया गया है स्ट्रिंग को इसके समतुल्य LINQ अभिव्यक्ति ट्री में कनवर्ट कैसे करें? AngularJS में गुंजाइश प्रोटोटाइप / प्रोटोटाइपिकल विरासत की बारीकियों क्या हैं? हमें फ्लैटमैप का उपयोग करने की आवश्यकता क्यों है? सीएसएस प्रॉपर्टी नाम में तारांकन क्या करता है? सी # में "स्थिर विधि" क्या है? पायथन पुनः। शब प्रश्न वेब ब्राउज़र से जीपीएस स्थान प्राप्त करें क्या पासवर्ड संग्रहण के लिए SHA-1 सुरक्षित है? किसी पीडीएफ को कैसे आरक्षित / कच्चे या परिसंपत्ति फ़ोल्डर में संग्रहीत किया जाता है? जावास्क्रिप्ट में & and && के बीच अंतर क्या है?

ऊपर या नीचे टेस्ट लूप्स? (जबकि बनाम करते हैं)

जब मैं कॉलेज में सीएस (मध्य 80 के दशक) में ले रहा था, तो उन विचारों में से एक जो लगातार दोहराया गया था, हमेशा उन लूपों को लिखना था जो नीचे की ओर (जबकि …) की तुलना में (नीचे …) की तुलना में पाश। इन धारणाओं को अक्सर पढ़ाई के संदर्भ के साथ समर्थन दिया जाता है, जिसमें पता चलता है कि शीर्ष पर परीक्षण किए गए लूप सांख्यिकीय आधार पर उनके नीचे-परीक्षण समकक्षों की तुलना में अधिक सटीक होने की संभावना है।

नतीजतन, मैं लगभग हमेशा शीर्ष पर परीक्षण जो loops लिखें। अगर मैं कोड में अतिरिक्त जटिलता का परिचय देता हूं तो मैं ऐसा नहीं करता, लेकिन यह मामला दुर्लभ लगता है। मुझे लगता है कि कुछ प्रोग्रामर लगभग अनन्य रूप से लूप लिखते हैं जो कि नीचे की परीक्षा है जब मैं देखता हूं कि जैसे:

if (condition) { do { ... } while (same condition); } 

या व्युत्क्रम ( while अंदर की तरफ), मुझे आश्चर्य होता है कि क्या वे वास्तव में उस तरीके से लिखा है या अगर वे उस बयान को जोड़ते हैं, जब उन्हें एहसास हुआ कि लूप ने नल केस को संभाला नहीं।

मैंने कुछ गोगलिंग किया है, लेकिन इस विषय पर कोई भी साहित्य नहीं मिल पा रहा है। आप लोग कैसे (और जील्स) अपने छोरों को लिखते हैं?

वेब के समाधान से एकत्रित समाधान "ऊपर या नीचे टेस्ट लूप्स? (जबकि बनाम करते हैं)"

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

लूप के पहले पुनरावृत्ति के पहले किसी स्थिति का परीक्षण करना चाहते समय लूप के दौरान उपयोग करें।

लूप का पहला चलना चलने के बाद जब आप एक शर्त का परीक्षण करना चाहते हैं, तो करें-करते हुए लोप्स का उपयोग करें।

उदाहरण के लिए, यदि आप इन स्निपेट्स में से किसी एक तरह से स्वयं कर रहे हैं:

 func(); while (condition) { func(); } //or: while (true){ func(); if (!condition) break; } 

आपको इसे फिर से लिखना चाहिए:

 do{ func(); } while(condition); 

अंतर यह है कि डू लूप "कुछ करना" को एक बार निष्पादित करता है और फिर यह देखने के लिए स्थिति जांचता है कि क्या इसे "कुछ करना" दोहराने चाहिए, जबकि कुछ समय पहले लूप स्थिति जांचता है

क्या वास्तव में मेरी कोड को अधिक पठनीय बनाने में मदद do / while हैं?

नहीं।

यदि यह किसी do / लूप का उपयोग करने के लिए अधिक समझ में आता है, तो ऐसा करें यदि आपको स्थिति जांचने से पहले एक बार लूप के शरीर को निष्पादित करने की आवश्यकता है, तो एक do / while लूप शायद सबसे सरल क्रियान्वयन है।

यदि कोई शर्त झूठी है तो सबसे पहले कोई भी निष्पादित नहीं हो सकता है। अन्य एक कम से कम एक बार निष्पादित करेगा, फिर कॉन्सडिशन की जांच करें।

पठनीयता के लिए यह शीर्ष पर परीक्षण करने के लिए समझदार लगता है तथ्य यह है कि एक पाश महत्वपूर्ण है; कोड पढ़ने वाला व्यक्ति लूप के शरीर को समझने की कोशिश करने से पहले लूप स्थितियों के बारे में पता होना चाहिए।

यहां एक अच्छा वास्तविक दुनिया उदाहरण है, जो मैंने हाल ही में आया था। मान लीजिए आपके पास कई प्रोसेसिंग कार्य हैं (जैसे कि किसी सरणी में प्रोसेसिंग तत्व) और आप एक धागे प्रति सीपीयू कोर उपस्थित के बीच काम को विभाजित करना चाहते हैं। मौजूदा कोड चलाना कम से कम एक कोर होना चाहिए! तो आप ऐसा कर सकते do... while ऐसा कुछ:

 do { get_tasks_for_core(); launch_thread(); } while (cores_remaining()); 

यह लगभग लापरवाह है, लेकिन यह प्रदर्शन लाभ पर विचार करने के लिए उपयुक्त हो सकता है: यह समान रूप से एक मानक के रूप में लिखा जा सकता है, while लूप, लेकिन यह हमेशा एक अनावश्यक प्रारंभिक तुलना बनायेगा जो हमेशा true मूल्यांकन करेगी – और एकल-कोर पर शर्त शाखाएं अधिक पूर्वानुमानित (हमेशा झूठी हैं, बनाम एक मानक के लिए वास्तविक / झूठी वैकल्पिक)

पहले परीक्षण करने से पहले शर्त यह संभव है कि आपका कोड कभी नीचे कोड दर्ज नहीं करेगा। दूसरा स्थिति का परीक्षण करने से पहले कोड को पूरा करेगा।

जबकि लूप पहले "स्थिति" की जांच करेगा; अगर यह गलत है, तो यह कभी कुछ नहीं करेगा। लेकिन ऐसा करें … जबकि लूप पहले "कुछ करना" होगा, फिर "स्थिति" की जांच करें।

Ya..its..its सच है .. करते समय कम से कम एक बार चलेंगे। केवल फर्क सिर्फ इतना है इस पर बहस करने के लिए और कुछ नहीं

हां, बस के बजाय के लिए उपयोग करने की तरह, या इसके बजाय foreach पठनीयता में सुधार के लिए उसने कहा कि कुछ परिस्थितियों को करना पड़ता है और मैं मानता हूं कि आप उन परिस्थितियों को थोड़ी देर लूप में लागू करने के लिए बेवकूफी होगी।

सामान्य उपयोग के संदर्भ में सोचने में अधिक उपयोगी है जबकि ज्यादातर छोरों के साथ काफी स्वाभाविक रूप से काम while , भले ही वे साथ काम करने के लिए किया जा सकता do...while , जब तक मूल रूप से आपको इसका उपयोग करना चाहिए, जब अंतर कोई फर्क नहीं पड़ता मैं इस प्रकार इस्तेमाल करेगा do...while दुर्लभ परिदृश्यों के लिए जहां यह पठनीयता में एक उल्लेखनीय सुधार प्रदान करता है।

उपयोग के मामलों के लिए दो अलग हैं। यह एक "सर्वोत्तम अभ्यास" प्रश्न नहीं है

यदि आप किसी लूप की स्थिति के आधार पर निष्पादित करने के लिए विशेष रूप से या इसके दौरान उपयोग करना चाहते हैं

यदि आप हालत की परवाह किए बिना एक बार कुछ करना चाहते हैं और फिर स्थिति मूल्यांकन के आधार पर इसे जारी रखना चाहते हैं। जबकि ऐसा

थोड़ी देर () लूप बॉडी के प्रत्येक निष्पादन से पहले की स्थिति की जांच करता है और एक करें … जबकि () लूप बॉडी के प्रत्येक निष्पादन के बाद स्थिति जांचता है।

इस प्रकार, ** करो … जबकि () ** एस हमेशा कम से कम एक बार लूप बॉडी निष्पादित करेगा।

कार्यात्मक रूप से, एक समय () बराबर है

 startOfLoop: if (!condition) goto endOfLoop; //loop body goes here goto startOfLoop; endOfLoop: 

और एक करें … जबकि () बराबर है

 startOfLoop: //loop body //goes here if (condition) goto startOfLoop; 

ध्यान दें कि कार्यान्वयन शायद इस की तुलना में अधिक कुशल है। हालांकि, एक करें … जबकि () थोड़ी देर की तुलना में एक कम तुलना शामिल है () तो यह थोड़ा तेज है का प्रयोग करें … जबकि () यदि:

  • आप जानते हैं कि यह स्थिति हमेशा पहली बार सच होगी, या
  • आप लूप को एक बार निष्पादित करना चाहते हैं , भले ही स्थिति गलत हो।

यहां अनुवाद है:

 do { y; } while(x); 

के समान

 { y; } while(x) { y; } 

ध्यान दें कि अतिरिक्त स्थिति में ब्रेसिज़ के मामले हैं जो आपके पास y में चर परिभाषाएं हैं। उन लोगों के दायरे को स्थानीय रूप से डॉट-लूप के मामले में रखा जाना चाहिए। इसलिए, एक डू-ऑल लूप कम से कम एक बार अपने शरीर को निष्पादित करता है इसके अलावा, दो लूप समान हैं। इसलिए यदि हम इस नियम को अपने कोड में लागू करते हैं

 do { // do something } while (condition is true); 

इसी समय आपके डू-लूप के लिए लूप दिखता है

 { // do something } while (condition is true) { // do something } 

हां, जब आप अपने डू लूप के लिए इसी समय देखेंगे, तब तक आप अलग-अलग हैं I

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

यह वास्तव में एक अलग चीजों के लिए है सी में, आप दो- दो परिदृश्य प्राप्त करने के लिए निर्माण करते समय – कम से कम एक बार चला सकते हैं और सच्चे रूप में चल सकते हैं)। लेकिन पास्कल ने दोहराए हैं – प्रत्येक परिदृश्य के लिए और तब तक , और अगर मुझे सही याद है, एडीए का एक और निर्माण होता है जो आपको बीच में छोड़ने देता है, लेकिन बेशक यह नहीं है कि आप क्या पूछ रहे हैं। आपके प्रश्न का उत्तर: मुझे शीर्ष पर परीक्षण के साथ मेरी पाश पसंद है।

किसी के लिए जो एक या अधिक बार लूप के कारण के बारे में नहीं सोच सकता है:

 try { someOperation(); } catch (Exception e) { do { if (e instanceof ExceptionIHandleInAWierdWay) { HandleWierdException((ExceptionIHandleInAWierdWay)e); } } while ((e = e.getInnerException())!= null); } 

इसका इस्तेमाल किसी क्रमबद्ध संरचना के लिए किया जा सकता है।

कक्षा नोड में:

 public Node findSelfOrParentWithText(string text) { Node node = this; do { if(node.containsText(text)) { break; } } while((node = node.getParent()) != null); return node; } 

यदि आपको सही ढंग से कोड लिखना है, तो दोनों सम्मेलनों सही हैं 🙂

आम तौर पर दूसरे अधिवेशन का उपयोग ( करना {} करते समय () ) का मतलब लूप के बाहर डुप्लिकेट किया गया स्टेटमेंट से बचने के लिए होता है। निम्न (सरलीकृत) उदाहरण पर विचार करें:

 a++; while (a < n) { a++; } 

अधिक संक्षिप्त तरीके से उपयोग कर लिखा जा सकता है

 do { a++; } while (a < n) 

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

 while (++a < n) {} 

लेकिन मुझे लगता है कि आप यहां बिंदु देख सकते हैं।

जैसा कि पेइज़िशन्स ने बताया है, अंतर यह है कि क्या परीक्षण करने से पहले एक बार लूप निष्पादित होता है, या अगर परीक्षण पहले किया जाता है ताकि लूप का शरीर कभी भी निष्पादित न हो।

महत्वपूर्ण सवाल यह है कि आपके आवेदन के लिए समझ में आता है।

दो सरल उदाहरण लेने के लिए:

  1. कहते हैं कि आप एक सरणी के तत्वों के माध्यम से पाशन कर रहे हैं। यदि सरणी में कोई तत्व नहीं है, तो आप शून्य के नंबर एक को संसाधित नहीं करना चाहते हैं। तो आपको WHILE का उपयोग करना चाहिए

  2. आप एक संदेश प्रदर्शित करना चाहते हैं, एक प्रतिक्रिया स्वीकार कर सकते हैं, और अगर प्रतिक्रिया अमान्य है, तब तक फिर से पूछें जब तक आप एक वैध प्रतिक्रिया प्राप्त न करें। तो आप हमेशा एक बार पूछना चाहते हैं आप परीक्षण नहीं कर सकते हैं कि क्या प्रतिक्रिया तब तक मान्य है जब तक कि आपको प्रतिक्रिया न मिले, इसलिए आपको इस स्थिति की जांच करने से पहले एक बार लूप के शरीर के माध्यम से जाना होगा। आपको DO / WHILE का उपयोग करना चाहिए

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

यह वास्तव में निर्भर करता है कि जब आप शीर्ष पर परीक्षण करना चाहते हैं, दूसरों को जब आप नीचे से परीक्षण करना चाहते हैं, और फिर भी जब आप मध्य में परीक्षण करना चाहते हैं

हालांकि दिए गए उदाहरण बेतुका लगता है। यदि आप शीर्ष पर परीक्षण करने जा रहे हैं, तो नीचे दिए गए एक बयान और परीक्षण का उपयोग न करें, बस एक वक्तव्य का उपयोग करें, यही वह है जो इसके लिए किया जाता है।

आपको पहले लूप कोड के भाग के रूप में परीक्षण के बारे में सोचना चाहिए। यदि परीक्षण तार्किक रूप से लूप प्रसंस्करण की शुरुआत में है, तो यह शीर्ष-के- the- लूप परीक्षण है। अगर परीक्षण तार्किक रूप से लूप के अंत में होता है (यानी यह तय करता है कि लूप को चलाना जारी रखना चाहिए), तो यह संभवतः एक निचला-नीचे-लूप परीक्षण है।

अगर परीक्षण तार्किक तौर पर उनके मध्य में है तो आपको कुछ फैंसी करना होगा। 🙂

मुझे लगता है कि कुछ लोगों को नीचे की परीक्षा है क्योंकि आप 30 साल पहले ऐसा करके एक या कुछ मशीन चक्रों को बचा सकते हैं

सही कोड लिखने के लिए, एक मूल रूप से एक मानसिक, शुद्धता के अनौपचारिक सबूत का प्रदर्शन करना होगा।

एक पाश सही साबित करने के लिए, मानक तरीका है एक लूप अपरिवर्तनीय, और एक प्रेरण प्रमाण चुनें। लेकिन जटिल शब्दों को छोड़ें: आप जो भी करते हैं, अनौपचारिक रूप से, कुछ ऐसी चीज़ का पता लगा सकते हैं जो लूप के प्रत्येक आवृत्ति के बारे में सच है, और जब लूप किया जाता है, तो आप जो चाहते थे वह अब सही है। पाश अपरिवर्तनीय अंत में झूठ है, पाश को समाप्त करने के लिए।

यदि लूप की स्थितियों को अपरिवर्तनीय रूप से आसानी से देखा जाता है, और अपरिवर्तनीय लूप के शीर्ष पर है, और एक का अनुमान है कि लूप के कोड के माध्यम से काम करके लूप के अगले पुनरावृत्ति पर अपरिवर्तनीय सही है, तो यह आसान है यह पता लगाने के लिए कि पाश सही है

हालांकि, अगर अपरिवर्तनीय लूप के तल पर है, तब तक जब तक आपके पास लूप (एक अच्छा अभ्यास) से पहले कोई तर्क नहीं होता है, तो यह अधिक कठिन हो जाता है क्योंकि आपको अनिवार्य रूप से अनुमान लगाना पड़ता है कि अपरिवर्तनीय क्या होना चाहिए, और यह कि कोई भी कोड जो पहले लूप लूप अपरिवर्तनीय बनाता है (क्योंकि कोई पाश पूर्व शर्त नहीं है, कोड लूप में निष्पादित होगा)। यह सिर्फ सही साबित करने के लिए अधिक कठिन हो जाता है, भले ही यह आपके अन्तर्निहित में-आपके-मुख्य सबूत हो।

यह वास्तव में एक जवाब नहीं है, लेकिन मेरे व्याख्याताओं में से किसी एक का पुनर्मिलन ने कहा और उस वक्त मुझे दिलचस्पी है।

दो प्रकार की लूप जबकि..और करो … वास्तव में तीसरे और जेनेरिक लूप के उदाहरण हैं, जो कि बीच में कहीं टेस्ट है।

 begin loop <Code block A> loop condition <Code block B> end loop 

कोड ब्लॉक ए को कम से कम एक बार निष्पादित किया जाता है और बी को शून्य या अधिक बार निष्पादित किया जाता है, लेकिन बहुत ही आखिरी (विफल) पुनरावृत्ति पर नहीं चल रहा है। एक समय लूप तब होता है जब कोड ब्लॉक A खाली होता है और एक ऐसा समय होता है जब कोड ब्लॉक बी खाली होता है। लेकिन अगर आप एक कंपाइलर लिख रहे हैं, तो आप दोनों मामलों को इस तरह से एक लूप में सामान्य करने में रुचि रख सकते हैं।

 while( someConditionMayBeFalse ){ // this will never run... } // then the alternative do{ // this will run once even if the condition is false while( someConditionMayBeFalse ); 

अंतर स्पष्ट है और आपको कोड चलाने की अनुमति मिलती है और फिर परिणाम का मूल्यांकन करने के लिए यह देखने के लिए कि क्या आपको "इसे दोबारा दोबारा" करना है और अन्य तरीकों से यदि सशर्त पूरा नहीं होता है तो आपको स्क्रिप्ट के ब्लॉक को अनदेखा करने की अनुमति मिलती है।

कंप्यूटर विज्ञान में एक ठेठ असतत संरचना वर्ग में, यह एक आसान सबूत है कि दोनों के बीच एक समानता मानचित्रण है

स्टाइलिस्टिक रूप से, मैं जबकि (आसान एक्सप्र) {} को पसंद करता हूं, जब आसान एक्सपी सामने जाता है और जाने के लिए तैयार होता है, और पाश में बहुत अधिक ओवरहेड / आरंभीकरण नहीं होता है मुझे पसंद है {} जबकि (कुछ हद तक कम आसान- expr); जब अधिक बार ओवरहेड होता है और स्थिति समय से पहले स्थापित करने में काफी आसान नहीं होती है। अगर मैं एक अनंत लूप लिखता हूं, तो मैं हमेशा (सच्चा) {} समय का उपयोग करता हूं। मैं क्यों नहीं समझा सकता, लेकिन मुझे (;;) {} के लिए लिखना पसंद नहीं है।

मैं कहूंगा कि यह लिखने के लिए बुरा व्यवहार है अगर..कैसे..यह छोरों, सरल कारण यह है कि यह कोड के आकार को बढ़ाता है और कोड डुप्लिकेशन्स का कारण बनता है कोड की नकली त्रुटि प्रवण होती है और इसे टाला जाना चाहिए, क्योंकि किसी भी हिस्से में कोई भी परिवर्तन डुप्लिकेट पर भी किया जाना चाहिए, जो हमेशा मामला नहीं होता। इसके अलावा, बड़ा कोड सीपीयू कैश पर एक कठिन समय का मतलब है। अंत में, यह रिक्त मामलों को संभालता है, और सिर दर्द को हल करता है

केवल जब पहला लूप मूल रूप से अलग होता है, तो इसका उपयोग करना चाहिए, कहते हैं, यदि कोड आपको पाश स्थिति (जैसे प्रारंभिक) को पारित करता है, तो पाश में किया जाता है। अन्यथा, यदि यह निश्चित है कि लूप पहले पुनरावृत्ति पर कभी नहीं गिरता, तो हाँ, एक do..while उपयुक्त है।

मेरे कोड पीढ़ी के सीमित ज्ञान से मुझे लगता है कि यह नीचे के परीक्षण के लूप लिखने के लिए एक अच्छा विचार हो सकता है क्योंकि वे संकलक को पाश अनुकूलन को बेहतर बनाने में सक्षम करते हैं। निचले टेस्ट लूप के लिए यह गारंटी है कि लूप कम से कम एक बार निष्पादित करता है। इसका मतलब है कि लूप अपरिवर्तनीय कोड बाहर निकलने के नोड पर "हावी है" और इस तरह सुरक्षित रूप से लूप शुरू होने से पहले ही स्थानांतरित किया जा सकता है।