git rebase, 'लोकल' और 'रिमोट' का ट्रैक रखना


174

जब मैं एक विद्रोह कर रहा हूँ, तो मुझे अक्सर यह समझने में कठिनाई होती है कि संघर्षों को हल करते समय 'स्थानीय' और 'रिमोट' के साथ क्या हो रहा है। मुझे कभी-कभी यह आभास होता है कि वे एक ओर से दूसरी ओर तक स्वैप करते हैं।

यह शायद (निश्चित रूप से) है क्योंकि मुझे अभी भी ठीक से समझ नहीं आया है।

रिबास करते समय, कौन 'स्थानीय' और कौन 'दूरस्थ'?

(मैं संघर्षों को हल करने के लिए P4Merge का उपयोग करता हूं)


क्या यह संभव है कि पढ़ने यह आप में मदद मिलेगी? बाकी ट्यूटोरियल बहुत ही उपयोगी है ....
ivans

एक और उत्कृष्ट गिट संसाधन
अज्ञात

क्या stackoverflow.com/questions/2959443/… मदद करेगा? (' git svn' भाग के लिए नहीं , सिर्फ ' git rebase' भाग के लिए)
वॉन

@VonC, हाँ, बिलकुल ऐसा ही है। यदि आप अपने उत्तर की प्रासंगिक बिट को यहाँ पर कॉपी करना चाहते हैं, तो मैं इसे टिक कर दूँगा (मैं वास्तव में इस बार, मैं वादा करता हूँ!)
बेंजोल

सब ठीक है ... मैं काटता हूँ;) प्रासंगिक अर्क पोस्ट किया गया।
वॉन

जवाबों:


244

टी एल; डॉ;

संक्षेप में ( बेनुबर्ड टिप्पणियों के रूप में ), जब:

git checkout A
git rebase   B    # rebase A on top of B
  • localहै B(rebase पर ),
  • remote है A

तथा:

git checkout A
git merge    B    # merge B into A
  • localहै A(मर्ज में ),
  • remote है B

एक रिबास स्विच ours(रिबास शुरू होने से पहले वर्तमान शाखा) और theirs(वह शाखा जिसके ऊपर आप रिबास करना चाहते हैं)।


कुत्सकेम बताते हैं कि, GUI मेरिजेट संदर्भ में :

  • स्थानीय संदर्भ आंशिक रूप से छूट वाले कमिट्स : " ours" (अपस्ट्रीम शाखा)
  • दूरस्थ आने वाले परिवर्तनों को संदर्भित करता है : " theirs" - रिबास से पहले वर्तमान शाखा।

इस उत्तर के अंतिम भाग में चित्र देखें।


उलटा होने पर उलटा

भ्रम की स्थिति उलट oursऔर theirsएक रिबेस के दौरान हो सकती है ।
(प्रासंगिक अर्क)

git rebaseआदमी पृष्ठ :

ध्यान दें कि रिबेज मर्ज शाखा के शीर्ष पर कार्यरत शाखा से प्रत्येक कमेटी को रिपीट करके काम करता है <upstream>

इस वजह से, जब एक मर्ज संघर्ष होता है:

  • पक्ष को ' ours' के रूप में रिपोर्ट किया गया है, जो अब तक शुरू की गई श्रृंखला है <upstream>,
  • और ' theirs' कार्यशील शाखा है। दूसरे शब्दों में, पक्षों की अदला-बदली की जाती है।

उलटा सचित्र

एक मर्ज पर

x--x--x--x--x(*) <- current branch B ('*'=HEAD)
    \
     \
      \--y--y--y <- other branch to merge

, हम वर्तमान शाखा 'बी' को नहीं बदलते हैं, इसलिए हमारे पास अभी भी वही है जो हम काम कर रहे थे (और हम दूसरी शाखा से विलय करते हैं)

x--x--x--x--x---------o(*)  MERGE, still on branch B
    \       ^        /
     \     ours     /
      \            /
       --y--y--y--/  
               ^
              their

एक छूट पर:

लेकिन एक रिबास पर , हम पक्ष बदल देते हैं क्योंकि रिबास की पहली चीज अपस्ट्रीम शाखा को चेकआउट करना है! (वर्तमान में इसके शीर्ष पर पुनरावृत्ति करने के लिए)

