एक बड़ी फ़ाइल को रीफ्रैक्ट करने का सबसे अच्छा तरीका क्या है?


41

मैं वर्तमान में एक बड़ी परियोजना पर काम कर रहा हूं, जिसमें दुर्भाग्य से कुछ फाइलें हैं जहां सॉफ्टवेयर गुणवत्ता दिशानिर्देश जहां हमेशा पीछा नहीं करते हैं। इसमें बड़ी फाइलें (2000-4000 लाइनें पढ़ें) जिसमें स्पष्ट रूप से कई अलग-अलग कार्य शामिल हैं।

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

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

तो क्या रिफ्लेक्टर करने का एक तरीका है, किसी और को काम करने से रोकने के लिए (लंबे समय तक) की आवश्यकता नहीं है या अपनी सुविधा शाखाओं को विकसित करने के लिए वापस मर्ज करना है?


6
मुझे लगता है कि यह इस्तेमाल की गई प्रोग्रामिंग भाषा पर भी निर्भर करता है।
रॉबर्ट एंड्रजुक

8
मुझे "छोटे वृद्धिशील" चेकिन पसंद हैं। जब तक कोई रेपो की अपनी कॉपी को ताजा नहीं रखता है, तब तक यह अभ्यास सभी के लिए मर्ज टकराव को कम करेगा।
मैट रफ़ेल

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

1
ऐसे कई दृष्टिकोण हैं जो आप इस के साथ ले सकते हैं और सबसे अच्छा दृष्टिकोण आपकी स्थिति पर निर्भर करेगा।
स्टीफन

3
मैं उस परियोजना में शामिल हो गया जहाँ सबसे बड़ी फ़ाइल 10k लाइनों की है जिसमें अन्य वर्ग हैं जो खुद 6k लंबी हैं और हर कोई इसे छूने से डरता है। मेरा मतलब यह है कि आपका प्रश्न महान है। हमने एक चुटकुला का भी आविष्कार किया कि यह एकल वर्ग हमारे पति या पत्नी में स्क्रॉल व्हील को अनलॉक करने का एक अच्छा कारण है।
एल्मोवैन किल्मो

जवाबों:


41

आप सही ढंग से समझ गए हैं कि यह एक सामाजिक समस्या के रूप में इतना तकनीकी नहीं है: यदि आप अत्यधिक मर्ज संघर्ष से बचना चाहते हैं, तो टीम को इस तरह से सहयोग करने की आवश्यकता है जो इन संघर्षों से बचा जाए।

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

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

यह आपकी तात्कालिक समस्या के लिए बहुत अधिक हो सकता है। लेकिन सहकर्मियों को अपने परिवर्तनों को मर्ज करने के लिए कहना संभव हो सकता है जो इस फ़ाइल को सप्ताह के अंत तक प्रभावित करते हैं ताकि आप रिफैक्टरिंग कर सकें। यदि वे अधिक समय तक प्रतीक्षा करते हैं, तो उन्हें स्वयं मर्ज संघर्ष से निपटना होगा। यह असंभव नहीं है, यह सिर्फ परिहार्य काम है।

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

  1. एक अलग मॉड्यूल में कार्यक्षमता निकालें।
  2. अपने कॉल को नए एपीआई में अग्रेषित करने के लिए पुराने कार्यों को बदलें।
  3. समय के साथ, नए API में पोर्ट डिपेंडेंट कोड।
  4. अंत में, आप पुराने कार्यों को हटा सकते हैं।
  5. (कार्यक्षमता के अगले समूह के लिए दोहराएं)

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

लेकिन अंत में, किसी भी समाधान के लिए आपको अपनी टीम के साथ समन्वय करना होगा।


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

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

1
@Laiv मेरे अनुभव में, यह पहले से टीम के साथ पोस्ट-रीफैक्टरिंग डिज़ाइन पर चर्चा करने के लिए समझ में आता है, लेकिन आमतौर पर यह आसान होता है अगर कोई व्यक्ति कोड में बदलाव करता है। अन्यथा, आप उस समस्या पर वापस आ गए हैं जिसमें आपको सामान को मर्ज करना होगा। 4k लाइन्स बहुत लगती हैं, लेकिन यह वास्तव में एक्सट्रेक्ट-क्लास जैसी लक्षित रिफ्लेक्टरिंग के लिए नहीं है । (मैं इतनी मेहनत से यहाँ मार्टिन फाउलर की पुनर्रचना पुस्तक shill हैं तो मैं इसे पढ़ा था।) लेकिन 4k लाइनों है केवल के लिए एक बहुत अलक्षित की तरह "देखते हैं मैं यह कैसे सुधार कर सकते हैं करते हैं" refactorings।
एमन

