मैं एक GitHub रिपॉजिटरी को forked कैसे अपडेट करूं?

3602

मैंने हाल ही में एक परियोजना की शुरुआत की और कई सुधार लागू किए। मैंने तब एक पुल अनुरोध बनाया, जिसे तब स्वीकार कर लिया गया था।

कुछ दिनों बाद दूसरे योगदानकर्ता द्वारा एक और बदलाव किया गया। इसलिए मेरे कांटे में वह बदलाव नहीं है।

मैं अपने कांटे में कैसे बदलाव ला सकता हूं? क्या मुझे योगदान के लिए और परिवर्तन करने पर अपने कांटे को हटाने और फिर से बनाने की आवश्यकता है? या अपडेट बटन है?

— ली हेस
स्रोत

120

यह github UI से भी किया जा सकता है। मैं इसका श्रेय [इस अन्य पोस्टर को देना चाहूंगा] [१]। [1]: stackoverflow.com/a/21131381/728141

— माइक स्कॉल २०'१४

2

इस पर एक और अच्छा ब्लॉग पोस्ट - कीपिंग ए गिटहब फोर्क अपडेटेड

— अरूप रक्षित

3

Github सहायता लेखों में यह पाया गया: help.github.com/articles/syncing-a-fork

— प्रणव

2

क्या यह stackoverflow.com/questions/3903817/… का डुप्लिकेट है ?

— डेविड कैरी

यहाँ एक वीडियो डेमो है जो दो github खातों का उपयोग करता है youtube.com/watch?v=kpE0gTX4ycE

— lifebalance

3977

आपके फोर्क्ड रिपॉजिटरी के स्थानीय क्लोन में, आप मूल GitHub रिपॉजिटरी को "रिमोट" के रूप में जोड़ सकते हैं। ("उपाय" रिपॉजिटरी के यूआरएल के लिए उपनाम की तरह हैं - originएक है, उदाहरण के लिए।) फिर आप उस अपस्ट्रीम रिपॉजिटरी से सभी शाखाओं को प्राप्त कर सकते हैं, और अपस्ट्रीम संस्करण पर काम करना जारी रखने के लिए अपने काम को फिर से शुरू कर सकते हैं। उन आदेशों के संदर्भ में, जो इस तरह दिख सकते हैं:

# Add the remote, call it "upstream":

git remote add upstream https://github.com/whoever/whatever.git

# Fetch all the branches of that remote into remote-tracking branches,
# such as upstream/master:

git fetch upstream

# Make sure that you're on your master branch:

git checkout master

# Rewrite your master branch so that any commits of yours that
# aren't already in upstream/master are replayed on top of that
# other branch:

git rebase upstream/master

यदि आप अपनी मास्टर शाखा के इतिहास को फिर से लिखना नहीं चाहते हैं, (उदाहरण के लिए क्योंकि अन्य लोगों ने इसे क्लोन किया हो सकता है) तो आपको अंतिम कमांड को बदलना चाहिए git merge upstream/master। हालांकि, आगे के पुल अनुरोधों को बनाने के लिए जो जितना संभव हो उतना साफ है, संभवतः इसे रीबेस करना बेहतर है।

यदि आपने अपनी शाखा पर विद्रोह कर दिया है, तो आपको GHHub पर upstream/masterअपने स्वयं के forked रिपॉजिटरी को पुश करने के लिए पुश करने के लिए मजबूर करने की आवश्यकता हो सकती है। आप ऐसा करेंगे:

git push -f origin master

आपके द्वारा -fपहली बार विद्रोह करने के बाद आपको पहली बार उपयोग करने की आवश्यकता है ।

— मार्क लॉन्गेयर
स्रोत

94

जैसा कि आपका कांटा केवल जीथब पर मौजूद है, और जीथब में वेब इंटरफेस के माध्यम से मर्ज करने के लिए उपकरण नहीं हैं, तो सही उत्तर यह है कि स्थानीय स्तर पर अपस्ट्रीम मर्ज करें और परिवर्तनों को अपने कांटे पर वापस धकेल दें।

— टिम कीटिंग

29

यहाँ मैं एक महान ट्यूटोरियल है जो मुझे गितुब के

— टिम कीटिंग

50

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

— माटूस कोवल्स्की

11

रीबेस कमांड के बजाय, मैंने निम्नलिखित का उपयोग किया: git merge --no-ff upstream/masterइस तरह से आपके कमेंट्स अब शीर्ष पर नहीं हैं।

— स्टेकडॉसरिख

51

