मास्टर और विकास शाखाओं के बीच "गिट पुल" या "गिट मर्ज"

Question

मेरे पास कुछ बदलावों पर काम करने के लिए मेरी masterशाखा और एक developशाखा है। मैं से परिवर्तन मर्ज करने के लिए की जरूरत masterमें develop, लेकिन अंत में सब कुछ मर्ज हो जाएगा developमें master। मेरे पास दो अलग-अलग वर्कफ़्लोज़ हैं:

1. git pull origin masterमें developशाखा
2. git merge masterमें developशाखा

ऐसा करने का सबसे अच्छा तरीका कौन सा है, और क्यों?

Comments

अनुशंसित पढ़ने: nvie.com/posts/a-successful-git-branching-model

— एलेक्स ब्रासेविक

git pull= git fetch+git merge FETCH_HEAD

— योषा अलायबौ

Answer 1

रिबास से सावधान रहें। यदि आप अपनी विकसित शाखा को किसी के साथ साझा कर रहे हैं, तो रिबेस कुछ गड़बड़ कर सकता है। रिबेस केवल आपकी अपनी स्थानीय शाखाओं के लिए अच्छा है।

अंगूठे का नियम, यदि आपने शाखा को मूल में धकेल दिया है, तो रिबास का उपयोग न करें। इसके बजाय, मर्ज का उपयोग करें।

Comments

फिर भी क्या यह git push origin rebasedBranch --forceएक निजी रेपो पर छूट देना और सुरक्षित करना है ? एकमात्र उपयोगकर्ता स्वयं है।

— k0pernikus

हां, यदि आप एकमात्र उपयोगकर्ता हैं, तो निश्चित रूप से यह सुरक्षित है। मैं गिट पुश का उपयोग करता हूं - हर समय लागू करें जब मैं एकमात्र उपयोगकर्ता हूं। :)

— टायलर रिक

मैं एरिक की चेतावनी की प्रतिध्वनि करता हूं। हालाँकि, अपनी स्वयं की दूरस्थ शाखा को भी रिबेस करना पूरी तरह से ठीक है। रिबेस और मर्ज दोनों के साथ खेलते हैं और आप प्रत्येक के पेशेवरों और विपक्षों को समझेंगे और सीखेंगे कि उनका उपयोग कब करना है।

— इयान लोटिन्स्की

— रिबास

@IanLotinsky आपका लिंक रिबेस पर एक लेख को इंगित नहीं करता है। Longshot, लेकिन क्या आपके पास अभी भी सही लिंक है? :)

— डैनियल सेरोडियो

Answer 2

यह वर्कफ़्लो मेरे लिए सबसे अच्छा काम करता है:

git checkout -b develop

... कुछ बदलाव करें ...

... नोटिस मास्टर को अपडेट कर दिया गया है ...

... परिवर्तन के लिए प्रतिबद्ध ...

git checkout master
git pull

... उन परिवर्तनों को वापस विकास में लाएँ ...

git checkout develop
git rebase master

... कुछ और बदलाव करें ...

... उन्हें विकसित करने के लिए प्रतिबद्ध ...

... उन्हें मास्टर में विलय करें ...

git checkout master
git pull
git merge develop

Comments

यह है कि मैं भी काम करता हूं, और मुझे लगता है कि यह अच्छी तरह से काम करता है। एक बात है जो मैं हालांकि नहीं करता, और यह git pullअंतिम से पहले सही है git merge develop। उसका उद्देश्य क्या है?

— crdx

के बाद ... नोटिस मास्टर को अपडेट किया गया है ... भाग, चेकआउट मास्टर आपके स्थानीय परिवर्तनों को विकसित करने के लिए नहीं मिटाएगा यदि आप उन्हें प्रतिबद्ध नहीं करते हैं?

— 1

