बहुत अधिक ओवरहेड के बिना सार्थक तरीके से कोडिंग प्रगति को विभाजित करना


23

एक फिक्स या एक फीचर पर काम करते समय, मैं कभी-कभी अन्य छोटे मुद्दों पर ठोकर खाता हूं, जो कुछ सेकंड में मक्खी पर सुधारा जा सकता है। जब मैं उन्हें तुरंत करता हूं और फिर तैयार फीचर / फिक्स करता हूं, तो कमिट में एक से अधिक चीजें शामिल होती हैं। उदाहरण के लिए "add feature X and code clean up"या "fix bug X and improved logging"। इसे दो कमिट में विभाजित करना बेहतर होगा। यदि एक ही फ़ाइल में दो परिवर्तन हुए हैं, तो मैं केवल एक फ़ाइल नहीं जोड़ सकता, कमिट कर सकता हूँ, दूसरे को जोड़ सकता हूँ और फिर दोबारा कर सकता हूँ। इसलिए मुझे निम्नलिखित तीन विकल्प दिखाई देते हैं:

  1. किसी चीज पर काम करते समय गैर-संबंधित चीजों को जानबूझकर अनदेखा करें।

  2. फ़ाइल को दो परिवर्तनों के साथ कॉपी करें, इसे वापस लाएं, इसमें एक बदलाव शामिल करें, कमिट करें, दूसरा बदलाव शामिल करें, फिर से कमिट करें।

  3. छोटी असंबंधित चीज़ों को न बदलें बल्कि उन्हें टूडू सूची में जोड़ें और बाद में उन्हें करें।

निम्नलिखित कारणों से मुझे वास्तव में तीनों विकल्प पसंद नहीं हैं:

  1. यदि कोई छोटी समस्याओं को ठीक नहीं करता है तो कोड की गुणवत्ता को नुकसान हो सकता है। और मुझे बुरा लगता है अगर मैं जानबूझकर बहुत प्रयास किए बिना कुछ सुधारने का मौका चूक जाता हूं।

  2. यह मैनुअल काम को बढ़ाता है और त्रुटि प्रवण होता है।

  3. यह छोटे-छोटे टॉडोस के लिए ठीक है, लेकिन एक टूडू सूची में एक छोटी वस्तु को जोड़ना और बाद में इसे फिर से बनाना अक्सर इसे तुरंत ठीक करने की तुलना में बहुत अधिक समय लगता है।

आप ऐसी स्थितियों को कैसे संभालते हैं?


7
क्या आपको संपूर्ण फ़ाइलों के बजाय व्यक्तिगत लाइनों में जांच करने की अनुमति नहीं है?
किलन फ़ॉथ


मैं git add -pएक बहुत का उपयोग करता हूं जो मुझे अंतःक्रियात्मक रूप से उन फ़ाइलों के भागों का चयन करने देता है जो मैं करना चाहता हूं। यदि सफाई पर्याप्त रूप से अलग है, तो यह करना आसान है। यदि जुदाई अधिक कठिन है, तो मैं एक अस्थायी शाखा पर राज्य को प्रतिबद्ध करता हूं, फिर मैन्युअल रूप से मेरी वास्तविक शाखा में परिवर्तन जोड़ें जब तक कि अस्थायी शाखा में कोई अंतर न हो। इसके लिए बहुत अधिक काम करने की आवश्यकता है, लेकिन मुझे यह जांचने की अनुमति देता है कि प्रत्येक प्रतिबद्ध अपने आप काम करता है।
आमोन

1
@ नागट: जाहिर है कि कोई ठग नहीं है। ओपी एक कमिट के सही आकार के बारे में नहीं पूछ रहा है - वह छोटे-छोटे काम करना चाहता है। वह ऐसा करने के लिए अधिक कुशल तरीके की तलाश में है।
डॉक्टर ब्राउन

2
@gnat: शीर्ष उत्तर कुछ भी नहीं (!) कहते हैं कि कैसे एक फाइल में विभिन्न परिवर्तनों को संभालना है और कैसे उन्हें अलग-अलग कमिट में विभाजित करना है।
डॉक्टर ब्राउन

जवाबों:


11

मुझे लगता है कि प्रोग्रामिंग करते समय आपको बहुत व्यावहारिक होना चाहिए। यहां तक ​​कि अगर यह सही योजना, वर्कफ़्लो, या कार्यान्वयन तैयार करना संभव हो सकता है, तो कभी-कभी आपको बस काम करने की आवश्यकता होती है। यहाँ मैं क्या कर रहा हूँ:

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

जब असंबंधित परिवर्तन बहुत बड़ा है, तो मैं इसे टूडू सूची में डालूंगा, और आमतौर पर इसे सही समय पर ले जाऊंगा, जबकि मेरे दिमाग में यह ताजा होगा। कभी-कभी इसे वापस लेने से पहले मुझे एक या दो दिन लग सकते हैं, यह मेरे वर्तमान कार्य और विचार की ट्रेन पर निर्भर करता है। कभी-कभी मैं केवल एक TODO लगाऊंगा: यदि आप एक अच्छा समाधान तैयार नहीं करते हैं, तो अपमानजनक कोड के बगल में।