x--x--x--x--x(*) <- current branch B
    \
     \
      \--y--y--y <- upstream branch

A git rebase upstreamपहले HEADB को अपस्ट्रीम ब्रांच में बदलेगा HEAD(इसलिए पिछले "चालू" वर्किंग ब्रांच की तुलना में 'हमारा' और 'उनका स्विच')।

x--x--x--x--x <- former "current" branch, new "theirs"
    \
     \
      \--y--y--y(*) <- upstream branch with B reset on it,  
                       new "ours", to replay x's on it

, और फिर रिबास फिर से 'नए' हमारी 'बी शाखा' पर अपना काम शुरू करेगा:

x--x..x..x..x <- old "theirs" commits, now "ghosts", available through reflogs
    \
     \
      \--y--y--y--x'--x'--x'(*) <-  branch B with HEAD updated ("ours")
               ^
               |
        upstream branch

नोट: "अपस्ट्रीम" धारणा डेटा का रेफ़रेंशियल सेट है (सभी रेपो या, यहाँ की तरह, एक शाखा, जो एक स्थानीय शाखा हो सकती है ) जहाँ से डेटा पढ़ा जाता है या जिसमें नया डेटा जोड़ा / बनाया जाता है।


' local' और ' remote' बनाम ' mine' और ' theirs'

Pandawood में कहते हैं टिप्पणियाँ :

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

जीयूआई मेरिटगूल

kutschkem कहते हैं, और ठीक है:

संघर्षों को हल करते समय, git कुछ ऐसा कहेगा:

local: modified file and remote: modified file. 

मुझे यकीन है कि सवाल इस बिंदु पर स्थानीय और दूरस्थ की परिभाषा का लक्ष्य है। उस समय, यह मेरे अनुभव से मुझे लगता है कि:

  • स्थानीय संदर्भ आंशिक रूप से छूट वाले कमिट्स : " ours" (अपस्ट्रीम शाखा)
  • दूरस्थ आने वाले परिवर्तनों को संदर्भित करता है : " theirs" - रिबास से पहले वर्तमान शाखा।

git mergetoolवास्तव में 'स्थानीय' और 'दूरस्थ' का उल्लेख करता है :

Merging:
f.txt

Normal merge conflict for 'f.txt':
  {local}: modified file
  {remote}: modified file
Hit return to start merge resolution tool (kdiff3):

उदाहरण के लिए, KDiff3 मर्ज रिज़ॉल्यूशन को इस तरह प्रदर्शित करेगा :

kdiff3

और मिलकर एक हो जाना होगा यह भी प्रदर्शित :

गलन अलग

VimDiff के लिए समान , जो प्रदर्शित करता है :

Git mergetool -t gvimdiff के साथ एक मेरिजेट के रूप में Vimdiff को आमंत्रित करें। निम्न विंडो लेआउट के साथ Git के हाल के संस्करणों ने Vimdiff को आमंत्रित किया:

+--------------------------------+
| LOCAL  |     BASE     | REMOTE |
+--------------------------------+
|             MERGED             |
+--------------------------------+
  • LOCAL:
    एक अस्थायी फ़ाइल जिसमें वर्तमान शाखा पर फ़ाइल की सामग्री है।
  • BASE:
    मर्ज के लिए सामान्य आधार वाली एक अस्थायी फ़ाइल।
  • REMOTE:
    एक अस्थायी फ़ाइल जिसमें मर्ज की जाने वाली फ़ाइल की सामग्री है।
  • MERGED:
    संघर्ष मार्करों के साथ फ़ाइल।

गिट ने जितना संभव हो उतना स्वत: संघर्ष समाधान का प्रदर्शन किया है और इस फाइल की स्थिति दोनों के संयोजन के साथ LOCALऔर REMOTEकुछ भी आसपास के संघर्ष मार्करों के साथ है जो गिट खुद को हल नहीं कर सके। इस फ़ाइल की संकल्प का परिणाम लिखना चाहिए।
mergetool


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

@ पांडा: "स्थानीय" "वर्तमान शाखा" है (जो "उनकी" बन जाती है), "रिमोट" "अपस्ट्रीम शाखा" (जो "हमारी" बन जाती है)।
वॉनसी