@ a1an नहीं, लेकिन यदि आप उन्हें प्रतिबद्ध नहीं करते हैं, तो परिवर्तन मास्टर शाखा में चले जाएंगे और जब तक वे प्रतिबद्ध नहीं होंगे, तब तक आपको खींचने नहीं देंगे।

— एलिम्जय

@ क्रैडैक्स संभावना यह है कि अन्य शाखाएं दूरस्थ मास्टर में विलय हो जाती हैं इससे पहले कि आप अपनी शाखा को अपने स्थानीय मास्टर में विलय कर दें। आप मास्टर की अपनी स्थानीय प्रति में दूरस्थ मास्टर परिवर्तन खींचते हैं और लाते हैं। यह मैंने इसे कैसे समझा।

— तरुण

git pull --rebase origin masterआपकी विकसित शाखा में थोड़ी तेजी है।

— नाथन लिलिएनथाल

Answer 3

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

Comments

अच्छी सलाह, यह मानते हुए developकि किसी और के साथ साझा नहीं किया गया है।

— कार्ल बेज़ेलफेल्ट

@KarlBielefeldt यदि अन्य योगदानकर्ताओं के साथ develop साझा किया जाता है , developतो कुछ हॉटफ़िक्स को सीधे पुश करने पर हम कैसे अपडेट करेंगे master? क्या हमें मर्ज करना चाहिए, अर्थात git checkout master && git pull --rebase && git checkout develop && git merge master? मैंने ऊपर दिए गए उच्चतम मतदान जवाब पर एक टिप्पणी छोड़ दी, जो इस चिंता का भी विवरण देता है।

— modulitos

Answer 4

यदि आप किसी के साथ डेवलपमेंट ब्रांच को साझा नहीं कर रहे हैं, तो मैं इसे हर बार अपडेट किए गए मास्टर के लिए रिबेस कर दूंगा, इस तरह से आपके पास अपने इतिहास के सभी मर्ज कमिट नहीं होंगे, जब आप मास्टर में वापस मर्ज करेंगे। इस मामले में वर्कफ़्लो इस प्रकार होगा:

> git clone git://<remote_repo_path>/ <local_repo>
> cd <local_repo>
> git checkout -b develop
....do a lot of work on develop
....do all the commits
> git pull origin master
> git rebase master develop

उपरोक्त चरणों से यह सुनिश्चित होगा कि आपकी विकसित शाखा हमेशा मास्टर शाखा के नवीनतम परिवर्तनों के शीर्ष पर होगी। एक बार जब आप विकसित शाखा के साथ हो जाते हैं और यह मास्टर के नवीनतम परिवर्तनों के लिए पुन: उत्पन्न हो जाता है, तो आप इसे वापस मर्ज कर सकते हैं:

> git checkout -b master
> git merge develop
> git branch -d develop

Answer 5

अंगूठे का मेरा नियम है:

rebaseएक ही नाम वाली शाखाओं के लिए , mergeअन्यथा।

एक ही नाम के लिए उदाहरण होगा master, origin/masterऔर otherRemote/master।

यदि developकेवल स्थानीय रिपॉजिटरी में मौजूद है, और यह हमेशा एक हालिया origin/masterप्रतिबद्ध पर आधारित है , तो आपको इसे कॉल करना चाहिए master, और वहां सीधे काम करना चाहिए । यह आपके जीवन को सरल बनाता है, और चीजों को प्रस्तुत करता है जैसे वे वास्तव में हैं: आप सीधे masterशाखा पर विकसित हो रहे हैं ।

अगर developसाझा किया जाता है, तो इसे masterवापस नहीं किया जाना चाहिए , बस इसके साथ वापस विलय कर दिया जाना चाहिए --no-ff। आप विकसित हो रहे हैं develop। masterऔर developअलग-अलग नाम हैं, क्योंकि हम चाहते हैं कि वे अलग चीजें हों, और अलग रहें। उन्हें एक ही साथ मत बनाओ rebase।