हम कुछ डेवलपर हैं जो एक ही परियोजना पर काम करते हैं और हम परियोजना के लिए गिट का उपयोग करते हैं। यदि हम में से दो या अधिक एक ही फाइल पर काम करते हैं, तो हमें गिट टकराव मिलते हैं जो कि मुश्किल से निपटने में मुश्किल होती है, कभी-कभी इन संघर्षों के दौरान एक डेवलपर द्वारा किए गए परिवर्तन खो जाते हैं।एक टीम में गिट संघर्ष से कैसे बचें?
वे एक टीम में गिट के साथ कैसे काम करते हैं? गिट संघर्ष से बचने के लिए उचित प्रवाह क्या होना चाहिए?
अग्रिम धन्यवाद।
इससे पहले कि आप अपने कार्यप्रवाह का गहराई से, इससे पहले कि आप समय का एक पल या पैसे अपने संचार प्रक्रियाओं के पुनर्निर्माण के लिए एक डॉलर खर्च करते हैं, अपनी टीम के तीन प्रश्न पूछें:
.sass या .scss फ़ाइलों से सीएसएस नियम उत्पन्न करते हैं, या फ्लाई पर एक्सएमएल कॉन्फ़िगरेशन बनाते हैं? क्या हम उन्हें चेक करते हैं?संघर्ष पैदा करने और अन्य लोगों को केंद्रीकृत कार्यप्रवाह में उन्हें हल के वर्षों के बाद, मैं इन तीन चीजों हमारे सामूहिक संघर्ष दर्द के विशाल बहुमत के कारण सबमिट करें:
उपरोक्त छवि में, '!'स्लाइस वैध विलय संघर्ष का प्रतिनिधित्व करता है। विशाल अधिकांश भयानक विलय आलसी सफेद जगहों के सम्मेलनों या अत्यधिक आक्रामक आईडीई (या कभी-कभी, अतिसंवेदनशील डेवलपर्स) से आते हैं। कुछ और करने से पहले, अपनी आईडीई सेटिंग्स और व्हाइटस्पेस सम्मेलनों को मानकीकृत करें। तब हर किसी को है उनके स्थानीय खजाने में इस आदेश जारी:
# Enable the repository's stock pre-commit hook
mv .git/hooks/pre-commit.sample .git/hooks/pre-commit
कि पूर्व प्रतिबद्ध हुक चेकों की एक श्रृंखला हर बार जब आप जारी git commit का संचालन करेंगे git diff --check का एक संस्करण, एक कमांड की जाँच करता है कि अगर आपके प्रतिबद्ध परिवर्तन शुरू सहित, व्हाइटस्पेस त्रुटियां। अगर ऐसा होता है तो प्रतिबद्धता खारिज कर दी जाएगी। यदि आपको वास्तव में इसके आसपास जाना है, तो आप git commit --no-verify जारी कर सकते हैं, लेकिन यह नहीं: व्हाइटस्पेस त्रुटियां संस्करण नियंत्रण के अनपेक्षित अध्यादेश की तरह हैं। वे होने वाले संघर्षों को विलय कर रहे हैं।
यदि आप व्हाइटस्पेस को साफ करना चाहते हैं, तो अपनी इंडेंटेशन में सुधार करने के लिए एक फ़ाइल को दोबारा दोहराएं, या अन्यथा पूरी तरह से स्वरूपण परिवर्तनों की एक बड़ी श्रृंखला बनाएं, इसे अलग-अलग कामों में करें, और टीम को अपने विरोधाभासी काम को पहले प्रगति में जांचने के लिए चेतावनी दें ।
आप कोड समीक्षा का संचालन करते हैं, तो ये पहले सवाल हर समीक्षक प्रश्नों को पूछने के: "इस परिवर्तन सेट स्पर्श कुछ भी यह किसी भी स्वरूपण को साफ किया नहीं होना चाहिए था क्या यह अनावश्यक रूप से एक विधि refactor किया??" अगर ऐसा हुआ, तो समीक्षा में असफल रहा। या यदि आप नहीं कर सकते हैं, तो सुनिश्चित करें कि आपके इतिहास को उपयोगी बनाने के लिए उन परिवर्तनों को तार्किक परिवर्तनों (यानी विभिन्न प्रतिबद्धताओं में) से पर्याप्त रूप से अलग किया गया है।
स्टाइलशीट भाषाएं, RequJS, और जेएस मिनीफायर भी विवाद पैदा करते हैं, यदि उनके जेनरेट किए गए लक्ष्य चेक किए जाते हैं। इन तकनीकों द्वारा बनाई गई फ़ाइलें कलाकृतियों का निर्माण करती हैं। आप एक युद्ध संग्रह में जांच नहीं करेंगे; SASS- संकलित सीएसएस फ़ाइल में जांच न करें। या, अगर आपको लगता है कि आपको गिट के रूप में द्विआधारी के रूप में व्यवहार करने के लिए .gitattributes file का उपयोग करना है।
यदि इन सभी चीजों को करने के बाद, आप अभी भी विवाद विवाद, संस्थान वर्कफ़्लो सुधारों को विलय कर चुके हैं। गैरी फिक्सलर का जवाब बिल्कुल सही है: वैध विलय संघर्ष उत्पन्न होते हैं क्योंकि टीम अपनी परियोजनाओं के दायरे के बारे में अच्छी तरह से संवाद नहीं कर सकती या नहीं कर सकती हैं। बस सुनिश्चित करें कि यह पहले खराब रूप से लागू प्रारूपण नियमों को लागू नहीं करता है।
अच्छा, वास्तव में ईमानदार होने के लिए, उचित वर्कफ़्लो में अच्छा संचार और प्रबंधन शामिल है। टीम के सदस्यों को अक्सर एक ही चीज़ पर काम नहीं करना चाहिए और संघर्ष पैदा करना चाहिए। दैनिक स्टैंडअप जैसी चीजें, और एक चौकस प्रबंधक जो जानता है कि टीम का प्रत्येक सदस्य कम से कम सामान्य रूप से क्या है - कई मामलों में इसे सीमित करने के लिए एक लंबा रास्ता तय करेगा।
यह निश्चित रूप से उत्पाद की सटीक प्रकृति पर निर्भर करता है, लेकिन यह एक गिट मुद्दे की तुलना में एक संगठनात्मक मुद्दा है। वास्तव में, संघर्ष अक्सर "अच्छी" चीजों के रूप में देखा जाता है, क्योंकि वे लोगों को अपने डेस्क से उठने के लिए कहते हैं, या एक-दूसरे को एक संघर्ष के बारे में बात करने के लिए कहते हैं, और आगे बढ़ने के बारे में क्या किया जाना चाहिए। यह पता लगाने का एक मौका है कि एक व्यक्ति को एक क्षेत्र, या फाइलों का एक सेट होना चाहिए, या कम से कम उस अनुभाग में परिवर्तनों पर चर्चा के लिए संपर्क बिंदु होना चाहिए।
अप-फ्रंट प्लान बनाने के बाहर, गिट टकराव से बचने का कोई तरीका नहीं है, लेकिन यह किसी भी संस्करण प्रणाली में एक ही समस्या होगी। किसी भी समय दो लोग कोड के समान अनुभाग को बदलते हैं, आपको यह पता लगाना होगा कि कौन जीतता है। यही कारण है कि समाधान के लिए संस्करणकर्ता की ओर देखना वास्तव में उचित नहीं है, बल्कि आपकी टीम के तरीकों और प्रथाओं को देखने के लिए। दो कारें एक ही समय में एक छेड़छाड़ से नहीं जा सकती हैं, लेकिन कारों का आविष्कार करना बेहद मुश्किल है जो एक-दूसरे से गुज़र सकते हैं, इसलिए हमने स्टॉप संकेतों और यातायात संकेतों के नियंत्रण तंत्र का आविष्कार किया। यह एक समान मुद्दा है। हम वास्तव में एक ही चीज़ में दो बदलाव नहीं कर सकते हैं जो संघर्ष नहीं करते हैं, इसलिए हमें यह नियंत्रित करना होगा कि हम फ़ाइलों के साथ कैसे काम करते हैं।
आप सामने वाले सिरों में से एक पर विचार करें जो गिट में लॉकिंग की अनुमति देता है, लेकिन मैं वास्तव में अवधारणा से सहमत नहीं हूं, गैर-विलय करने योग्य फ़ाइल प्रकारों के बाहर। मुझे लगता है कि एक बेहतर टीम वर्कफ़्लो को समझना बेहतर है, और इस बीच, इसे फ़ाइलों को विलय करने में वास्तव में अच्छा होने का अवसर के रूप में उपयोग करें। मैंने ऐसा किया, और अब इसे करने के महीनों के बाद, संघर्ष मेरे लिए एक परेशान चीज नहीं है।
विवादों से बचने के लिए केवल एक ही रास्ता है: अलग-अलग लोग एक ही समय में एक ही फ़ाइल को संपादित नहीं करते हैं। अनिवार्य रूप से प्रत्येक फ़ाइल में एक स्वामी होता है जो सभी संपादनों के लिए ज़िम्मेदार होता है और जो दूसरे को स्वामित्व पास कर सकता है। किसी फ़ाइल के लिए स्वामित्व किसी विशेष सुविधा/शाखा या दिन-प्रति-दिन के आधार पर पारित किया जा सकता है जब तक स्वामित्व स्पष्ट हो।
आप पाते हैं कि आप तो प्रत्येक फाइल करने के लिए एक मालिक नहीं दे सकता:
कुछ और चीजें हैं जो आप कर सकते हैं जो भी मदद कर सकती हैं। अगर मैं उन्हें अलग से पोस्ट करता हूं तो यह स्पष्ट होगा।
जहां आप नई चीजें डालते हैं, यह निर्धारित करने में मदद करेगा कि आप संघर्ष बनाते हैं या नहीं।
कर्मचारियों
Andy,
Oliver,
Ivan,
तब ब्राड और पैट्रिक में शामिल होने और उनके नाम सूची में जुड़ जाते के नामों की सूची की कल्पना करें। आप ब्रैड जोड़ते हैं और मैं पैट्रिक जोड़ता हूं। हम दोनों सूची के नीचे नाम जोड़ते हैं, और फिर हमारी सूचियों को मर्ज करने के लिए गिट का उपयोग करते हैं। परिणाम Git उपयोगकर्ताओं के लिए परिचित होंगे: -
Merge branch 'Patrick' into Brad
Conflicts:
names.txt
@@@ -1,4 -1,4 +1,8 @@@
Andy,
Oliver,
Ivan,
<<<<<<< HEAD
+Brad,
=======
+ Patrick,
>>>>>>> Patrick
अब मान लीजिए कि हम एक ही बात किया था लेकिन हमारी सूची पर एक सरल वर्णमाला आदेश शासन लगाया गया। अब जब हम दो शाखाओं को मर्ज करने के लिए आते परिणामों के एक छोटे से अधिक भाता है: -
Andy,
Ivan,
Oliver,
एक नाम अपने आप को जोड़ें और फिर Git के साथ दूसरे व्यक्ति के परिवर्तन मर्ज करते हैं, अन्य नाम जोड़ने के लिए।
Auto-merging names.txt
Merge made by the 'recursive' strategy.
names.txt | 1 +
1 file changed, 1 insertion(+)
और हम
Andy,
Brad,
Ivan,
Oliver,
Patrick,
के बाद से हम नहीं जानते कि जो कंपनी अगले हम प्रभावी रूप से बेतरतीब ढंग से सूची में जोड़ रहे हैं में शामिल होने के लिए जा रहा है मिलता है, और यादृच्छिक स्थानों में डालने से, स्थान के संघर्ष फाइलों में कम संभावना है। संलग्न ब्लॉक
इस तरह सॉफ्टवेयर में शुरू होता है ...
function chess()
{
while (!end_of_game)
{
make_move()
लाइनों ब्रेसिज़ आसानी से सॉफ्टवेयर में अन्य लाइनों ही छिद्र ब्रेसिज़ से मिलकर साथ भ्रमित होने जा रहे हैं खोलने के साथ ब्लॉक शुरू करने । एक ही सॉफ्टवेयर इस तरह लिखा हुआ हो तो ब्लॉक जोड़कर पिछले लाइनों के लिए शुरू होता है ...
function chess() {
while (!end_of_game) {
make_move()
जो मैं व्यक्तिगत रूप से पसंद नहीं है, लेकिन Git करता है, वहाँ बहुत सारे कम लाइनों है कि जैसे ही लगते हैं गिट करें और एक-दूसरे के लिए गलत हो जाएं, यानी गिट को संपादन के समान तरीके से समझने की संभावना है, जिससे किसी भी संघर्ष को सुलझाना आसान हो जाता है।
उपयोग टिप्पणियों पर टिप्पणी समान लग रही लाइनों अलग पहचाना जा सके।
यदि आप बहुत सारी जावास्क्रिप्ट और JSON लिखते हैं, तो आपके पास बहुत सी रेखाएं दिखाई दे सकती हैं जो इस तरह की दिखती हैं।
}
}
}
)
यदि आप चीजों पर टिप्पणी करते हैं तो वे अलग-अलग हो सकते हैं।
}
}
}
) // end of weekdays()
और
}
}
}
) // end of weekend()
नहीं रह गया है git करने के लिए ही दिखते हैं। यह आपके परिवर्तनों को बेहतर ढंग से समझने में गिट की सहायता कर सकता है।आप कुछ जोड़ते हैं, जैसे
function a()
{
...
} // end of a()
Git, और अधिक देखने के लिए कि परिवर्तन की एक इकाई के रूप में होने की संभावना है और सोच भी नहीं तुम सिर्फ कुछ अन्य समारोह के अंत से पहले की तरह
}
function a()
{
...
कुछ जोड़ लिया है। यहां तक कि जब यह विवादों को रोकता नहीं है, यदि गिट आपके परिवर्तनों को समझदारी से देखता है और प्रस्तुत करता है (यानी जिस तरह से हम मानसिक रूप से उन्हें देखते हैं), तो आप शायद संघर्षों को आसानी से हल कर सकते हैं। एक वर्णनात्मक हेडर टिप्पणी करता है कि कौन से फ़ंक्शन करते हैं, वे जो पैरामीटर लेते हैं, आदि, गिट को पड़ोसी कार्यों की सामग्री को एक साथ जोड़ने से रोकने में मदद करेंगे।
संस्करण नियंत्रण में विवादों की संख्या को कम करने के लिए जो संपादन कर रहा है, इस बारे में चिंता किए बिना, आपको बस छोटे बदलाव करने और उन्हें बढ़ाने/उन्हें बढ़ाने की आवश्यकता है। समस्या को छोटे टुकड़ों में विभाजित करें जिन्हें आप जल्दी फ़ाइलों को संशोधित कर सकते हैं और उन्हें वापस ट्रंक पर धक्का दे सकते हैं। आपकी शाखाएं कम थीं, संघर्षों को मर्ज करने का कम मौका होगा।
फिर भी, किसी बिंदु पर दो लोग एक ही फाइल को एक ही समय में अपनी गलती के बिना संपादित करेंगे। जब ऐसा होता है तो स्पष्ट प्रश्न यह है:
"मैं गिट संघर्षों को हल करने में दर्द कैसे उठा सकता हूं?"
उत्तर यह है कि आपको ट्रंक खींचना चाहिए और अपनी शाखा को बार-बार फिर से दबा देना चाहिए, और आप जितनी जल्दी हो सके विवादों को देखेंगे, जबकि वे अभी भी छोटे हैं। इस बिंदु पर दोनों डेवलपर्स को एक साथ बैठना चाहिए और आगे बढ़ने के लिए सबसे अच्छे तरीके से चर्चा करना चाहिए, जबकि उनके दिमाग में बदलाव ताजा हैं।
रिलीज की समयसीमा से पहले एक आतंक में बड़ी लंबी अवधि की शाखाओं पर संघर्ष सुलझाने की कोशिश करने के साथ इस दृष्टिकोण की तुलना करें, जब डेवलपर्स कुछ समय पहले किए गए सभी परिवर्तनों के पीछे सोच को याद रखने के लिए संघर्ष करते हैं।
एक और तरीका है संघर्ष के दर्द को कम करने धकेल दिया सहयोगियों को सूचित करने के लिए जब आप अपने परिवर्तन धकेल दिया बस है। यह उन्हें आपके परिवर्तन खींचने और वहां कुछ संघर्षों को हल करने की अनुमति देता है। किसी भी विवाद आपके हालिया परिवर्तन, आपके दिमाग में ताजा और उनके दिमाग में ताजा काम करने के बीच होने की संभावना है।
यदि लोग बड़े शाखा से परिवर्तन नहीं खींचते हैं, तब तक जब तक वे बड़े विकास को पूरा नहीं कर लेते हैं और फिर एक ही क्षेत्र में कई लोगों द्वारा किए गए परिवर्तनों के साथ संघर्ष करते हैं, तो इसे हल करना कठिन होगा।
की Git के उद्देश्य के संस्करण नियंत्रण है एक। अन्य कार्यक्रम फाइलों को विलय करने और संघर्षों को हल करने में विशेषज्ञ हैं। यदि आप गिट के साथ उपयोग करने के लिए एक मेरेटूल को कॉन्फ़िगर करते हैं, तो यह कई मुद्दों को स्वचालित रूप से हल कर सकता है जो गिट को संघर्ष के रूप में मानते हैं, या कम से कम आपके लिए निरीक्षण करने के लिए बहुत अच्छा अनुमान लगाते हैं और अगर यह ठीक दिखता है तो बस छूटे रहें, या आप टूल पर भरोसा करते हैं ।
इससे कम वास्तविक संघर्ष छोड़ते हैं जिन्हें समाधान के लिए एक बुद्धिमान निर्णय की आवश्यकता होती है।
मैं mycontrollers के तल पर एक नया नियंत्रक जोड़ें।जेएस और आप के नीचे एक नया नियंत्रक जोड़ें yourcontrollers.js: कोई समस्या नहीं।
हम दोनों allcontrollers.js: संघर्ष के नीचे एक नया नियंत्रक जोड़ते हैं।
(हालांकि चीजों को क्रमबद्ध रूप से ऑर्डर करने के बारे में सलाह याद रखें। एम के साथ शुरू होने वाला मेरा न्यूकंट्रोलर() फ़ाइल के बीच में जा सकता है और वाई के साथ शुरू होने वाला आपका न्यू कंट्रोलर() उसी फ़ाइल के अंत में जा सकता है, फिर बिना किसी संघर्ष के ।)
गिट के कई संस्करण (यानी मैंने जो भी संस्करण उपयोग किया है, जहां तक मुझे पता है) यूटीएफ -16 फाइलों को एक सामान्य यूटीएफ -16 टेक्स्ट फ़ाइल में कई शून्य बाइट्स की उपस्थिति के कारण बाइनरी फाइलों के रूप में पेश कर सकते हैं।
एक बार गिट सोचता है कि एक फ़ाइल एक द्विआधारी फ़ाइल है, तो यह फ़ाइल को बाइनरी फ़ाइल के रूप में बदलने पर भी ध्यान देने की संभावना है। इसका अर्थ यह है कि संस्करण नियंत्रण उनके बीच मतभेदों के बजाय फ़ाइल के पूर्ण संस्करणों को संग्रहीत करके किया जाता है और संस्करण नियंत्रण प्रणाली के कुछ फायदे खो जाते हैं। (संपादित करें: नहीं। मैंने हाल ही में यूटीएफ -16 फाइल को यूटीएफ -8 में बदलकर इसे संपादित करके, इसे संपादित करने और फिर से काम करके इसका परीक्षण किया - और मूल और संपादित फाइलें यूटीएफ -8 दोनों के बाद परिवर्तनों के रूप में परिवर्तनों को बदलना शुरू कर दिया।)
अधिकांश आधुनिक संपादक एक फ़ाइल की वर्ण एन्कोडिंग और लाइन समाप्ति शैली को पहचानेंगे और फ़ाइल को उसी प्रारूप में सहेज लेंगे। कुछ संपादकों (उदाहरण के लिए बेबेलपैड) आपको यह चुनने की अनुमति देगा कि क्या आप अपनी फ़ाइल को यूटीएफ -8 या यूटीएफ -16 में सहेजते हैं, और बाइट ऑर्डर मार्क के साथ या बिना
यदि फ़ाइल आप संस्करण नियंत्रण करना चाहते हैं (i) यूटीएफ -16 प्रारूप में और (ii) यूटीएफ -8 में समान रूप से अच्छी तरह से काम करेगा - उदाहरण के लिए एक सभ्य आधुनिक कंपाइलर के लिए एक स्रोत कार्यक्रम - यह यूटीएफ -8 में परिवर्तित करने पर विचार करने योग्य है।
यदि गिट सोचता है कि आपका स्रोत टेक्स्ट अपनी पहली प्रतिबद्धता से पहले एक बाइनरी फ़ाइल है, तो इसे देखें और देखें कि यह एक संपादक में लोड करने के लायक है और इसे एक अलग प्रारूप में सहेजने के लिए है जिसे गिट टेक्स्ट के रूप में पहचानता है।
(नोट। लिनक्स फाइलें डिफ़ॉल्ट रूप से यूटीएफ -8 होती हैं। कुछ विंडोज प्रोग्रामों में यूटीएफ -16 बनाने की आदत थी। इसलिए यह विंडोज उपयोगकर्ता हैं जिनके पास समस्या होने की संभावना है। यह भी ध्यान रखें कि आप सही करना चाहते हैं इस से पहले बहुत पहले, फ़ाइल के लिए प्रतिबद्ध से पहले Git मानना है कि यह एक बाइनरी फ़ाइल है!)
पुन: उपयोग संकल्प रिकॉर्ड किया गया!
मैं अपने दिल में snark के साथ इस सवाल के लिए आया था, और तुम मेरे साथ कितना अच्छा अपने जवाब था पर जीत हासिल की! –
महान उत्तर के लिए धन्यवाद :) – Dev01