%22%3E%3Cpath%20d%3D%22m-369%200h408v79h-408z%22%20fill%3D%22%237933ff%22%2F%3E%3Cpath%20d%3D%22m-148%200h306v45h-306z%22%20fill%3D%22%23974dff%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E)
%22%2F%3E%3C%2FclipPath%3E%3Cg%20clip-path%3D%22url(%23a)%22%3E%3Cpath%20d%3D%22m76%200h484v36h-484z%22%20fill%3D%22%23974dff%22%2F%3E%3Cpath%20d%3D%22m0%200h384v24h-384z%22%20fill%3D%22%2306bdfc%22%20transform%3D%22matrix(1%200%200%20-1%200%2060)%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E)
Git में मर्ज के प्रकार
Git मर्ज के प्रकार समझना आपके परिदृश्य के लिए सही रणनीति चुनने में मदद करता है। यहाँ मर्ज करने के तीन आम तरीके हैं।
फास्ट-फ़ॉरवर्ड मर्ज
जब बेस ब्रांच में फीचर ब्रांच बनने के बाद से कोई नया कमिट नहीं हुआ हो, तो Git फास्ट-फ़ॉरवर्ड तरीका अपनाता है।
यदि आपकी नई फीचर ब्रांच अपडेट हो गई है जबकि main ब्रांच अपरिवर्तित है, तो मर्ज main के हेड पॉइंटर को फीचर ब्रांच तक आगे बढ़ा देता है।
कोई अतिरिक्त मर्ज कमिट नहीं बनता, जिससे कमिट इतिहास साफ और रैखिक रहता है।
थ्री-वे मर्ज
यदि बेस और फीचर दोनों ब्रांचों में नए कमिट हैं, तो Git उनके सामान्य पूर्वज को ढूंढता है और एक नया मर्ज कमिट बनाता है। यह कमिट दोनों ब्रांचों के इतिहास को जोड़ देता है, जबकि फीचर और main दोनों की व्यक्तिगत हिस्ट्री सुरक्षित रहती है।
नीचे दिए उदाहरण में, “E” और “G” फीचर ब्रांच बनने के बाद main ब्रांच के नए कमिट हैं।
C---D---F (feature-branch)
/
A---B---E---G (main) एक नया मर्ज कमिट “M” बनता है, जो main और फीचर ब्रांच—दोनों का इतिहास सुरक्षित रखता है।
C---D---F
/ \
A---B---E---G---M (main)स्क्वैश मर्ज
स्क्वैश मर्ज किसी फीचर ब्रांच के सभी बदलावों को एक ही कमिट में समेटता है और उसे टारगेट ब्रांच में मर्ज कर देता है। यह फीचर ब्रांच के व्यक्तिगत कमिट इतिहास को संरक्षित नहीं करता।
git merge --squash feature_branch_nameस्क्वैश मर्ज विशेष रूप से तब उपयोगी है जब आप कई छोटे-छोटे कमिट से पैदा होने वाली अव्यवस्था से बचना चाहते हैं, जबकि टारगेट ब्रांच में फीचर की अंतिम स्थिति बनी रहती है।
एकाधिक ब्रांचों को मर्ज करना
बड़े प्रोजेक्ट्स पर काम करते समय, आपको कई ब्रांचों को मर्ज करने की ज़रूरत पड़ सकती है—या तो एक-एक करके या एक साथ। आपका तरीका आपके वर्कफ़्लो और बदलावों की जटिलता पर निर्भर करता है। इस सेक्शन में, मैं दोनों तरीकों और उन्हें प्रभावी ढंग से कब उपयोग करना है, यह समझाऊँगा।
एक से अधिक ब्रांचों को क्रमवार मर्ज करना
ब्रांचों को एक-एक करके मर्ज करने के लिए, प्रत्येक फीचर ब्रांच के लिए क्रमवार मर्ज कमांड का उपयोग करें।
चरण 1: उस टारगेट ब्रांच पर स्विच करें जिसमें आप बदलाव मर्ज करना चाहते हैं।
git checkout target_branch_nameचरण 2: पहली फीचर ब्रांच को नीचे दिखाए अनुसार मर्ज करें।
git merge feature_branch_1चरण 3: दूसरी फीचर ब्रांच को इस प्रकार मर्ज करें।
git merge feature_branch_2यह प्रक्रिया तब तक दोहराएँ जब तक सभी अन्य ब्रांचें मर्ज न हो जाएँ।
एक से अधिक ब्रांचों को समानांतर में मर्ज करना
कई फीचर ब्रांचों को एक साथ मर्ज करने के लिए ये कदम अपनाएँ।
चरण 1: उस टारगेट ब्रांच पर स्विच करें जिसमें आप बदलाव मर्ज करना चाहते हैं।
git checkout target_branch_nameचरण 2: निम्न कमांड को कई फीचर ब्रांचों के साथ चलाएँ
git merge feature_branch_1 feature_branch_2 feature_branch_3जब Git कई ब्रांचों को समानांतर में मर्ज करता है, तो कॉन्फ्लिक्ट हो सकते हैं। ऐसा होने पर, Git आपको उन्हें मैन्युअल रूप से सुलझाने के लिए कहेगा।
कई मर्ज के साथ कॉन्फ्लिक्ट संभालना
कई ब्रांचों को मर्ज करना हमेशा सीधा नहीं होता—खासकर जब एक ब्रांच दूसरी पर निर्भर हो।
उदाहरण के लिए, feature_x को main में feature_y से पहले मर्ज करना कॉन्फ्लिक्ट ला सकता है। इसी तरह, यदि अलग ब्रांचें एक ही फाइलों में बदलाव करती हैं, तो समानांतर मर्ज कॉन्फ्लिक्ट पैदा कर सकते हैं जिन्हें सावधानी से सुलझाने की आवश्यकता होती है।
इन कदमों का पालन करके मर्ज कॉन्फ्लिक्ट सुलझाएँ:
- चरण 1: कौन-सी फाइलें कॉन्फ्लिक्ट का कारण बन रही हैं, यह देखने के लिए
git statusचलाएँ। - चरण 2: कॉन्फ्लिक्ट वाली फाइलें खोलें और उन्हें ठीक करें।
- चरण 3: बदलावों को स्टेज करें और कमिट करें।
मर्ज कमिट इतिहास को समझना
जटिल कॉन्फ्लिक्ट के लिए, आपको git status से अधिक जानकारी की आवश्यकता हो सकती है। ऐसे मामलों में, आप git log या git show जैसी कमांड्स का उपयोग करके इतिहास में गहराई तक जा सकते हैं।
git log: पूरा कमिट इतिहास दिखाता है, जिसमें मर्ज कमिट भी शामिल हैं। यह यह पहचानने में मदद करता है कि समस्या किस विशेष मर्ज में हुई।git show: यदि आपको ऊपर दी कमांड से कोई संदिग्ध मर्ज कमिट मिले, तो उसे जाँचने के लिएgit showका उपयोग करें। यह कमांड कमिट का विस्तृत दृश्य देती है—मर्ज के दौरान क्या बदला, यह दिखाती है। यह किसी विशेष मर्ज से पहले पेरेंट ब्रांच का यूनिक आइडेंटिफ़ायर भी आउटपुट करती है।git diff: आप पेरेंट और मर्ज की गई ब्रांचों के यूनिक आइडेंटिफ़ायर्स पिछले कमांड्स से लेकरgit diffके साथ इन दो अवस्थाओं के बीच के बदलावों की तुलना कर सकते हैं।
Git मर्जिंग की श्रेष्ठ प्रक्रियाएँ
मर्जिंग कभी-कभी अव्यवस्थित हो सकती है, खासकर जब कई डेवलपर्स एक ही कोडबेस पर काम कर रहे हों।
हालाँकि हमने कॉन्फ्लिक्ट आने पर उन्हें सुलझाने के तरीकों को कवर किया है, सबसे अच्छा तरीका है उन्हें पहले से रोकना। इस सेक्शन में, हम व्यावहारिक टिप्स पर जाएँगे ताकि आपके मर्ज सुचारु रहें और आपका Git इतिहास साफ़ रहे।
ब्रांचों को छोटा और फोकस्ड रखें
बड़ी ब्रांचों में ओवरलैपिंग एडिट्स का जोखिम बढ़ जाता है, जो अधिक कॉन्फ्लिक्ट्स का कारण बनते हैं। इसे कम करने के लिए, प्रति ब्रांच एक ही फीचर पर काम करें और ब्रांचों को छोटा व केंद्रित रखें।
बार-बार पुल और मर्ज करें
नवीनतम बदलाव पुल करें ताकि मर्ज से पहले आपकी बेस ब्रांच रिमोट रिपॉज़िटरी के साथ अपडेटेड रहे। नियमित रूप से main ब्रांच के अपडेट अपनी फीचर ब्रांच में खींचते रहें ताकि वे सिंक में रहें। इससे आगे चलकर बड़े और जटिल कॉन्फ्लिक्ट्स से बचाव होता है।
Git के बिल्ट-इन मर्ज टूल्स का उपयोग करें
फाइलों को मैन्युअली एडिट करने के बजाय, आप विज़ुअल UI में कॉन्फ्लिक्ट सुलझाने के लिए Git के बिल्ट-इन टूल्स का उपयोग कर सकते हैं। जब आप git mergetool चलाते हैं, तो तीन विकल्प खुलते हैं:
- LOCAL - main ब्रांच का वर्शन। इसे चुनने पर कॉन्फ्लिक्टिंग फाइल की सामग्री main ब्रांच से ली जाएगी और फीचर ब्रांच के बदलाव नज़रअंदाज़ होंगे।
- REMOTE - फीचर ब्रांच का वर्शन। इसे चुनने पर फीचर ब्रांच की सामग्री कॉन्फ्लिक्टिंग फाइल पर लागू होगी।
- BASE - यह दोनों ब्रांचों की कॉन्फ्लिक्टिंग फाइलों के बदलावों को मिलाकर मर्ज करेगा।
क्रम में मर्ज करें
जब कई ब्रांचों को मर्ज कर रहे हों, तो क्रम मायने रखता है—खासकर अगर एक फीचर दूसरे पर निर्भर हो। यदि feature_x feature_y पर निर्भर है, तो पहले feature_x को मर्ज करना कॉन्फ्लिक्ट ला सकता है। इससे बचने के लिए, हमेशा निर्भरताओं के क्रम में ब्रांचों को मर्ज करें ताकि प्रक्रिया सुचारु रहे और कॉन्फ्लिक्ट कम हों।
स्क्वैश मर्जिंग
जैसा पहले उल्लेख किया गया, स्क्वैश मर्जिंग फीचर ब्रांच के सभी कमिट्स को एक कमिट में समेकित करती है, कमिट इतिहास को साफ रखती है और संभावित मर्ज कॉन्फ्लिक्ट्स को घटाती है।
एक वैकल्पिक तरीका रीबेसिंग है, जो फीचर ब्रांच के बदलावों को सीधे बेस ब्रांच के ऊपर लागू करता है। यह एक रैखिक इतिहास बनाता है और अनावश्यक मर्ज कमिट्स से बचाता है। हालाँकि, दोनों तरीकों में इतिहास को फिर से लिखा जाता है और फीचर ब्रांच के व्यक्तिगत कमिट्स सुरक्षित नहीं रहते।
निष्कर्ष
इस Git merge ट्यूटोरियल में, हमने मर्जिंग की बुनियाद से लेकर कॉन्फ्लिक्ट्स से बचने की श्रेष्ठ प्रक्रियाओं तक सब कवर किया। git merge का प्रभावी उपयोग समझने से टीमें बिना रुकावट सहयोग कर पाती हैं, वर्कफ़्लो सुचारु रहता है और कोड इतिहास साफ रहता है।
यदि आप अपनी Git स्किल्स को और गहरा करना चाहते हैं, तो इस इंटरमीडिएट Git कोर्स को देखें और अधिक उन्नत वर्कफ़्लोज़ और तकनीकों में महारत पाएँ!
FAQs
git merge और git rebase में क्या अंतर है?
दोनों कमांड एक ब्रांच के बदलावों को दूसरी में शामिल करती हैं, लेकिन git merge एक नया मर्ज कमिट बनाता है और दोनों ब्रांचों का इतिहास सुरक्षित रखता है। इसके विपरीत, git rebase फीचर ब्रांच के कमिट्स को सीधे टारगेट ब्रांच पर लागू करता है, जिससे इतिहास रैखिक हो जाता है, पर प्रक्रिया में इतिहास फिर से लिखा जाता है।
क्या मैं Git में मर्ज को वापस कर सकता/सकती हूँ?
हाँ, यदि आपने अभी तक मर्ज पुश नहीं किया है, तो आप इसका उपयोग कर सकते हैं:
git reset --hard HEAD~1
यह आपकी ब्रांच को मर्ज से पहले की स्थिति में रीसेट कर देता है। यदि मर्ज पहले ही पुश हो चुका है, तो इतिहास सुरक्षित रखते हुए बदलावों को सुरक्षित रूप से पलटने के लिए आपको git revert का उपयोग करना होगा।
मैं रिमोट ब्रांच को अपनी लोकल ब्रांच में कैसे मर्ज करूँ?
रिमोट ब्रांच को अपनी लोकल ब्रांच में मर्ज करने के लिए ये कदम अपनाएँ:
git fetch origin
git checkout my-branch
git merge origin/feature-branch
यह सुनिश्चित करता है कि आप रिमोट रिपॉज़िटरी से नवीनतम अपडेट्स को मर्ज कर रहे हैं।
मैं अनावश्यक मर्ज कॉन्फ्लिक्ट्स से कैसे बचूँ?
कॉन्फ्लिक्ट कम करने के लिए:
- नया काम शुरू करने से पहले नियमित रूप से नवीनतम बदलाव पुल करें (
git pull)। - यदि कई ब्रांचें एक-दूसरे पर निर्भर हैं, तो निर्भरता के क्रम में मर्ज करें।
- लंबे समय तक चलने वाली ब्रांचों के बजाय, धीरे-धीरे कोड इंटीग्रेट करने के लिए फीचर फ्लैग्स का उपयोग करें।
यदि मैं पहले से मर्ज की जा चुकी ब्रांच को फिर से मर्ज करूँ तो क्या होगा?
यदि कोई ब्रांच पहले ही मर्ज हो चुकी है, तो git merge feature-branch फिर से चलाने पर कुछ नहीं बदलेगा। Git समझ जाएगा कि ब्रांचों का सामान्य इतिहास है और बस यह पुष्टि करेगा कि सब कुछ अप टू डेट है।
क्या मैं एक साथ कई ब्रांचों को मर्ज कर सकता/सकती हूँ?
नहीं, Git एक ही कमांड में कई ब्रांचों को मर्ज करने का समर्थन नहीं करता। आपको उन्हें क्रमवार मर्ज करना होगा:
git merge feature-branch-1
git merge feature-branch-2
यदि ज़रूरत हो, तो आप एक इंटीग्रेशन ब्रांच बना सकते हैं जहाँ आप कई ब्रांचों को मर्ज करें और फिर उसे main में मर्ज करें।
मुझे git merge --no-ff का उपयोग करना चाहिए या git merge --ff?
--no-ff(नो फास्ट-फ़ॉरवर्ड मर्ज) एक नया मर्ज कमिट बनाता है, जिससे ब्रांच इतिहास को ट्रैक करना आसान हो जाता है।--ff(फास्ट-फ़ॉरवर्ड मर्ज) संभव होने पर बदलाव सीधे लागू करता है, और अतिरिक्त कमिट से बचता है।
जहाँ फीचर ब्रांचों को ट्रैक करना महत्वपूर्ण है, वहाँ --no-ff की सिफारिश की जाती है।
Srujana चार-वर्षीय कंप्यूटर साइंस डिग्री के साथ एक फ्रीलांस टेक राइटर हैं। डेटा साइंस, क्लाउड कंप्यूटिंग, डेवलपमेंट, प्रोग्रामिंग, सुरक्षा, और अन्य कई विषयों पर लिखना उनके लिए स्वाभाविक है। उन्हें शास्त्रीय साहित्य से प्रेम है और नए स्थानों की खोज करना पसंद है।
यदि आपने कभी कई डेवलपर्स के साथ किसी प्रोजेक्ट पर काम किया है (या खुद कई फीचर्स संभाले हैं), तो आप जानते हैं कि चीज़ों को व्यवस्थित रखने के लिए ब्रांचिंग ज़रूरी है। लेकिन एक समय पर सभी ब्रांचों को वापस साथ आना होता है—और यहीं
git mergeकाम आता है।इस ट्यूटोरियल में, मैं Git मर्ज के अलग-अलग प्रकार, वे कैसे काम करते हैं, और जब चीज़ें योजना के अनुसार न चलें तो मर्ज कॉन्फ्लिक्ट कैसे सुलझाएँ—इन सब पर चर्चा करूँगा। अंत में, मैं कुछ श्रेष्ठ प्रक्रियाएँ साझा करूँगा ताकि आप
git mergeका प्रभावी उपयोग कर सकें और आम गलतियों से बच सकें।git merge क्या है?
टीम सेटिंग में, डेवलपर्स अक्सर अलग-अलग फीचर्स, बग फिक्स, और सुधारों पर अलग ब्रांचों में काम करते हैं। काम पूरा होने पर वे उन बदलावों को इंटीग्रेट करने के लिए
git mergeका उपयोग करते हैं।मर्जिंग एक ब्रांच के बदलावों को दूसरी में मिलाती है और पूरा वर्शन इतिहास सुरक्षित रखती है। यह दोनों ब्रांचों के कमिट इतिहास को एकजुट करती है।
आइए एक उदाहरण के जरिए वर्कफ़्लो समझते हैं।
एक सामान्य बेस कमिट दो ब्रांचों में विभाजित होता है, जिससे मर्ज से पहले अलग-अलग main और feature टिप्स बनती हैं। चित्र: लेखक द्वारा।
ऊपर दिए गए चित्र में, फीचर और main ब्रांचों ने फीचर ब्रांच बनने के बाद से नए कमिट बनाए हैं।
एक फीचर ब्रांच और main ब्रांच एक सामान्य बेस से अलग होती हैं और बाद में एकल मर्ज कमिट में सम्मिलित की जाती हैं। चित्र: लेखक द्वारा।
Git merge दोनों ब्रांचों के सामान्य बेस से शुरू होकर सभी नए कमिट लेता है और उन्हें एक ही मर्ज कमिट में जोड़ देता है। फिर यह हेड पॉइंटर को इस नए मर्ज कमिट की ओर अपडेट कर देता है।
बेसिक git merge कमांड का उपयोग
मर्ज करना केवल git merge चलाने भर की बात नहीं है—सब कुछ सही रखने के लिए पहले कुछ ज़रूरी कदम होते हैं। इस सेक्शन में, हम पूरी प्रक्रिया देखेंगे—ब्रांचों की तैयारी से लेकर सफल मर्ज तक।
चरण 1: मर्ज से पहले तैयारी
केवल कमिट किए गए बदलाव ही दोनों ब्रांचों में मर्ज हो सकते हैं। इसलिए,
git statusकमांड से अनकमिटेड बदलाव जाँचें और मर्ज करने से पहलेgit commitका उपयोग करके उन्हें कमिट करें।चरण 2: टारगेट ब्रांच चेकआउट करें
git merge चलाने से पहले, आपको टारगेट ब्रांच पर स्विच करना चाहिए, जो आमतौर पर main ब्रांच होती है। main ब्रांच पर स्विच करें
git checkout mainयाgit switch mainका उपयोग करके।चरण 3: किसी ब्रांच को मर्ज करना
सुनिश्चित करें कि main ब्रांच रिमोट रिपॉज़िटरी के साथ अप टू डेट है। इसके लिए
git pull origin mainचलाएँ।अब आप आखिरकार फीचर ब्रांच को main ब्रांच में मर्ज करने के लिए तैयार हैं! आप निम्न जैसा कमांड इस्तेमाल कर सकते हैं:
चरण 4: मर्ज कॉन्फ्लिक्ट सुलझाना (यदि हों)
Git मर्ज के दौरान होने वाले कॉन्फ्लिक्ट्स को स्वतः सुलझाने की कोशिश करता है। हालांकि, जब वह खुद कॉन्फ्लिक्ट नहीं सुलझा पाता, तो मैन्युअल दखल की ज़रूरत पड़ सकती है।
उदाहरण के लिए, यदि एक ही फाइल की एक ही लाइनों में अलग ब्रांचों में बदलाव हुए हों, तो मर्ज कॉन्फ्लिक्ट हो सकता है।
जब Git कोई कॉन्फ्लिक्ट पकड़ता है, तो वह मर्ज रोक देता है और आपको उसे सुलझाने के लिए कहता है। उस स्थिति में:
git statusचलाएँ।चरण 5: मर्ज को कमिट करना
कॉन्फ्लिक्ट सुलझाने के बाद, ठीक की गई फाइलों को स्टेज करने के लिए
git add .कमांड का उपयोग करें। फिर, संदेश के साथ कमिट करके मर्ज पूरा करें:आगे के सेक्शनों में, हम मर्ज कॉन्फ्लिक्ट्स को और गहराई से सुलझाना देखेंगे।
शुरुआती लोगों के लिए, यहाँ पूरा Git चीट शीट है, जो ब्रांच बनाने, अपडेट करने, हटाने और प्रबंधित करने के सभी आवश्यक कमांड कवर करता है।
यदि आपके पास पहले से कुछ Git अनुभव है और आपको ज़रूरी कमांड्स का रिफ्रेशर चाहिए, तो सबसे अधिक उपयोग होने वाले Git कमांड्स उदाहरण सहित के लिए यह ट्यूटोरियल देखें।