एक और गिट विफलता। यदि यह उपकरण वितरित सहयोग का समर्थन करने वाला है, तो मूल वर्कफ़्लो प्रदर्शन करना इतना मुश्किल क्यों है? 4 मिलियन लोग और 2200 अपवोट्स का मतलब है कि टूल विफल हो गया। "आप मूल GitHub रिपॉजिटरी को" रिमोट "के रूप में जोड़ सकते हैं - किसी को भी ऐसा क्यों करना पड़ता है? कांटा के दौरान ऐसा क्यों नहीं किया जाता है? इस उपकरण के बारे में ऐसा क्या है?

— jww

738

मई 2014 से शुरू होकर, GitHub से सीधे एक कांटा अपडेट करना संभव है। यह अभी भी सितंबर 2017 तक काम करता है, लेकिन यह एक गंदे प्रतिबद्ध इतिहास को जन्म देगा।

GitHub पर अपना कांटा खोलें।
पर क्लिक करें Pull Requests।
पर क्लिक करें New Pull Request। डिफ़ॉल्ट रूप से, GitHub आपके कांटे के साथ मूल की तुलना करेगा, और यदि आपने कोई बदलाव नहीं किया है तो तुलना करने के लिए कुछ भी नहीं होना चाहिए।
switching the baseयदि आपको वह लिंक दिखाई दे तो क्लिक करें । अन्यथा, मैन्युअल रूप से base forkड्रॉप को अपने कांटे, और head forkअपस्ट्रीम पर सेट करें। अब GitHub आपके कांटे की तुलना मूल से करेगा, और आपको सभी नवीनतम परिवर्तन देखने चाहिए।
Create pull requestऔर अपने पुल अनुरोध (जैसे, Update from original) के लिए एक पूर्वानुमान योग्य नाम निर्दिष्ट करें ।
नीचे स्क्रॉल करें Merge pull request, लेकिन अभी तक कुछ भी क्लिक न करें।

अब आपके पास तीन विकल्प हैं, लेकिन प्रत्येक कम-से-कम स्वच्छ इतिहास का नेतृत्व करेगा।

डिफ़ॉल्ट एक बदसूरत मर्ज कमिट बनाएगा।
यदि आप ड्रॉपडाउन पर क्लिक करते हैं और "स्क्वैश और मर्ज" चुनते हैं, तो सभी हस्तक्षेप करने वाले कमिट्स को एक में स्क्वैश किया जाएगा। यह सबसे अधिक बार कुछ आप चाहते हैं नहीं है।
यदि आप क्लिक करते हैं Rebase and merge, तो सभी कमिट "आप" के साथ किए जाएंगे, मूल पीआर आपके पीआर से लिंक होंगे, और गिटहब प्रदर्शित करेगा This branch is X commits ahead, Y commits behind <original fork>।

तो हां, आप अपने रेपो को GitHub वेब UI का उपयोग करके अपने अपस्ट्रीम के साथ अपडेट रख सकते हैं, लेकिन ऐसा करने से आपका इतिहास खराब हो जाएगा। इसके बजाय कमांड लाइन से चिपके रहें - यह आसान है।

— lobzik
स्रोत

19

इसने एक समय बहुत अच्छा काम किया। दूसरी बार यह प्रक्रिया उसी तरह से काम नहीं करती थी: "स्विचिंग द बेस" लिंक नहीं दिखा। और जब मैंने "एक पुल अनुरोध बनाने के लिए क्लिक करें" मारा तो इसने SOURCE रेपो पर एक PR बनाया। नहीं जो मैं चाहता था ..

— javadba

29

अभी भी काम करता है (मार्च 2015), हालांकि "स्विचिंग द बेस" लिंक अब नहीं है। आपको "बेस" ड्रॉप डाउन को बदलना होगा ताकि दोनों आपके कांटे की ओर इंगित करें और फिर आपको "रिपॉजिट के पार तुलना करें" का संकेत मिलेगा, जो आपको वहां ले जाएगा जहां आप चाहते हैं।

— 14

8

अप्रैल 2015 से काम करता है। धन्यवाद। मुझे "स्विचिंग टू बेस" मिला। हालाँकि, चरण 6 "पुल अनुरोध बनाएँ" था -> टिप्पणी दर्ज करें -> "पुल अनुरोध बनाएँ"। मूल के आगे 1 प्रतिबद्ध के साथ समाप्त करें।

— कार्टलैंड

5

@ कर्टलैंड (या अन्य) - हाँ, यह कहता है "यह शाखा 1 प्रतिबद्ध है ... से आगे" क्या यह चिंता करने के लिए कुछ है? क्या उस संदेश से छुटकारा पाना संभव है?

— रेन्नीपेट

11

बस अद्यतन या सिंक बटन के साथ यह बेहतर नहीं होगा!

— ट्रांसफार्मर

456

यहाँ कांटा सिंक करने पर GitHub का आधिकारिक दस्तावेज है :

कांटा सिंक करना

स्थापित करना