1
@DanLyons सिद्धांत रूप में आप सही हैं: जो विलय के कुछ प्रयासों को फैला सकते हैं। व्यवहार में, Git का विलय शाखाओं के विलय के नवीनतम सामान्य पूर्वजों की प्रतिबद्धता पर बहुत कुछ निर्भर करता है । मास्टरिंग में विलय → सुविधा हमें मास्टर पर एक नया सामान्य पूर्वज नहीं देती है, लेकिन विलय की सुविधा → मास्टर करता है। बार-बार मास्टर → फीचर मर्ज के साथ, ऐसा हो सकता है कि हमें एक ही संघर्ष को बार-बार हल करना होगा (लेकिन इसे स्वचालित करने के लिए गिट रीरे देखें)। रिबासिंग यहां कड़ाई से बेहतर है क्योंकि मास्टर की नोक नए सामान्य पूर्वज बन जाते हैं, लेकिन इतिहास पुनर्लेखन में अन्य मुद्दे हैं।
दोपहर

1
इसका उत्तर मेरे लिए ठीक है, सिवाय रेंट के मेरे बारे में कि इसे शाखा में लाना बहुत आसान है, और इस प्रकार देव शाखा भी अक्सर। मुझे अच्छी तरह से एसवीएन और यहां तक ​​कि सीवीएस का समय याद है जब ब्रांचिंग कठिन थी (या कम से कम बोझिल) पर्याप्त थी कि लोग आमतौर पर सभी संबंधित समस्याओं के साथ यदि संभव हो तो इसे टाल देते थे। गिट में, एक वितरित प्रणाली होने के नाते, कई शाखाएं होना वास्तव में कई अलग-अलग रिपॉजिटरी होने के अलावा कुछ भी नहीं है (यानी, प्रत्येक देव पर)। समाधान कहीं और निहित है, शाखा के लिए आसान होना समस्या नहीं है। (और हाँ, मैं देख रहा हूँ कि यह एक तरफ है ... लेकिन अभी भी)।
एओई

30

छोटे चरणों में रीफैक्टरिंग करें। मान लीजिए कि आपकी बड़ी फ़ाइल का नाम है Foo:

  1. एक नई खाली फ़ाइल जोड़ें Bar, और इसे "ट्रंक" के लिए प्रतिबद्ध करें।

  2. उस कोड का एक छोटा भाग खोजें Fooजिसमें ले जाया जा सकता है Bar। चाल को लागू करें, ट्रंक से अपडेट करें, कोड का निर्माण करें और परीक्षण करें, और "ट्रंक" के लिए प्रतिबद्ध करें।

  3. चरण 2 को तब तक दोहराएं Fooऔर Barउसका आकार समान हो (या जो भी आकार आपको पसंद हो)

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

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

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


2
यह rerereसक्षम विशेष रूप से उपयोगी है
गिट्स

@ D.BenKnoble: इसके अलावा के लिए धन्यवाद। मुझे स्वीकार करना होगा, मैं एक गिट विशेषज्ञ नहीं हूं (लेकिन वर्णित समस्या जीआईटी के लिए विशिष्ट रूप से नहीं है, यह किसी भी वीसीएस पर लागू होता है जो ब्रांचिंग की अनुमति देता है, और मेरा जवाब उन प्रणालियों में से अधिकांश के लिए फिट होना चाहिए)।
डॉक्टर ब्राउन

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

18

आप फ़ाइल को परमाणु ऑपरेशन के रूप में विभाजित करने के बारे में सोच रहे हैं, लेकिन ऐसे मध्यवर्ती परिवर्तन हैं जो आप कर सकते हैं। फ़ाइल समय के साथ धीरे-धीरे विशाल हो गई, यह धीरे-धीरे समय के साथ छोटी हो सकती है।

एक ऐसा हिस्सा चुनें, जिसे लंबे समय में बदलना नहीं है (इससे git blameमदद मिल सकती है), और पहले उसे अलग कर दें। उस परिवर्तन को सभी की शाखाओं में मिला दें, फिर विभाजित करने के लिए अगला सबसे आसान हिस्सा चुनें। हो सकता है कि एक भाग को विभाजित करना भी एक बड़ा कदम हो और आपको पहले बड़ी फ़ाइल के भीतर कुछ पुनर्व्यवस्थित करना चाहिए।

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

विचार धीरे-धीरे अपने लक्ष्य की ओर बढ़ना है। ऐसा लगेगा कि प्रगति धीमी है, लेकिन फिर अचानक आपको महसूस होगा कि आपका कोड बहुत बेहतर है। एक महासागर लाइनर को चालू करने के लिए एक लंबा समय लगता है।


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

9

मैं इस समस्या के सामान्य समाधान से अलग सुझाव देने जा रहा हूं।

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

