refactoring - आप कितना डुप्लिकेट कोड सहन करते हैं?




coding-style dry (9)

DRY की बात स्थिरता है। यदि कोड को समझना कठिन है, तो इसे बनाए रखना कठिन है, इसलिए यदि रिफैक्टिंग पठनीयता को नुकसान पहुंचाता है तो आप वास्तव में DRY के लक्ष्य को पूरा करने में विफल हो सकते हैं। कोड की 15 से कम लाइनों के लिए, मैं आपके सहपाठी से सहमत होना चाहूंगा।

हाल ही में एक कोड की समीक्षा में मैंने एक वर्ग (15 से कम लाइनों) में नकल किए गए तर्क की कुछ पंक्तियों को देखा। जब मैंने सुझाव दिया कि लेखक कोड को रिफलेक्टर करता है, तो उसने तर्क दिया कि कोड को इस तरह समझना सरल है। कोड को फिर से पढ़ने के बाद, मुझे इस बात पर सहमत होना होगा कि डुप्लिकेट किए गए तर्क को निकालने से पठनीयता को थोड़ा नुकसान पहुंचेगा।

मुझे पता है कि DRY दिशानिर्देश है, एक पूर्ण नियम नहीं है। लेकिन सामान्य तौर पर, क्या आप DRY के नाम पर पठनीयता पर चोट करने को तैयार हैं?


अमूर्त में कहना बहुत मुश्किल है। लेकिन मेरा खुद का मानना ​​है कि डुप्लिकेट कोड की एक लाइन को भी फंक्शन में बनाया जाना चाहिए। बेशक, मैं हमेशा अपने आप को इस उच्च मानक को प्राप्त नहीं करता हूं।


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

ज्यादातर भाषाओं में, एक ब्लॉक को एक उपयुक्त नाम पद्धति से निकालने से शायद ही कभी आपकी पठनीयता को ठेस पहुंचे।

यह आपके मानकों के साथ आपका कोड है, लेकिन मेरा मूल उत्तर आपके "कितना?" कोई नहीं है ...


पठनीयता सबसे महत्वपूर्ण चीजों में से एक है जो कोड हो सकती है, और मैं इस पर समझौता करने के लिए तैयार नहीं हूं। डुप्लिकेटेड कोड एक बुरी गंध है, न कि एक घातक पाप।

कहा जा रहा है कि, यहाँ मुद्दे हैं।

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

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


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

यह कहते हुए कि यह पठनीयता को चोट पहुँचाएगा, केवल यह बताता है कि आप नाम लेने में बुरे हैं :-)


यदि प्रश्न में कोड में एक स्पष्ट व्यवसाय या प्रौद्योगिकी-समर्थन उद्देश्य पी है, तो आपको आमतौर पर इसे फिर से भरना चाहिए। अन्यथा आपको क्लोन कोड के साथ क्लासिक समस्या होगी: अंततः आपको पी का समर्थन करने वाले कोड को संशोधित करने की आवश्यकता होगी, और आपको इसे लागू करने वाले सभी क्लोन नहीं मिलेंगे।

कुछ लोग सुझाव देते हैं कि 3 या अधिक प्रतियाँ रिफैक्टरिंग की सीमा होती हैं। मेरा मानना ​​है कि अगर आपके पास दो हैं, तो आपको ऐसा करना चाहिए; एक बड़ी प्रणाली में अन्य क्लोन (ओं) [या यहां तक ​​कि वे मौजूद हो सकते हैं] को जानना मुश्किल है, चाहे आपके पास दो या तीन या अधिक हों।

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