इससे पहले कि आप सिंक कर सकें, आपको एक रिमोट जोड़ना होगा जो अपस्ट्रीम रिपॉजिटरी को इंगित करता है। आपने ऐसा तब किया होगा जब आप मूल रूप से कांटे थे।

युक्ति: आपके कांटे को सिंक करने से केवल रिपॉजिटरी की आपकी स्थानीय कॉपी अपडेट होती है; यह GitHub पर आपकी रिपॉजिटरी को अपडेट नहीं करता है।
$ git remote -v
# List the current remotes
origin  https://github.com/user/repo.git (fetch)
origin  https://github.com/user/repo.git (push)

$ git remote add upstream https://github.com/otheruser/repo.git
# Set a new remote

$ git remote -v
# Verify new remote
origin    https://github.com/user/repo.git (fetch)
origin    https://github.com/user/repo.git (push)
upstream  https://github.com/otheruser/repo.git (fetch)
upstream  https://github.com/otheruser/repo.git (push)
सिंक्रनाइज़ किए जा रहे

अपस्ट्रीम के साथ अपनी रिपॉजिटरी को सिंक करने के लिए दो चरणों की आवश्यकता होती है: पहले आपको रिमोट से लाना होगा, फिर आपको वांछित ब्रांच को अपनी स्थानीय शाखा में मर्ज करना होगा।

ला रहा है

दूरस्थ रिपॉजिटरी से लाकर इसकी शाखाओं और उनके संबंधित क्षेत्रों में लाया जाएगा। ये आपके स्थानीय भंडार में विशेष शाखाओं के तहत संग्रहीत हैं।
$ git fetch upstream
# Grab the upstream remote's branches
remote: Counting objects: 75, done.
remote: Compressing objects: 100% (53/53), done.
remote: Total 62 (delta 27), reused 44 (delta 9)
Unpacking objects: 100% (62/62), done.
From https://github.com/otheruser/repo
 * [new branch]      master     -> upstream/master
अब हमारे पास अपस्ट्रीम की मास्टर शाखा है जो एक स्थानीय शाखा, अपस्ट्रीम / मास्टर में संग्रहीत है
$ git branch -va
# List all local and remote-tracking branches
* master                  a422352 My local commit
  remotes/origin/HEAD     -> origin/master
  remotes/origin/master   a422352 My local commit
  remotes/upstream/master 5fdff0f Some upstream commit
विलय

अब जब हमने अपस्ट्रीम रिपॉजिटरी प्राप्त कर ली है, तो हम इसके परिवर्तनों को अपनी स्थानीय शाखा में मिलाना चाहते हैं। यह उस शाखा को हमारे स्थानीय परिवर्तनों को खोए बिना, अपस्ट्रीम के साथ सिंक में लाएगा।
$ git checkout master
# Check out our local master branch
Switched to branch 'master'

$ git merge upstream/master
# Merge upstream's master into our own
Updating a422352..5fdff0f
Fast-forward
 README                    |    9 -------
 README.md                 |    7 ++++++
 2 files changed, 7 insertions(+), 9 deletions(-)
 delete mode 100644 README
 create mode 100644 README.md
यदि आपकी स्थानीय शाखा के पास कोई अनोखा कमिट नहीं है, तो git इसके बजाय "फास्ट-फॉरवर्ड" करेगा:
$ git merge upstream/master
Updating 34e91da..16c56ad
Fast-forward
 README.md                 |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
युक्ति: यदि आप GitHub पर अपनी रिपॉजिटरी अपडेट करना चाहते हैं, तो यहां दिए गए निर्देशों का पालन करें

— jumpnett
स्रोत

1

यह मेरे स्थानीय कांटे को अपडेट करता है, लेकिन Github.com पर मेरा कांटा अभी भी "43 कमिट्स पीछे" कहता है। मुझे अपने Github.com कांटे में मास्टर परिवर्तनों को मर्ज करने के लिए खुद के लिए एक पुल अनुरोध बनाने के लिए लोबज़िक की तकनीक का उपयोग करना पड़ा।

— माइकल मैकगिनिस

11

@MichaelMcGinnis स्थानीय स्तर पर विलय के बाद, आपको अपने परिवर्तनों को गिटबब में धकेलना होगा। git push origin master

— जंपनेट

1

साथ धकेलने में होशियार हो सकते हैं --follow-tags: stackoverflow.com/a/26438076/667847

— kenny

1

मुझे इसे सभी शाखाओं के लिए अलग-अलग करना है git merge upstream/master, फिर शाखा को विकसित करने के लिए देखें और करेंgit merge upstream/develop

— शोबी

stackoverflow.com/a/14074925/470749 मेरे लिए मददगार था क्योंकि Permission denied (publickey). fatal: Could not read from remote repository.फेसबुक के गितूब अकाउंट से अपस्ट्रीम लाने की कोशिश करने के दौरान मुझे मिल रहा था ।