ऐसा होता है कि चीजों को अलग करना व्यावहारिक नहीं है और मैं मूल काम के साथ-साथ मामूली समायोजन भी करूंगा।

जब मैं जाने के लिए मार्ग चुनता हूं, तो परिवर्तन का आकार आमतौर पर निर्धारित करने वाला कारक होता है, लेकिन अंत में मैं बहुत अधिक वर्कफ़्लो नियम की उपेक्षा करूंगा, बजाय एक गंध को पीछे छोड़ने के।


7

मेरे संपादक के पास एक प्लगइन है जो फ़ाइल के अलग-अलग हिस्सों को बेहद आसान बनाता है। मुझे लगता है कि अन्य प्रोग्रामर संपादकों के पास समान प्लगइन्स हो सकते हैं, हालांकि आप हमेशा इसे मैनुअल तरीके से कर सकते हैं git add --patch | -p। फिर मैं अलगाव में अपनी छोटी सी प्रतिबद्धता का परीक्षण करने के लिए अपने अन्य परिवर्तनों को बचाने के लिए गिट स्टैश का उपयोग करता हूं। उसके बाद जब मैं कमिट करता हूं, तो मैं सिर्फ एक करता हूं git stash popऔर जहां मैं छोड़ता हूं, जारी रखता हूं। ठीक यही उन विशेषताओं के लिए डिज़ाइन किया गया था।


2

जब तक आप बदलाव के हकदार नहीं हैं, तब तक बदलाव करने के लिए ट्रिक नहीं है।

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

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


1
ओपी ने दो बदलावों को एक कमिट में मिलाने का सुझाव नहीं दिया, जो कि बिल्कुल विपरीत था।
डॉक्टर ब्राउन

1
@DocBrown वह एक ही शाखा में 2 परिवर्तनों को मिलाने का सुझाव देता है, हालांकि, बाद में उसे अनसुना करने के लिए गन्दा हो सकता है, हालांकि स्पष्ट रूप से एक ही प्रतिबद्ध में 2 परिवर्तन के रूप में गन्दा नहीं है।
gbjbaanb 15

ठीक है, मैं देखता हूं कि आपके अंतिम पैराग्राफ के साथ आपके मन में क्या है।
डॉक ब्राउन

2

एक विकल्प जिसका उपयोग मैं बहुत कम करता हूं TODO, टिप्पणियों को जोड़ना है , फिर git add --patchफ़ाइल के संबंधित भागों का चयन करने के लिए बहुत से "आंशिक" कमिट करें। फिर git rebase --interactiveआंशिक फीचर को अंतिम फीचर में फिर से जोड़ने और विलय करने के लिए उपयोग करें और उन्हें पुश करने से पहले फिक्सअप करें।

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

git rebaseइस संदर्भ में कुछ भी गलत नहीं है क्योंकि आप केवल स्थानीय कमानों का पुनर्लेखन कर रहे हैं।


1

एक और विकल्प आपके वर्तमान परिवर्तनों को "गिट स्टैश" करने के लिए हो सकता है। वर्कफ़्लो इस तरह दिखेगा:

  1. फ़ीचर ए से संबंधित बदलाव करना शुरू करें
  2. डिस्कवर बग बी और तुरंत इसे ठीक करने का फैसला
  3. आपके रेपो प्रदर्शन में कमांड लाइन से git stash (जिसके बाद आपका कोड उस स्थिति में वापस आ जाएगा, जब आप फ़ीचर ए पर काम करना शुरू करने से पहले थे )
  4. इस बिंदु पर फ़ीचर A के लिए आपके अनपेक्षित परिवर्तन "stash" में संग्रहीत हैं
  5. बग बी को ठीक करने और रेपो में वापस करने के लिए कोड परिवर्तन आवश्यक करें
  6. कमांड लाइन रन से git stash pop
  7. फ़ीचर A के लिए आपके अनकैप्ड किए गए परिवर्तन अब स्लैश से बाहर हो गए हैं और बग बी के लिए प्रगति कोड के साथ आपके पास (पहले से प्रतिबद्ध) फिक्स में बहाल हो गए हैं

क्या आप थोड़ा और विस्तार कर सकते हैं कि यह वर्कफ़्लो कैसे काम करेगा? प्रत्येक बिंदु पर रिपॉजिटरी की स्थिति क्या है? क्या आप गिट स्टैश का उपयोग करने की प्रक्रिया के माध्यम से किसी को चला सकते हैं?

0

बग-फिक्स से संबंधित अलग-अलग चरण (और प्रतिबद्ध)। गेट एक्सटेंशन में, यह करना बहुत आसान है। कमांडलाइन से, मुझे लगता है कि आपको करने की आवश्यकता है git add -p

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.