आप इसके लिए एक विशिष्ट राशि निर्धारित करना चाह सकते हैं, ताकि दृष्टि में कोई अंत न होने के साथ एक सप्ताह तक बहस न हो। इसके बजाय, यह एक साप्ताहिक 1-2 घंटे की घटना भी हो सकती है जब तक कि आप सभी चीजों को नहीं देख रहे हैं कि यह कैसे होना चाहिए। हो सकता है कि आपको फ़ाइल को रिफलेक्टर करने के लिए केवल 1-2 घंटे की आवश्यकता हो। जब तक आप कोशिश नहीं करेंगे, तब तक आपको पता नहीं चलेगा।

इससे सभी को लाभ होता है कि रिफैक्टरिंग के साथ एक ही पृष्ठ पर (कोई भी इरादा नहीं), लेकिन यह आपको गलतियों से बचने के साथ-साथ यदि संभव हो तो बनाए रखने के लिए संभावित विधि समूहों के बारे में दूसरों से इनपुट प्राप्त करने में भी मदद कर सकता है।

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

यह सभी स्थितियों, टीमों या कंपनियों में काम नहीं कर सकता है, क्योंकि यह काम इस तरह से वितरित नहीं किया जाता है जिससे यह आसानी से होता है। यह (गलत तरीके से) देव समय के दुरुपयोग के रूप में भी हो सकता है। इस समूह कोड को प्रबंधक के साथ-साथ रिफ्लैक्टर से भी खरीदने की आवश्यकता है।

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

एक बार जब आप इस तरह से एक फ़ाइल को पुनः प्राप्त कर लेते हैं, तो आप अधिक आसानी से अधिक रिफैक्टर्स के लिए अनुमोदन प्राप्त करने में सक्षम हो सकते हैं, अगर यह सफल और उपयोगी था।

हालाँकि आप अपना रिफ्लेक्टर, शुभकामनाएँ तय करते हैं!


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

+1 कोड भीड़ के सुझाव के लिए
जॉन रेन्नोर

1
यह वास्तव में समस्या के सामाजिक पहलू को संबोधित करता है।
च्च्कॉट्रिल

4

इस समस्या को ठीक करने के लिए अन्य टीमों से खरीद-इन की आवश्यकता होती है क्योंकि आप एक साझा संसाधन (स्वयं कोड) को बदलने का प्रयास कर रहे हैं। यह कहा जा रहा है, मुझे लगता है कि लोगों को बाधित किए बिना विशाल अखंड फाइलों के होने से "पलायन" करने का एक तरीका है।

मैं एक बार में सभी विशाल फ़ाइलों को लक्षित नहीं करने की भी सिफारिश करूंगा जब तक कि बड़ी फ़ाइलों की संख्या व्यक्तिगत फ़ाइलों के आकार के अलावा अनियंत्रित रूप से बढ़ रही हो।

इस तरह की बड़ी फ़ाइलों को फिर से लाना अप्रत्याशित समस्याओं का कारण बनता है। पहला कदम बड़ी फ़ाइलों को अतिरिक्त कार्यक्षमता को जमा करने से रोकना है जो वर्तमान में मास्टर या विकास शाखाओं में है

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

प्रतिबद्ध हुक नई कक्षाओं के लिए जाँच कर सकता है या अन्य स्थैतिक विश्लेषण (तदर्थ या नहीं) कर सकता है। आप केवल एक पंक्ति या वर्ण गणना चुन सकते हैं जो वर्तमान में फ़ाइल से 10% बड़ी है और कहते हैं कि बड़ी फ़ाइल नई सीमा से आगे नहीं बढ़ सकती है। आप अलग-अलग कमिट्स को भी अस्वीकार कर सकते हैं जो बड़ी फाइल को बहुत सारी लाइनों या बहुत सारे अक्षरों या w / e द्वारा बढ़ाते हैं।

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

आखिरकार, बड़ी फाइलें इतनी छोटी होंगी कि कमिट हुक पूरी तरह से हटा दिया जा सकता है।


-3

गृहनगर तक प्रतीक्षा करें। फ़ाइल को विभाजित करें, कमिट करें और मास्टर में विलय करें।

अन्य लोगों को किसी भी अन्य परिवर्तन की तरह सुबह अपनी फीचर शाखाओं में बदलाव को खींचना होगा।


3
हालांकि इसका मतलब यह होगा कि उन्हें अपने परिवर्तनों के साथ मेरे रिफैक्टोरिंग को मर्ज करना होगा ...
Hoff


1
ठीक है, उन्हें वास्तव में वैसे भी विलय से निपटना होगा यदि वे सभी इन फ़ाइलों को बदल रहे हैं।
लाईव

9
यह "आश्चर्य की समस्या है, मैंने आपका सारा सामान तोड़ दिया।" ओपी को ऐसा करने से पहले खरीदने और अनुमोदन प्राप्त करने की आवश्यकता है, और इसे एक निर्धारित समय पर करना है कि किसी और के पास "प्रगति में" फ़ाइल नहीं है।
कंप्यूटरकार्गी

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