— रयान

98

बहुत सारे उत्तर अंत में आपके कांटे को आगे बढ़ाते हैं , जो माता-पिता के भंडार से आगे निकल जाते हैं। यह उत्तर यहां पाए गए चरणों का सार प्रस्तुत करता है जो आपके कांटे को माता-पिता के समान ही प्रतिबद्ध करेंगे ।

निर्देशिका को अपने स्थानीय रिपॉजिटरी में बदलें।
- यदि आप नहीं हैं, तो मास्टर शाखा पर जाएँ git checkout master
दूरस्थ रिपॉजिटरी के रूप में माता-पिता को जोड़ें, git remote add upstream <repo-location>
मुद्दा git fetch upstream
मुद्दा git rebase upstream/master
- इस स्तर पर आप जांचते हैं कि टाइप करने से क्या विलय होगा git status
मुद्दा git push origin master

इन आदेशों के बारे में अधिक जानकारी के लिए, चरण 3 देखें ।

— सहर राबिनोविज
स्रोत

13

@ एमटी: आप इन आदेशों को कहां दर्ज करते हैं, हालांकि? प्रश्न का सार, जैसा कि मैं इसे समझता हूं, यह है कि मुख्य परियोजना के साथ अपने व्यक्तिगत गिटहब कांटा को कैसे फिर से संगठित करना है , और यह सब गिटहब से करें । दूसरे शब्दों में, आप स्थानीय रिपॉजिटरी के बिना अपने रिमोट फोर्क को कैसे अपडेट कर सकते हैं ?

— जॉन वाई

4

@ जॉइनथ गीथब का इस्तेमाल हमेशा एक अतिरिक्त कमिटमेंट बनाएगा। उस अतिरिक्त कमिट से बचने के लिए आपको स्थानीय रेपो पर एक शेल में यह सब करने की आवश्यकता है।

— जोनाथन क्रॉस

48

प्राक्कथन: आपका कांटा "मूल" है और जिस भंडार को आपने लिया था, वह "अपस्ट्रीम" है।

मान लेते हैं कि आपने अपने कांटे को अपने कंप्यूटर पर इस तरह से कमांड के साथ पहले ही क्लोन कर लिया है:

git clone git@github.com:your_name/project_name.git
cd project_name

यदि वह दिया जाता है तो आपको इस क्रम में जारी रखने की आवश्यकता है:

अपने क्लोन भंडार में "अपस्ट्रीम" जोड़ें ("मूल"):
```
git remote add upstream git@github.com:original_author/project_name.git
```
"अपस्ट्रीम" से कमिट (और शाखाएं) प्राप्त करें:
```
git fetch upstream
```
अपने कांटे की "मास्टर" शाखा में स्विच करें ("मूल"):
```
git checkout master
```
अपनी "मास्टर" शाखा के परिवर्तनों को रोकें:
```
git stash
```
"अपस्ट्रीम" की "मास्टर" शाखा से अपने "मूल" की "मास्टर" शाखा में परिवर्तन को मिलाएं:
```
git merge upstream/master
```
यदि कोई है तो मर्ज विरोधों को हल करें और अपना मर्ज करें
```
git commit -am "Merged from upstream"
```
अपने कांटे में बदलाव लाएं
```
git push
```
अपने अटके हुए परिवर्तन वापस पाएं (यदि कोई हो)
```
git stash pop
```
हो गया! बधाई हो!

GitHub इस विषय के लिए निर्देश भी प्रदान करता है: एक कांटा सिंक करना

— बेनी न्युगबॉएर
स्रोत

1

आंशिक रूप से मदद की: क्या इसके लिए git remote add upstream git@github.com:original_author/project_name.gitसिर्फ एक उपनाम है git remote add upstream https://github.com/original_author/project_name.git?

— वुल्फ

2

वुल्फ , यह अनुमान लगाते हुए कि आप इसे अब तक जानते हैं, लेकिन बाद के लिए ... यह ssh के लिए प्रारूप है। help.github.com/articles/configuring-a-remote-for-a-fork

— ब्रैड एलिस

2

आपका बहुत बहुत धन्यवाद। git stashऔर git stash popबहुत मददगार

— सत्यमेव जयते

यह काम किया। जीआईटी मर्ज अपस्ट्रीम / मास्टर के बाद, ऑटो मर्ज एकतरफा रास्तों के कारण विफल हो गया, जिसे मुझे गिट ऐड-ए गिट कमिट-एम "संदेश" चलाना था, तब यह अप टू डेट था।

— हाईस्कनबग

47

अगर, मेरी तरह, आप कभी भी सीधे गुरु के लिए कुछ भी नहीं करते हैं , जो आपको वास्तव में करना चाहिए, तो आप निम्नलिखित कार्य कर सकते हैं।

