आपके लिए एक विधि की आदर्श लंबाई क्या है? [बन्द है]

Question

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

में स्वच्छ कोड: फुर्तीली सॉफ्टवेयर शिल्प कौशल की एक पुस्तिका , रॉबर्ट मार्टिन कहते हैं:

कार्यों का पहला नियम यह है कि वे छोटे होने चाहिए। कार्यों का दूसरा नियम यह है कि वे उससे छोटे होने चाहिए। फ़ंक्शंस 100 लाइनें लंबी नहीं होनी चाहिए। फ़ंक्शंस शायद ही कभी 20 लाइनें लंबी होनी चाहिए।

और वह केंट बेक से देखे गए जावा कोड से एक उदाहरण देता है:

उनके कार्यक्रम में हर समारोह सिर्फ दो, या तीन, या चार लाइनों लंबा था। प्रत्येक पारदर्शी रूप से स्पष्ट था। प्रत्येक ने एक कहानी सुनाई। और प्रत्येक ने आपको सम्मोहक क्रम में अगले तक पहुँचाया। आपके कार्य कितने कम होने चाहिए!

यह बहुत अच्छा लगता है, लेकिन दूसरी ओर, कोड कम्प्लीट में , स्टीव मैककॉनेल कुछ अलग कहता है:

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

और वह एक अध्ययन का संदर्भ देता है जो कहता है कि 65 लाइनें या लंबी लाइनें विकसित करने के लिए सस्ती हैं।

इसलिए जब मामले के बारे में अलग-अलग राय दी जाती है, तो क्या आपके लिए एक कार्यात्मक सबसे अच्छा अभ्यास है?

Comments

कार्यों को समझना आसान होना चाहिए। परिस्थिति के आधार पर लंबाई का पालन किया जाना चाहिए।

— हेंक होल्टरमैन

मुझे लगता है कि वास्तविक सीमा 53 लाइनों पर है। 32.4 वर्णों की औसत रेखा आकार के साथ। गंभीरता से, कोई निश्चित जवाब नहीं है। एक 100 लाइन विधि बहुत स्पष्ट और बनाए रखने योग्य हो सकती है, और 4 लाइन विधि समझने के लिए एक बुरा सपना हो सकती है। आम तौर पर हालांकि, लंबी विधियों में बहुत अधिक जिम्मेदारियां होती हैं, और छोटे लोगों की तुलना में समझने और बनाए रखने के लिए कठिन होता है। मैं जिम्मेदारियों के संदर्भ में सोचता हूं, और प्रति विधि एक ही जिम्मेदारी लेने की कोशिश करता हूं।

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

और, यदि आप अपने कार्यों की जटिलता को सीमित करना चाहते हैं, तो आपको उनकी साइक्लोमैटिक जटिलता को मापना चाहिए , न कि उनकी लंबाई को। switch100 caseशर्तों वाला एक बयान 10 स्तरों के ifबयानों के एक दूसरे के भीतर निहित होने से अधिक बनाए रखने योग्य है ।