3
इसलिए, संक्षिप्त करने के लिए: जब आप git checkout A; git rebase Bस्थानीय बी हैं, तो रिमोट ए है। मुझे जानने की जरूरत है ...
बेनुबर्ड

1
git प्रयोज्य का एक ऐसा क्लस्टर है। इससे कोई मतलब नहीं है: जब आप git checkout A; git rebase Bस्थानीय बी हैं, तो रिमोट ए है । मैं तो checkout Aफिर मैं कर रहा हूँ वर्तमान में फ़ाइलों को देख के रूप में वे पर मौजूद हैं A, कि किसी भी तरह से कैसे है दूरस्थ ? (मैं यह नहीं कह रहा हूँ कि बेनुबर्ड गलत है; मैं कह रहा हूँ कि एक बेवकूफ यूएक्स है)
राफा

1
@VonC सुनिश्चित; मेरा (शेख़ी) बिंदु यह है कि दस्तावेज़ों को पढ़ना नहीं चाहिए, आरेखों को देखना, और स्टैकऑवरफ़्लो को ब्राउज़ करना। यदि केवल कमांड ने स्पष्ट, स्पष्ट प्रतिक्रिया दी। उदाहरण के लिए, स्थानीय / दूरस्थ / उनके / हमारे / मेरा / तुम्हारा के बजाय, बस दिखाएँ {branch A}और {branch B}इसी तरह।
राफा

45

तल - रेखा

गिट रिबेस

  • स्थानीय = आधार आप रिबेसिंग रहे हैं पर
  • REMOTE = आप ऊपर जा रहे हैं

git मर्ज

  • LOCAL = जिस मूल शाखा में आप विलय कर रहे हैं
  • REMOTE = वह दूसरी शाखा जिसके आने पर आप विलय कर रहे हैं

दूसरे शब्दों में, LOCAL हमेशा मूल होता है, और REMOTE हमेशा वह व्यक्ति होता है, जिसके पहले कोई ऐसा नहीं था, क्योंकि वे शीर्ष पर विलय या विद्रोह कर रहे हैं।

इसे साबित करो!

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

सबसे पहले, सुनिश्चित करें कि आपके पास git mergetool ठीक से कॉन्फ़िगर किया गया है। (यदि आपने ऐसा नहीं किया है, तो आप शायद इस सवाल को वैसे भी नहीं पढ़ेंगे।) फिर काम करने के लिए एक निर्देशिका खोजें।

अपना भंडार सेट करें:

md LocalRemoteTest
cd LocalRemoteTest

एक प्रारंभिक प्रतिबद्ध बनाएँ (एक खाली फ़ाइल के साथ):

git init
notepad file.txt  (use the text editor of your choice)
  (save the file as an empty file)
git add -A
git commit -m "Initial commit."

उस शाखा पर कमिट बनाएँ जो मास्टर नहीं है:

git checkout -b notmaster
notepad file.txt
  (add the text: notmaster)
  (save and exit)
git commit -a -m "Add notmaster text."

मास्टर शाखा पर एक कमिट बनाएँ:

git checkout master
notepad file.txt
  (add the text: master)
  (save and exit)
git commit -a -m "Add master text."

gitk --all

इस बिंदु पर आपकी रिपॉजिटरी को इस तरह दिखना चाहिए:

बेस कमेटी और दो वन-कमिट शाखाओं के साथ भंडार

अब रिबास टेस्ट के लिए:

git checkout notmaster
git rebase master
  (you'll get a conflict message)
git mergetool
  LOCAL: master
  REMOTE: notmaster

अब मर्ज की परीक्षा। किसी भी परिवर्तन को सहेजे बिना अपना मर्जूल बंद करें, और फिर रिबास को रद्द करें:

git rebase --abort

फिर:

git checkout master
git merge notmaster
git mergetool
  LOCAL: master
  REMOTE: notmaster
git reset --hard  (cancels the merge)

आपके परिणाम वही होने चाहिए जो ऊपर दिखाए गए हैं।


1
+1। यह स्पष्ट करता है local/ उन remoteपहलुओं के बारे में जिनसे मैं ऊपर अपने स्वयं के उत्तर में संघर्ष कर रहा हूं (जो कि वैसे भी oursबनाम के उलट के बारे में अधिक theirsहै)
VonC

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