अपने कांटे के स्थानीय क्लोन से, अपना अपस्ट्रीम रिमोट बनाएं। आपको केवल एक बार ऐसा करने की आवश्यकता है:

git remote add upstream https://github.com/whoever/whatever.git

फिर जब भी आप अपस्ट्रीम रिपॉजिटरी मास्टर शाखा के साथ पकड़ना चाहते हैं, तो आपको निम्न करना होगा

git checkout master
git pull upstream master

यह मानते हुए कि आपने कभी भी मास्टर पर कुछ भी नहीं किया है आपको पहले से ही किया जाना चाहिए। अब आप अपने स्थानीय मास्टर को अपने मूल दूरस्थ GitHub कांटा पर धकेल सकते हैं। आप अपने अब तक के स्थानीय मास्टर पर अपनी विकास शाखा को भी वापस कर सकते हैं।

प्रारंभिक अपस्ट्रीम सेटअप और मास्टर चेकआउट को विगत करें, आपको केवल अपने मास्टर को अपस्ट्रीम के साथ सिंक करने के लिए निम्न कमांड को चलाने की आवश्यकता है: गिट्टी अपस्ट्रीम मास्टर ।

— Slion
स्रोत

45

नवंबर 2013 के बाद से GitHub के साथ एक अनौपचारिक सुविधा का अनुरोध खुला है, जिससे उन्हें स्थानीय कांटे को ऊपर की तरफ रखने के लिए एक बहुत ही सरल और सहज विधि जोड़ने के लिए कहा जा सके:

https://github.com/isaacs/github/issues/121

नोट: चूँकि फीचर अनुरोध अनौपचारिक है इसलिए इस सुविधा को लागू support@github.comकरने के लिए अपने समर्थन को जोड़ने के लिए संपर्क करना भी उचित है । ऊपर अनौपचारिक सुविधा अनुरोध का उपयोग इस ब्याज की राशि के साक्ष्य के रूप में किया जा सकता है।

— isedwards
स्रोत

23

इस उत्तर की तिथि के अनुसार, GitHub ने वेब इंटरफ़ेस में इस सुविधा को ( या अब मैं नहीं कहूंगा? ) किया है। हालाँकि, आप इसके support@github.comलिए अपना वोट जोड़ने के लिए कह सकते हैं।

इस बीच, GitHub उपयोगकर्ता bardiharborow ने ऐसा करने के लिए एक उपकरण बनाया है: https://upriver.github.io/

स्रोत यहां है: https://github.com/upriver/upriver.github.io

— Lucero
स्रोत

2

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

— सोरिन

2

आज के अनुसार, मैंने अपस्ट्रीम रेपो के साथ कांटा सिंक करने के लिए upriver का सफलतापूर्वक उपयोग किया है, इसलिए यह मेरे उद्देश्यों के लिए काम कर रहा है और मैं इसका उपयोग करना जारी रखूंगा।

— नॉटिकलमाइल

1

@sorin ये 20 रेपो / शाखा सीमा (बल्कि, यह अब 30 है) GitHub डिफ़ॉल्ट पेजिंग सेटिंग्स से आता है। इसे संभालने के लिए कोड में कुछ अनुकूलन करने की आवश्यकता है।

— एंड्रियास

19

यदि आप Windows या Mac के लिए GitHub का उपयोग कर रहे हैं, तो अब उनके पास फोर्क्स को अपडेट करने के लिए एक-क्लिक सुविधा है:

UI में रिपॉजिटरी का चयन करें।
"उपयोगकर्ता / शाखा से अपडेट करें" बटन पर क्लिक करें।

— शीतल शाह
स्रोत

2

कदम से कदम: github.com/desktop/desktop/issues/1785#issuecomment-483011281

— आलमकांबरा

11

दरअसल, ब्राउज़र में अपस्ट्रीम की किसी भी ओर से आपके कांटे में एक शाखा बनाना संभव है:

खोलें https://github.com/<repo>/commits/<hash>, जहां रेपो आपका कांटा है, और हैश कमिट का पूर्ण हैश है, जिसे आप अपस्ट्रीम वेब इंटरफेस में पा सकते हैं। उदाहरण के लिए, मैं https://github.com/max630/linux/commits/0aa33ffdd7676dd4747cc3f179feb097d28990 खोल सकता हूं , जो linux masterलिखने के समय की ओर इशारा करता है।
"ट्री: ...." बटन पर क्लिक करें।
नई शाखा का नाम टाइप करें और दबाएँ Enter

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