बॉब मार्टिन का दृष्टिकोण 2008 से है, स्टीव मैक कॉनेल `1993 से। उनके पास" अच्छा कोड "के बारे में अलग-अलग दर्शन हैं, और आईएमएचओ बॉब मार्टिन कोड गुणवत्ता के बहुत अधिक स्तर को प्राप्त करने की कोशिश करता है।

— डॉक्टर ब्राउन

Answer 1

जावा या C # में कोडिंग करते समय फंक्शन्स सामान्य रूप से छोटे होने चाहिए, 5-15 लाइनों के बीच मेरा व्यक्तिगत "अंगूठे का नियम" है। यह कई कारणों से एक अच्छा आकार है:

• यह स्क्रॉल किए बिना आपकी स्क्रीन पर आसानी से फिट बैठता है
• यह वैचारिक आकार के बारे में है जिसे आप अपने सिर में धारण कर सकते हैं
• यह अपने आप में एक फ़ंक्शन की आवश्यकता के लिए पर्याप्त सार्थक है (एक स्टैंडअलोन के रूप में, तर्क का सार्थक हिस्सा)
• 5 लाइनों से छोटा एक फ़ंक्शन एक संकेत है कि आप शायद कोड को बहुत अधिक तोड़ रहे हैं (यदि आपको फ़ंक्शन के बीच नेविगेट करने की आवश्यकता है, तो पढ़ना / समझना कठिन है)। या तो वह या आप अपने विशेष मामलों / त्रुटि को भूल रहे हैं!

लेकिन मुझे नहीं लगता कि यह एक पूर्ण नियम निर्धारित करने में सहायक है, क्योंकि नियम से अलग होने के लिए हमेशा मान्य अपवाद / कारण होंगे:

• एक लाइन एक्सेसर फ़ंक्शन जो एक प्रकार कास्ट करता है, कुछ स्थितियों में स्पष्ट रूप से स्वीकार्य है।
• कुछ बहुत कम लेकिन उपयोगी कार्य हैं (उदाहरण के लिए उपयोगकर्ता द्वारा बताए गए स्वैप) जो स्पष्ट रूप से 5 लाइनों से कम की आवश्यकता होती है। कोई बड़ी बात नहीं है, कुछ 3 लाइन फ़ंक्शन आपके कोड आधार को कोई नुकसान नहीं पहुंचाते हैं।
• एक 100-लाइन फ़ंक्शन जो एक एकल बड़े स्विच स्टेटमेंट है स्वीकार्य हो सकता है अगर यह बहुत स्पष्ट है कि क्या किया जा रहा है। यह कोड वैचारिक रूप से बहुत सरल हो सकता है, भले ही इसके लिए विभिन्न मामलों का वर्णन करने के लिए बहुत सी लाइनों की आवश्यकता हो। कभी-कभी यह सुझाव दिया जाता है कि इसे अलग-अलग वर्गों में बदल दिया जाना चाहिए और इनहेरिटेंस / बहुरूपता का उपयोग करके कार्यान्वित किया जाना चाहिए, लेकिन IMHO यह OOP को बहुत दूर ले जा रहा है - मेरे पास केवल 40 नए वर्गों की तुलना में एक बड़ा 40-रास्ता स्विच स्टेटमेंट है, जिससे निपटने के लिए उन्हें बनाने के लिए 40-तरफा स्विच स्टेटमेंट के लिए।
• एक जटिल फ़ंक्शन में बहुत सारे राज्य चर हो सकते हैं जो मापदंडों के रूप में विभिन्न कार्यों के बीच पारित होने पर बहुत गड़बड़ हो जाते हैं। इस मामले में आप यथोचित तर्क दे सकते हैं कि कोड सरल और आसान है यदि आप एक ही बड़े कार्य में सब कुछ रखते हैं, तो इसका पालन करना आसान है (हालाँकि जैसा कि मार्क सही बताता है कि यह कक्षा में तब्दील होने के लिए भी एक उम्मीदवार हो सकता है दोनों तर्क को समेटने के लिए। और राज्य)।
• कभी-कभी छोटे या बड़े कार्यों के प्रदर्शन के फायदे होते हैं (शायद फ्रैंक उल्लेख के कारण इनलाइनिंग या जेआईटी कारणों के कारण)। यह अत्यधिक कार्यान्वयन पर निर्भर है, लेकिन यह एक अंतर बना सकता है - सुनिश्चित करें कि आप बेंचमार्क!

इसलिए मूल रूप से, सामान्य ज्ञान का उपयोग करें , अधिकांश उदाहरणों में छोटे फ़ंक्शन आकारों से चिपके रहें लेकिन असामान्य रूप से बड़े कार्य करने के लिए वास्तव में अच्छा कारण होने पर इसके बारे में हठधर्मिता न करें।

Comments

छोटे तरीकों के लिए एक तकनीकी / परिपूर्ण कारण है, भी: JIT कैश हिट। कई छोटे, पुन: प्रयोज्य तरीकों को पहले बुलाया जाने की अधिक संभावना है। ओह और एक अतिरिक्त डायग लाभ, स्टैकट्रैस उस तर्क पर अधिक ध्यान केंद्रित करते हैं जो पॉप गया था।

— ल्यूक पुप्लेट

"सामान्य ज्ञान का उपयोग करें" सबसे महत्वपूर्ण सलाह है

— साइमन

डिबगिंग के दौरान ब्रेकपॉइंट में स्टैक की गहराई के कारण "हेवोलि कोड" की शिकायतों के परिणामस्वरूप इस हेरास्टिक को पता होना चाहिए।

— फ्रैंक हिलमैन

@FrankHileman मैं कोड लिखने पर किसी भी दिन स्पेगेटी पर रैवियोली ले

@ स्नोमैन: ये विकल्प परस्पर अनन्य नहीं हैं ... स्पेगेटी के बिना छोटी स्टैक गहराई आदर्श है। गहरी ढेर गहराई, बगल में स्पेगेटी के साथ?

— फ्रैंक हिलमैन

Answer 2

जब मैं अन्य टिप्पणियों से सहमत होता हूं, जब उन्होंने कहा कि सही LOC नंबर के बारे में कोई कठिन नियम नहीं है, तो मैं शर्त लगाता हूं कि अगर हम उन परियोजनाओं को देखें जो हमने अतीत में देखी हैं और ऊपर प्रत्येक फ़ंक्शन की पहचान करते हैं, तो हम 150 लाइनों के कोड कहते हैं, ' मी अनुमान लगाते हुए कि हम एक आम सहमति पर आएंगे कि उन कार्यों में से 10 में से 9 एसआरपी को तोड़ते हैं (और साथ ही ओसीपी के रूप में भी), बहुत सारे स्थानीय चर, बहुत अधिक नियंत्रण प्रवाह हैं और आमतौर पर पढ़ने और बनाए रखने के लिए कठिन हैं।

इसलिए जबकि LOC खराब कोड का प्रत्यक्ष संकेतक नहीं हो सकता है, यह निश्चित रूप से एक सभ्य अप्रत्यक्ष संकेतक है कि निश्चित फ़ंक्शन को बेहतर लिखा जा सकता है।

मेरी टीम में मैं एक लीड की स्थिति में आ गया और जो भी कारण हो, लोग मुझे सुनते हुए प्रतीत होते हैं। जो मैं आमतौर पर तय करता हूं वह टीम को बताने के लिए होता है कि कोई पूर्ण सीमा नहीं होने पर, कोड की 50 से अधिक पंक्तियों को कोड की समीक्षा के दौरान कम से कम एक लाल झंडा उठाना चाहिए, ताकि हम उस पर दूसरा नज़र डालें और उसका पुनर्मूल्यांकन करें जटिलता और एसआरपी / ओसीपी उल्लंघन के लिए। उस दूसरे रूप के बाद, हम इसे अकेले छोड़ सकते हैं या हम इसे बदल सकते हैं, लेकिन कम से कम यह लोगों को इन चीजों के बारे में सोचने के लिए मजबूर करता है।

Comments

यह समझदार लगता है - LOC का मतलब जटिलता या कोड गुणवत्ता के संबंध में कुछ भी नहीं है, लेकिन यह इस संभावना के लिए एक अच्छा मार्कर हो सकता है कि चीजों को फिर से भरना चाहिए।

— कोरी

"एक आम सहमति है कि उन कार्यों में से 10 में से 9 एसआरपी को तोड़ते हैं" - मैं असहमत हूं, मुझे पूरा यकीन है कि उन कार्यों में से 10 में से 10 इसे तोड़ देंगे ;-)

— डॉक्टर ब्राउन

+1 कोड की समीक्षा के दौरान एक झंडा उठाने के लिए: दूसरे शब्दों में, एक कठिन और तेज़ नियम नहीं है, लेकिन आइए एक समूह के रूप में इस कोड पर चर्चा करें।

Answer 3

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

कितना बड़ा तरीका होना चाहिए इसका एक सामान्य नियम कभी-कभी इतना अच्छा नहीं होता है। मुझे रॉबर्ट सी। मार्टिन (अंकल बॉब) द्वारा नियम पसंद है: "तरीके छोटे होने चाहिए, छोटे से छोटे"। मैं हर समय इस नियम का उपयोग करने की कोशिश करता हूं। मैं यह स्पष्ट करके अपने तरीकों को सरल और छोटा रखने की कोशिश कर रहा हूं कि मेरी पद्धति केवल एक काम करती है और इससे ज्यादा कुछ नहीं।

Comments

मैं यह नहीं देखता कि एक 6000 लाइन फ़ंक्शन एक छोटे से डिबग करने के लिए कठिन क्यों है ... जब तक कि इसमें अन्य समस्याएं भी न हों (जैसे। पुनरावृत्ति)

— Calmarius

इसका डिबगिंग से कोई लेना-देना नहीं है .. इसकी जटिलता और स्थिरता के बारे में। आप 6000 लाइनों की विधि का विस्तार या परिवर्तन कैसे करेंगे?

— स्मोकफुट

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

— डैनियल बी

@ कैलेमरियस ने सहमति व्यक्त की, लेकिन वे दोनों कथन 6000 एलओसी कार्यों के खिलाफ एक तर्क हैं।

— डैनियल बी

600 लाइन विधि में एक स्थानीय चर अनिवार्य रूप से एक वैश्विक चर है।

— एमके 01

Answer 4

यह लाइनों की संख्या के बारे में नहीं है, यह एसआरपी के बारे में है। इस सिद्धांत के अनुसार, आपका तरीका एक और केवल एक ही काम करना चाहिए।

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

यदि आप बस एसआरपी का पालन करते हैं तो आपकी अधिकांश विधि छोटी और स्पष्ट इरादे के साथ होगी।

यह कहना सही नहीं है "यह तरीका> 20 लाइनें है इसलिए यह गलत है"। यह एक संकेत हो सकता है कि इस पद्धति के साथ कुछ गलत हो सकता है, और नहीं।

आपके पास एक विधि में 400 लाइनों का स्विच हो सकता है (अक्सर दूरसंचार में होता है), और यह अभी भी एकल जिम्मेदारी है और यह पूरी तरह से ठीक है।

Comments

बड़े स्विच स्टेटमेंट, आउटपुट स्वरूपण, हैश / शब्दकोश की परिभाषा जो कुछ डेटाबेस में लचीले होने के बजाय हार्डकोड होनी चाहिए, ऐसा अक्सर होता है, और पूरी तरह से ठीक है। जब तक तर्क भटक रहा है, तब तक आप सभी अच्छे हैं। एक बड़ी विधि आपको यह सोचने के लिए प्रेरित कर सकती है कि 'क्या मुझे इसे विभाजित करना चाहिए'। जवाब बहुत अच्छी तरह से हो सकता है 'नहीं, यह ठीक है जैसा कि यह है' (या हाँ, यह एक पूर्ण गड़बड़ है)

— Martijn

"एसआरपी" का क्या अर्थ है?

— थोमथोम

एसआरपी एकल जिम्मेदारी सिद्धांत के लिए खड़ा है और कहता है कि हर वर्ग (या विधि) के पास केवल एक जिम्मेदारी होनी चाहिए। यह सामंजस्य और युग्मन से संबंधित है। यदि आप एसआरपी का पालन करते हैं, तो आपकी कक्षाओं (या विधियों) में अच्छा सामंजस्य होगा, लेकिन युग्मन को बढ़ाया जा सकता है क्योंकि आप अधिक कक्षाओं (या विधियों) के साथ समाप्त होते हैं।

— क्रिस्टियन डूसके

एसआरपी के लिए +1। सामंजस्यपूर्ण कार्यों को लिखकर, कोई और अधिक आसानी से उन्हें अधिक जटिल परिणाम प्राप्त करने के लिए कार्यात्मक शैली में जोड़ सकता है। अंत में यह बेहतर है कि एक फ़ंक्शन को तीन अन्य कार्यों से बना दिया जाए, जो एक साथ तीन डिस्क्रीट कर रहे हैं, भले ही किसी भी तरह से संबंधित चीजें हों।

— मारियो टी। लैंज़ा

हाँ, लेकिन एक भी जिम्मेदारी क्या है। यह आपके सिर में बनी एक अवधारणा है। यदि आपको एक ही ज़िम्मेदारी के लिए 400 लाइनों की आवश्यकता है तो आपकी एकल जिम्मेदारी की अवधारणा शायद अलग है, तो मेरा

— Xitcod13

Answer 5

यह निर्भर करता है , गंभीरता से, वास्तव में इस सवाल का कोई ठोस जवाब नहीं है क्योंकि आप जिस भाषा में मामलों के साथ काम कर रहे हैं, इस उत्तर में वर्णित पाँच से पंद्रहवीं पंक्तियाँ C # या जावा के लिए काम कर सकती हैं, लेकिन अन्य भाषाओं में यह नहीं देती हैं आप के साथ काम करने के लिए बहुत कुछ। इसी तरह, आप जिस डोमेन में काम कर रहे हैं, उसके आधार पर, आप एक बड़ी डेटा संरचना में अपने आप को कोड सेटिंग मान लिखते हुए पा सकते हैं। कुछ डेटा संरचनाओं के साथ आपके पास दसियों तत्व हो सकते हैं जिन्हें आपको सेट करने की आवश्यकता है, क्या आपको अलग-अलग कार्यों में चीजों को तोड़ देना चाहिए क्योंकि आपका कार्य लंबा चल रहा है?

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

Answer 6

मुझे लगता है कि यहां एक समस्या यह है कि एक फ़ंक्शन की लंबाई इसकी जटिलता के बारे में कुछ नहीं कहती है। LOC (कोड की पंक्तियाँ) कुछ भी मापने के लिए एक बुरा साधन है।

एक विधि अत्यधिक जटिल नहीं होनी चाहिए, लेकिन ऐसे परिदृश्य हैं जहां एक लंबी विधि को आसानी से बनाए रखा जा सकता है। ध्यान दें कि निम्न उदाहरण यह नहीं कहता है कि इसे विधियों में विभाजित नहीं किया जा सकता है, बस यह कि विधियाँ स्थिरता को नहीं बदलेगी।

उदाहरण के लिए आने वाले डेटा के लिए एक हैंडलर एक बड़े स्विच स्टेटमेंट और फिर प्रति केस सरल कोड हो सकता है। मेरे पास ऐसा कोड है - फ़ीड से आने वाले डेटा को प्रबंधित करना। 70 (!) संख्यात्मक रूप से कोड किए गए हैंडलर। अब, कोई "स्थिरांक का उपयोग करें" कहेगा - हां, सिवाय इसके कि एपीआई उन्हें प्रदान नहीं करता है और मुझे यहां "स्रोत" के करीब रहना पसंद है। तरीके? निश्चित रूप से - बस दुख की बात है कि सभी समान 2 विशाल संरचनाओं के डेटा से निपटते हैं। संभवत: अधिक विधियों (पठनीयता) को छोड़कर उन्हें विभाजित करने में कोई लाभ नहीं। कोड आंतरिक रूप से जटिल नहीं है - एक क्षेत्र के आधार पर एक स्विच। फिर हर मामले में एक ब्लॉक होता है जो डेटा के x तत्वों को पार्स करता है और उन्हें प्रकाशित करता है। कोई रखरखाव दुःस्वप्न नहीं। कोई दोहरा रहा है "अगर स्थिति यह निर्धारित करती है कि किसी क्षेत्र में डेटा है (pField = pFields [x], यदि pField-> IsSet () {blabla}) - प्रत्येक क्षेत्र के लिए बहुत अधिक है।

बदलें कि बहुत छोटी दिनचर्या के साथ नेस्टेड लूप और बहुत सारे वास्तविक स्विचिंग स्टेटमेंट हैं और एक बड़ी विधि एक छोटे से बनाए रखने के लिए अधिक आसान हो सकती है।

तो, क्षमा करें, LOC के साथ शुरू करने के लिए एक अच्छा माप नहीं है। यदि कुछ भी हो, तो जटिलता / निर्णय बिंदुओं का उपयोग किया जाना चाहिए।

Comments

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

— rjzii

सही। यह ऐसा नहीं है कि LOC इस बात पर कोई टिप्पणी करने से वंचित नहीं है कि मैं अभिव्यंजक कोड को कैसे लिखता हूँ, hformatting rquirements आदि पर। LOC पूरी तरह से अनुपयुक्त और somethin है कि MBA के किसी भी अनुभव का उपयोग न करें। केवल। आप अपने आप को ऐसे लोगों की सूची में डालने के लिए स्वतंत्र हैं जो यह नहीं समझ रहे हैं कि एलओसी एक खराब माप क्यों है, लेकिन स्पष्ट रूप से यह आपको सुनने के लिए किसी के रूप में नहीं दिखेगा।

— टॉमटॉम

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

— rjzii

+1 फ़ंक्शन में फ़ंक्शन करने के लिए सभी कोड होने चाहिए। इसे एक काम और एक ही करना चाहिए - लेकिन अगर यह 1000 लाइनों का कोड लेता है, तो ऐसा ही होना चाहिए।

— जेम्स एंडरसन

मैंने आने वाले सॉकेट डेटा के लिए हैंडलर लिखे हैं और हां, उन्हें एक हजार या अधिक एलओसी की आवश्यकता हो सकती है। हालाँकि, मैं एक बार जितनी गिनती कर सकता हूँ, उतनी बार कर सकता हूँ और यह गिनने के लिए उपयुक्त तरीका नहीं था ।

Answer 7

मैं अभी एक और उद्धरण में फेंक दूँगा।

कार्यक्रमों को लोगों को पढ़ने के लिए लिखा जाना चाहिए, और केवल संयोगवश मशीनों के निष्पादन के लिए

- हेरोल्ड एबेल्सन

यह बहुत असंभव है कि 100-200 तक बढ़ने वाले कार्य इस नियम का पालन करते हैं

Comments

सिवाय जब वे एक स्विच होते हैं।

— कैलमेरियस

या डेटाबेस क्वेरी के परिणाम के आधार पर एक ऑब्जेक्ट का निर्माण करें जो

— परिणामी

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

— 17 फरवरी को MetalMikester

Answer 8

मैं इस पागल रैकेट में रहा हूँ, एक तरह से या किसी अन्य, 1970 के बाद से।

उस समय में, दो अपवादों के साथ, जो मुझे एक पल में मिलेंगे, मैंने कभी भी एक अच्छी तरह से डिज़ाइन की गई "दिनचर्या" (विधि, प्रक्रिया, कार्य, सबरूटीन, जो कुछ भी देखा है) देखा है कि एक से अधिक मुद्रित पृष्ठ होने की आवश्यकता है ( लगभग 60 रेखाएँ) लंबी। 10-20 पंक्तियों के आदेश पर उनमें से अधिकांश बहुत कम थे।

हालाँकि, मैंने "स्ट्रीम-ऑफ-चेतना" कोड का एक बहुत कुछ देखा है, जो उन लोगों द्वारा लिखे गए हैं, जिन्होंने स्पष्ट रूप से कभी भी मॉड्यूलरीकरण के बारे में नहीं सुना है।

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

दूसरा Matuszek-Reynolds-McGehearty-Cohen STARTRK गेम से फोटॉन टारपीडो रूटीन था, जो CDC 6600 FORTRAN IV में लिखा गया था। इसे कमांड लाइन को पार्स करना था, फिर प्रत्येक टारपीडो की उड़ान का अनुकरण करें, गड़बड़ी के साथ, टारपीडो और इसके बीच की हर तरह की चीज़ों के बीच की बातचीत की जांच कर सकते हैं, और ओह जिस तरह से पुनरावृत्ति का अनुकरण करते हैं, जंजीरों पर 8-तरफ़ा कनेक्टिविटी करने के लिए। टॉरपीडो से एक तारा जो अन्य सितारों के बगल में था, नोवा।

Comments

+1 के लिए "मेरे लॉन से दूर हो जाओ" मैं इस जवाब से मिलता हूं। साथ ही, ओओपी भाषाओं से पहले के व्यक्तिगत अनुभव व्यापक थे।

यह इतना अधिक "मेरे लॉन से दूर नहीं है" एक अवलोकन के रूप में है कि मैंने पिछले कुछ वर्षों में बकवास कोड देखा है, और यह मुझे लगता है कि काम कर रहा है।

— बजे जॉन आर। स्ट्रोह्म

मेरे बॉस को कई सौ लाइन लंबी लिखने की यह आदत है, अक्सर नेस्टेड आईएफएस के कई स्तरों के साथ। वह एक वर्ग को कई फ़ाइलों में "तोड़ने" के लिए आंशिक कक्षाएं (.NET) का उपयोग करता है ताकि वह दावा कर सके कि वह उन्हें कम रख रहा है। वे केवल दो चीजें हैं जिनसे मुझे निपटना है। लगभग 25 वर्षों से ऐसा कर रहे हैं, और मैं पुष्टि कर सकता हूं कि चीजें बदतर हो रही हैं। और अब मेरे लिए उस गंदगी में वापस जाने का समय।

— मेटलएमिस्टर

Answer 9

अगर मुझे लंबी विधि मिलती है - तो मैं शर्त लगा सकता हूं कि यह विधि ठीक से इकाई-परीक्षण नहीं है या अधिकांश समय यह इकाई परीक्षण बिल्कुल नहीं है। यदि आप टीडीडी करना शुरू करते हैं तो आप कभी भी 25 अलग-अलग जिम्मेदारियों और 5 नेस्टेड लूप के साथ 100-लाइनों के तरीकों का निर्माण नहीं करेंगे। टेस्ट आपको लगातार अपनी गंदगी को दूर करने और चाचा के बॉब क्लीन कोड लिखने के लिए बाध्य करते हैं।

Answer 10

विधि की लंबाई के बारे में कोई पूर्ण नियम नहीं है, लेकिन निम्नलिखित नियम उपयोगी हैं:

1. फ़ंक्शन का प्राथमिक उद्देश्य रिटर्न मान खोजना है। इसके अस्तित्व का कोई और कारण नहीं है। एक बार उस कारण के पूरा हो जाने के बाद, इसमें कोई अन्य कोड नहीं डाला जाना चाहिए। यह जरूरी कार्यों को छोटा रखता है। अन्य कार्यों को कॉल करना केवल तभी किया जाना चाहिए जब यह रिटर्न मान को आसान बनाता है।
2. दूसरी ओर, इंटरफेस छोटा होना चाहिए। इसका मतलब है कि आपके पास या तो बड़ी संख्या में कक्षाएं हैं, या आपके पास बड़े कार्य हैं - दोनों में से एक ऐसा होने जा रहा है जब आप कुछ भी महत्वपूर्ण करने के लिए पर्याप्त कोड शुरू करते हैं। बड़े कार्यक्रमों में दोनों हो सकते हैं।

Comments

साइड इफेक्ट के बारे में क्या है - एक फाइल पर लिखना, स्टेटस रीसेट करना, आदि?

— वोरैक

Answer 11

क्या लेखकों का मतलब "फ़ंक्शन" और "रूटीन" से है? आमतौर पर जब मैं "फ़ंक्शन" कहता हूं, तो मेरा मतलब है कि एक सबरूटीन / ऑपरेशन जो एक मान लौटाता है और एक के लिए "प्रक्रिया" जो नहीं करता है (और जिसका कॉल एक एकल कथन बन जाता है)। यह वास्तविक दुनिया में एसई में एक सामान्य अंतर नहीं है, लेकिन मैंने इसे उपयोगकर्ता ग्रंथों में देखा है।

किसी भी तरह से, इसका कोई सही जवाब नहीं है। एक या दूसरे के लिए वरीयता (यदि कोई प्राथमिकता है) कुछ ऐसा है जो मैं भाषाओं, परियोजनाओं और संगठनों के बीच बहुत भिन्न होने की उम्मीद करूंगा; बस के रूप में यह सभी कोड सम्मेलनों के साथ है।

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

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

इसलिए मुझे लगता है कि किस शैली में बग-भरा दुःस्वप्न होने की संभावना कम है, आप अपने कोड के बाकी हिस्सों के लिए कौन से सम्मेलनों का पालन करते हैं, इस पर बड़े हिस्से में निर्भर करेगा। :)

Answer 12

IMHO, आपको अपने फ़ंक्शन को पढ़ने के लिए स्क्रॉलबार का उपयोग नहीं करना चाहिए। जैसे ही आपको स्क्रॉलबार को स्थानांतरित करने की आवश्यकता होती है, यह समझने में कुछ समय लगता है कि फ़ंक्शन कैसे काम करता है।

तदनुसार, यह आपकी टीम के काम के सामान्य प्रोग्रामिंग वातावरण (स्क्रीन रिज़ॉल्यूशन, संपादक, फ़ॉन्ट आकार, आदि ...) पर निर्भर करता है। 80 के दशक में, यह 25 लाइनें और 80 कॉलम था। अब, मेरे संपादक पर, मैं लगभग ५० लाइनें प्रदर्शित करता हूं। मैंने कई बार दो फ़ाइलों को प्रदर्शित करने के लिए अपनी स्क्रीन को दो में विभाजित करने के बाद से मेरे द्वारा प्रदर्शित किए गए कॉलम की संख्या नहीं बदली।

संक्षेप में, यह आपके सहकर्मियों के सेटअप पर निर्भर करता है।

Comments

यह उस समय 24 लाइनों के बजाय नहीं था? मैं 3270 या 9750 टर्मिनलों के बारे में सोच रहा हूं, जहां 25 वीं स्थिति रेखा थी। और टर्मिनल एमुलेशन ने इसका अनुसरण किया।

— ott--

कुछ सिस्टम / संपादकों में शुरुआत से 40 या 50 लाइनें थीं। इन दिनों 150 लाइनें असामान्य नहीं हैं और 200+ उल्लेखनीय है, इसलिए यह वास्तव में एक अच्छा मीट्रिक नहीं है।

— मूर

मैं पोर्ट्रेट ओरिएंटेशन में अपनी स्क्रीन का उपयोग करता हूं, मैं एक साथ कोड की 200 लाइनें देख सकता हूं।

— कैलमेरियस

और अगर मैं अपनी लाइनों को तोड़ने के लिए किसी भी लाइन ब्रेक का उपयोग नहीं करता हूं तो मैं एक लाइन में 5000 लाइन विधि को कोड कर सकता हूं ...

— 13

Answer 13

मुझे लगता है कि टॉमटॉम का जवाब करीब आया कि मैं इसके बारे में कैसा महसूस करता हूं।

अधिक से अधिक मैं अपने आप को लाइनों के बजाय चक्रीय जटिलता पर जा रहा हूँ।

मैं आम तौर पर प्रति विधि एक से अधिक नियंत्रण संरचना के लिए लक्ष्य नहीं रखता, हालांकि कई लूपों के अपवाद के साथ यह एक बहुआयामी सरणी को संभालने के लिए होता है।

मैं कभी-कभी स्विच के मामलों में खुद को वन-लाइन इफ़ेक्ट लगाता हूं क्योंकि किसी कारण से ये ऐसे मामले होते हैं जहां इसे विभाजित करने से मदद के बजाय बाधा उत्पन्न होती है।

ध्यान दें कि मैं इस सीमा के खिलाफ गार्ड तर्क की गणना नहीं करता हूं।

Comments

साइक्लोमैटिक जटिलता को वास्तविक उत्पादन कोड की बड़ी मात्रा में दिखाया गया है, कच्चे एसएलओसी के साथ बहुत अधिक सहसंबद्ध होने के कारण, साइक्लोमैटिक जटिलता की गणना समय, ऊर्जा और घड़ी चक्रों की कुल बर्बादी है।

— बजे जॉन आर। स्ट्रोह्म

@ JohnR.Strohm मैं प्रति विधि के बारे में बात कर रहा हूं, समग्र रूप से नहीं। यकीन है, बड़ी तस्वीर में यह बहुत सहसंबद्ध है - सवाल यह है कि उस कोड को तरीकों में कैसे विभाजित किया जाए। 100 लाइनों के 10 तरीकों या 10 लाइनों के 100 तरीकों में अभी भी समग्र एसएलओसी और जटिलता समान होगी लेकिन पूर्व के साथ काम करने के लिए बहुत कठिन होने वाला है।

— लोरेन Pechtel

इसलिए मैं I. सहसंबंध अध्ययन कोड के बहुत से देखा, और दिनचर्या का बहुत। (यह बड़े सार्वजनिक रिपॉजिटरी में से एक था।)

— जॉन आर। स्ट्रोहम

Answer 14

OOP में सभी चीजें ऑब्जेक्ट हैं और ये विशेषताएं हैं:

1. बहुरूपता
2. मतिहीनता
3. विरासत

जब आप इन नियमों का पालन करते हैं तो आपके तरीके आमतौर पर छोटे होते हैं लेकिन छोटे या बहुत छोटे (जैसे 2-3 लाइन) नियमों के लिए कोई नियम मौजूद नहीं होता है। छोटी विधि (छोटी इकाई जैसे विधि या कार्य) का लाभ हैं:

1. बेहतर पठनीय है
2. बेहतर बनाए रखें
3. बग बेहतर है
4. बेहतर बदलाव