एक उपकरण जो क्लोन को मज़बूती से ढूँढ सकता है वह कम से कम आपको विफलता-से-अद्यतन-क्लोन रखरखाव त्रुटियों को बनाने से रोक सकता है। ऐसा ही एक टूल (मैं लेखक हूं) CloneDR । क्लोनर्ड, लक्षित लैंग्वेज संरचना के मार्गदर्शन के रूप में क्लोन का उपयोग करता है, और इस प्रकार क्लोन को व्हाट्सएप लेआउट, टिप्पणियों में परिवर्तन, नामांकित चर आदि की परवाह किए बिना पाता है (यह C, C ++, Java, C #, COBOL और PHP सहित कई भाषाओं के लिए लागू किया गया है )। CloneDR को बड़े सिस्टमों में क्लोन मिलेंगे, बिना किसी गाइडेंस के। पता लगाए गए क्लोन दिखाए गए हैं, साथ ही साथ एंटीइनफायर , जो अनिवार्य रूप से अमूर्त है जिसे आपने लिखा होगा। इसके संस्करण (COBOL के लिए) अब एक्लिप्स के साथ एकीकृत होते हैं, और आपको दिखाते हैं कि जब आप किसी बफर में एक क्लोन के अंदर संपादन कर रहे हैं, साथ ही साथ जहाँ अन्य क्लोन हैं, ताकि आप दूसरों के होने पर निरीक्षण / संशोधन कर सकें। (एक चीज जो आप कर सकते हैं, वह है उन्हें :)।

मैं समझता था कि क्लोनिंग सिर्फ एकमुश्त गलत था, लेकिन लोग ऐसा करते हैं क्योंकि वे नहीं जानते कि क्लोन मूल से कैसे भिन्न होगा और इसलिए अंतिम एब्स्ट्रेक्शन उस समय स्पष्ट नहीं होता है जब क्लोनिंग अधिनियम हो रहा है। अब मेरा मानना ​​है कि क्लोनिंग अच्छा है, यदि आप क्लोन को ट्रैक कर सकते हैं और आप एब्सट्रैक्शन के स्पष्ट होने के बाद रिफैक्ट करने का प्रयास करते हैं।


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

अक्सर कोड LOGIC के दोहराव तब होते हैं जब दो ऑब्जेक्ट्स, विभिन्न बेस कक्षाओं के साथ, उनके संचालित होने के तरीके में समानताएं होती हैं। उदाहरण के लिए 2 GUI घटक जो दोनों मान प्रदर्शित करते हैं, लेकिन उस मान तक पहुँचने के लिए एक सामान्य इंटरफ़ेस लागू नहीं करते हैं। इस तरह की प्रणाली को फिर से शुरू करने के लिए या तो जरूरत से ज्यादा सामान्य वस्तुओं को लेने के तरीकों की आवश्यकता होती है, इसके बाद टाइपकास्टिंग और कास्टिंग होती है, या फिर वर्ग पदानुक्रम को फिर से संगठित और पुनर्गठित करने की आवश्यकता होती है।

यह स्थिति भिन्न है यदि कोड बिल्कुल डुप्लिकेट था। यदि मैं केवल इसे दो बार उपयोग करने का इरादा रखता हूं, और दोनों बार एक ही फ़ंक्शन के भीतर, तो जरूरी नहीं कि मैं एक नया इंटरफ़ेस वर्ग बनाऊं।


व्यक्तिगत रूप से, मैं कोड को समझने योग्य रखना चाहता हूं, सबसे पहले और सबसे महत्वपूर्ण।

DRY कोड में रखरखाव को आसान बनाने के बारे में है। बार-बार कोड हटाने के लिए आपके कोड को कम समझने योग्य बनाने से कोड की कुछ बार-बार होने वाली लाइनों की तुलना में, कई मामलों में, अधिक स्थिरता बनी रहती है।

यह कहा जा रहा है, मैं सहमत हूँ कि DRY का पालन करना एक अच्छा लक्ष्य है, जब व्यावहारिक हो।


Refactoring: मौजूदा कोड के डिजाइन में सुधार

तीन का नियम

पहली बार जब आप कुछ करते हैं, तो आप इसे करते हैं। दूसरी बार जब आप करते हैं
कुछ इसी तरह, आप डुप्लिकेट पर जीतते हैं, लेकिन आप डुप्लिकेट करते हैं
वैसे भी। तीसरी बार जब आप कुछ ऐसा ही करते हैं, तो आप रिफ्लेक्टर करते हैं।

तीन स्ट्राइक और आप रिफ्लेक्टर।

काम पर कोडर्स

सीबिल: तो इनमें से प्रत्येक XII कॉल के लिए आप एक कार्यान्वयन लिख रहे हैं।
क्या आपने कभी पाया कि आप बहुत समान कोड के बहुत सारे बिट्स जमा कर रहे थे?

Zawinski: ओह, हाँ, निश्चित रूप से। आमतौर पर आपके द्वारा काटे गए और चिपकाए गए दूसरी या तीसरी बार
कोड का वह टुकड़ा जैसा है, ठीक है, समय काटने और चिपकाने को रोकने के लिए और इसे एक सबरूटीन में डालने के लिए।