यह कैसे काम करता है (यह एक अनुमान है, मुझे नहीं पता कि GitHub यह कैसे करता है): कांटे साझा वस्तु भंडारण और उपयोगकर्ताओं के संदर्भों को अलग करने के लिए नेमस्पेस का उपयोग करते हैं । इसलिए आप अपने फोर्क के माध्यम से सभी कमिट्स तक पहुंच सकते हैं, भले ही वे फोर्किंग के समय तक मौजूद न हों।

— max630
स्रोत

2

यह भी खूब रही! यह उन लोगों की पूरी तरह से व्यर्थ अपलोड से बचा जाता है जो गिटहब तक जाते हैं।

— रटासर

9

नीचे दिए गए चरणों का पालन करें। मैंने उन्हें आजमाया और इससे मुझे मदद मिली।

अपनी शाखा को चेकआउट करें

सिंटैक्स: गिट ब्रांच yourDevelopmentBranch
उदाहरण: git चेकआउट मास्टर

नवीनतम कोड प्राप्त करने के लिए स्रोत रिपॉजिटरी शाखा खींचें

सिंटैक्स: git pull https://github.com/tastejs/awesome-app-ideas मास्टर
उदाहरण: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

— Venkat.R
स्रोत

1

यदि आप GitHub का उपयोग कर रहे हैं, तो आप अपने परिवर्तन को अपनी GitHub शाखा में धकेलना चाह सकते हैं। git push HttpsForYourForkOfTheRepo BRANCH_NAME

— user3731622

9

मैं इस एक लाइन के साथ अपने कांटे के रेपो को अपडेट करता हूं:

git pull https://github.com/forkuser/forkedrepo.git branch

यदि आप अपने प्रोजेक्ट में कोई अन्य दूरस्थ समापन बिंदु जोड़ना नहीं चाहते हैं, तो इसका उपयोग करें, जैसा कि अन्य समाधान यहां पोस्ट किया गया है।

— R.Bravo
स्रोत

2

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

— लाइटसीसी

1

यह एक दूरस्थ शाखा से एक सामान्य पुल की तरह काम करता है। यदि आपने अपने स्थानीय रेपो पर एक्स किया और अब आप वाई हैं तो मूल रेपो के पीछे है, यह वाई कमिट्स को आपकी स्थानीय शाखा में लाएगा और, शायद, आपको हल करने के लिए कुछ संघर्ष मिलेंगे।

— आर .ब्रावो

1

@LightCC यह पहले से जोड़े गए रिमोट से खींचने से अलग नहीं है, इस तथ्य को छोड़कर कि आपने रिमोट नहीं जोड़ा है । इसलिए नुकसान यह है कि आपको हर बार पूर्ण रिपॉजिटरी URL दर्ज करना होगा pull।

— मार्क.2377

1

यह एक सही समाधान है अगर आपको मूल रेपो से कई बार खींचने की ज़रूरत नहीं है, या कांटा गया प्रोजेक्ट अपेक्षाकृत सरल है।

— एक्सपेफेक्ट

7

इस उत्तर के पूरक के रूप में, मैं एक ही बार में अपस्ट्रीम शाखाओं से अपने क्लोन रेपो ( उत्पत्ति ) की सभी दूरस्थ शाखाओं को अपडेट करने का एक तरीका ढूंढ रहा था । मैंने इस तरह से इसे किया।

यह मानता है कि आपने पहले ही स्रोत रिपॉजिटरी में एक अपस्ट्रीम रिमोट को कॉन्फ़िगर कर दिया है (जहां से मूल को मिटाया गया था) और इसके साथ समन्वयित किया है git fetch upstream।

फिर भागो:

for branch in $(git ls-remote --heads upstream|sed 's#^.*refs/heads/##'); do git push origin refs/remotes/upstream/$branch:refs/heads/$branch; done

इस कमांड का पहला भाग अपस्ट्रीम रिमोट रेपो में सभी प्रमुखों को सूचीबद्ध करता है और SHA-1 को refs/heads/शाखा नाम उपसर्ग के बाद हटाता है ।

फिर इन शाखाओं में से प्रत्येक के लिए, यह अपस्ट्रीम रिमोट ट्रैकिंग शाखा की स्थानीय प्रति ( refs/remotes/upstream/<branch>स्थानीय तरफ) को सीधे मूल शाखा पर ( refs/heads/<branch>दूरस्थ पक्ष पर) धकेलता है ।

इनमें से कोई भी शाखा सिंक आदेश दो कारणों में से एक के लिए विफल हो सकता है: या तो अपस्ट्रीम शाखा को फिर से लिखा गया है, या आपने उस शाखा पर अपने कांटे पर कमिट को धकेल दिया है। पहले मामले में जहां आपने अपने कांटे पर शाखा के लिए कुछ भी प्रतिबद्ध नहीं किया है, यह जबरदस्ती पुश करने के लिए सुरक्षित है ( -f स्विच जोड़ें ; यानी git push -fऊपर कमांड में)। अन्य मामले में यह सामान्य है क्योंकि आपकी कांटा शाखा का विचलन हो गया है और आप तब तक सिंक कमांड के काम करने की उम्मीद नहीं कर सकते जब तक कि आपके कमिट्स को वापस अपस्ट्रीम में विलय नहीं किया गया हो ।

— थॉमस गयोट-सायननेस्ट
स्रोत

6

"पुल" एप्लिकेशन एक स्वत: सेट अप और भूल जाते हैं समाधान है। यह अपस्ट्रीम रिपॉजिटरी के साथ आपके कांटे की डिफ़ॉल्ट शाखा को सिंक करेगा।

URL पर जाएं, हरे "इंस्टॉल करें" बटन पर क्लिक करें और उन रिपॉजिटरी का चयन करें जहां आप स्वचालित सिंक्रनाइज़ेशन को सक्षम करना चाहते हैं।

GitHub पर प्रति घंटे एक बार सीधे शाखा को अपडेट किया जाता है, अपनी स्थानीय मशीन पर आपको यह सुनिश्चित करने के लिए मास्टर शाखा को खींचने की आवश्यकता होती है कि आपकी स्थानीय कॉपी सिंक में है।

— krlmlr
स्रोत

2

कृपया ध्यान दें कि मूल सेटअप के साथ, आप अपने कांटे हुए भंडार में किए गए परिवर्तनों को खो सकते हैं। परिवर्तनों को रखने के लिए, एक कॉन्फ़िगर फ़ाइल सेट करें और निर्दिष्ट करें mergemethod। इस पर अधिक यहाँ

— सौरभ पी। भंडारी

1

मैंने ध्यान दिया कि मूल सेटअप पुल अनुरोध भेजता है और उन्हें मर्ज करता है (जैसा कि प्रलेखन में कहा गया है) के विपरीत। यह थोड़ा कष्टप्रद है लेकिन डेटा हानि की समस्या को हल करता है?

— krlmlr

4

एंड्रॉइड स्टूडियो ने अब GitHub कांटा रिपॉजिटरी के साथ काम करना सीख लिया है (आपको कंसोल कमांड द्वारा "अपस्ट्रीम" रिमोट रिपॉजिटरी को जोड़ना भी नहीं है)।

ओपन मेनू VCS → Git

और दो अंतिम पॉपअप मेनू आइटम पर ध्यान दें:

मेरे गितहब काँटा रीबसे
पुल अनुरोध बनाएँ

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

(मैं "Git एकीकरण" और "GitHub" प्लगइन्स के साथ एंड्रॉइड स्टूडियो 3.0 का उपयोग करता हूं।)

— alexshr
स्रोत

4

जब आपने अपने forked repository को क्लोन कर लिया है, तो उस डायरेक्टरी पथ पर जाएँ जहाँ आपका क्लोन रहता है और आपके Git Bash Terminal में कुछ पंक्तियाँ हैं।

$ cd project-name

$ git remote add upstream https://github.com/user-name/project-name.git
 # Adding the upstream -> the main repo with which you wanna sync

$ git remote -v # you will see the upstream here 

$ git checkout master # see if you are already on master branch

$ git fetch upstream

और वहां आप जाने के लिए अच्छे हैं। मुख्य रिपॉजिटरी में सभी अपडेट किए गए परिवर्तन आपके कांटा रिपॉजिटरी में धकेल दिए जाएंगे।

"लाने" आदेश एक परियोजना में अप-टू-डेट रहने के लिए अपरिहार्य है: केवल "गिट लाने" का प्रदर्शन करते समय आपको उन परिवर्तनों के बारे में सूचित किया जाएगा जो आपके सहयोगियों को दूरस्थ सर्वर पर धकेल दिए गए हैं।

आप आगे के प्रश्नों के लिए अभी भी यहां जा सकते हैं

— प्रतीक चंदा
स्रोत

4

अगर आप अपना अपस्ट्रीम सेट करते हैं। के साथ जाँच करें git remote -v, तो यह पर्याप्त होगा।

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git push

— prosti
स्रोत

2

यह आपके भंडार के आकार पर निर्भर करता है और आपने इसे कैसे भुनाया।

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

इस एक को पढ़ने की कोशिश करो । यह वर्णन करता है कि बड़े गिट रिपॉजिटरी को कैसे संभालना है और नवीनतम परिवर्तनों के साथ उन्हें कैसे अपस्ट्रीम करना है।

— s0nicYouth
स्रोत

2

मैं @ krlmlr के उत्तर को जोड़ना चाहूंगा ।

प्रारंभ में, फोर्क रिपॉजिटरी की एक शाखा है जिसका नाम है master:। यदि आप एक नई सुविधा या फिक्स पर काम कर रहे हैं, तो आप आम तौर पर एक नई शाखा featureबना सकते हैं और बदलाव कर सकते हैं।

यदि आप चाहते हैं कि जाली रिपॉजिटरी मूल रिपॉजिटरी के साथ सिंक में हो, तो आप पुल एप्लिकेशन ( फीचर शाखा मेंpull.yml ) के लिए एक कॉन्फिग फाइल ( ) इस तरह सेट कर सकते हैं :

version: "1"
rules:
  - base: feature
    upstream: master
    mergeMethod: merge
  - base: master
    upstream: parent_repo:master
    mergeMethod: hardreset

यह masterमाता-पिता रेपो के साथ कांटे की रेपो-अप-टू-डेट की शाखा रखता है । यह featureकांटे वाले रेपो की masterशाखा को उसी के साथ विलय करके फोर्क्ड रेपो की शाखा के माध्यम से अद्यतन रखता है । यह मानता है कि featureशाखा डिफ़ॉल्ट शाखा है जिसमें विन्यास फाइल है।

यहां दो mergemethodsनाटक चल रहे हैं, एक वह है hardresetजो masterअभिभावक रेपो की शाखा में सिंक परिवर्तन को बल देने में मदद करता है और दूसरा तरीका है merge। इस पद्धति का उपयोग featureशाखा में आपके द्वारा किए गए परिवर्तनों और शाखा में बल सिंक के कारण किए गए परिवर्तनों को मर्ज करने के लिए किया जाता है master। मर्ज संघर्ष के मामले में, पुल एप्लिकेशन आपको पुल अनुरोध के दौरान कार्रवाई के अगले कोर्स को चुनने की अनुमति देगा।

आप बुनियादी और उन्नत कॉन्फ़िगरेशन और विभिन्न के बारे में पढ़ सकते हैं mergemethods यहाँ ।

मैं वर्तमान में मेरे काँटेदार रेपो में इस विन्यास का उपयोग कर रहा यहाँ यकीन है कि एक वृद्धि का अनुरोध करने के लिए यहाँ रहता अपडेट किया गया।

— सौरभ पी। भंडारी
स्रोत

1

कांटे वाली रिपॉजिटरी को हमेशा अच्छे के लिए अपडेट रखने पर दो मुख्य बातें हैं।

1. कांटा मास्टर से शाखाएं बनाएं और वहां परिवर्तन करें ।

इसलिए जब आपका पुल अनुरोध स्वीकार किया जाता है तो आप सुरक्षित रूप से शाखा को हटा सकते हैं क्योंकि आपका योगदान कोड तब आपके forked रिपॉजिटरी के मास्टर में रहेगा जब आप इसे अपस्ट्रीम के साथ अपडेट करते हैं। इसके द्वारा आपका स्वामी हमेशा एक और परिवर्तन करने के लिए एक नई शाखा बनाने के लिए स्वच्छ स्थिति में रहेगा।

2. स्वचालित रूप से अपडेट करने के लिए कांटा मास्टर के लिए एक अनुसूचित नौकरी बनाएं ।

यह क्रोन के साथ किया जा सकता है । यहाँ एक उदाहरण कोड के लिए है यदि आप इसे लिनक्स में करते हैं।

$ crontab -e

crontab fileप्रति घंटा के आधार पर काम को अंजाम देने के लिए इस कोड को डालें ।

0 * * * * sh ~/cron.sh

फिर cron.shस्क्रिप्ट फ़ाइल और ssh- एजेंट और / या नीचे के रूप में अपेक्षा के साथ एक git इंटरैक्शन बनाएं

#!/bin/sh
WORKDIR=/path/to/your/dir   
REPOSITORY=<name of your repo>
MASTER="git@github.com:<username>/$REPOSITORY.git"   
UPSTREAM=git@github.com:<upstream>/<name of the repo>.git  

cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent` && expect ~/.ssh/agent && ssh-add -l
git clone $MASTER && cd $REPOSITORY && git checkout master
git remote add upstream $UPSTREAM && git fetch --prune upstream
if [ `git rev-list HEAD...upstream/master --count` -eq 0 ]
then
    echo "all the same, do nothing"
else
    echo "update exist, do rebase!"
    git reset --hard upstream/master
    git push origin master --force
fi
cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent -k`

अपने कांटे के भंडार की जाँच करें। समय-समय पर यह अधिसूचना दिखाता रहेगा:

यह शाखा यहाँ तक है <upstream>: स्वामी ।

— Chetabahana
स्रोत

0

इन आदेशों का उपयोग करें (भाग्यशाली मामले में)

git remote -v
git pull
git fetch upstream
git checkout master
git merge upstream/master --no-ff
git add .
git commit -m"Sync with upstream repository."
git push -v

— करो न्हु व्य
स्रोत