[git] 'गिट पुल' और 'गिट फ़ेच' के बीच क्या अंतर है?



Answers

  • जब आप pull उपयोग करते हैं, तो गिट स्वचालित रूप से आपके लिए अपना काम करने की कोशिश करता है। यह संदर्भ संवेदनशील है , इसलिए गिट उस शाखा में किसी भी खींची गई मज़े को मर्ज करेगा जो आप वर्तमान में काम कर रहे हैं। pull स्वचालित रूप से आपको उनकी समीक्षा करने के बिना कामों को विलय कर लेती है । यदि आप अपनी शाखाओं का बारीकी से प्रबंधन नहीं करते हैं, तो आप लगातार संघर्ष में भाग ले सकते हैं।

  • जब आप fetch , तो गिट लक्ष्य शाखा से कोई भी काम एकत्र करता है जो आपकी वर्तमान शाखा में मौजूद नहीं है और उन्हें आपके स्थानीय भंडार में संग्रहीत करता है । हालांकि, यह उन्हें आपकी वर्तमान शाखा के साथ विलय नहीं करता है । यह विशेष रूप से उपयोगी होता है यदि आपको अपनी रिपॉजिटरी को अद्यतित रखने की आवश्यकता है, लेकिन कुछ ऐसी चीजों पर काम कर रहे हैं जो आपकी फ़ाइलों को अपडेट करते हैं तो तोड़ सकते हैं। अपनी मास्टर शाखा में काम को एकीकृत करने के लिए, आप merge उपयोग करते हैं।

Question

git pull और git fetch बीच अंतर क्या हैं?




आप रिमोट रिपोजिटरी से प्राप्त कर सकते हैं, अंतर देखें और फिर खींचें या मर्ज करें।

यह origin नामक रिमोट रिपोजिटरी का एक उदाहरण है और दूरस्थ शाखा origin/master ट्रैक करने वाले master नामक एक शाखा है:

git checkout master                                                  
git fetch                                        
git diff origin/master
git rebase origin master



मुझे इन चीजों को समझने के लिए स्थिति का कुछ दृश्य प्रतिनिधित्व करना पसंद है। हो सकता है कि अन्य डेवलपर इसे भी देखना चाहें, इसलिए यहां मेरा जोड़ा है। मुझे पूरा यकीन नहीं है कि यह सब सही है, इसलिए अगर आपको कोई गलती मिलती है तो कृपया टिप्पणी करें।

                                         LOCAL SYSTEM
                  . =====================================================    
================= . =================  ===================  =============
REMOTE REPOSITORY . REMOTE REPOSITORY  LOCAL REPOSITORY     WORKING COPY
(ORIGIN)          . (CACHED)           
for example,      . mirror of the      
a github repo.    . remote repo
Can also be       .
multiple repo's   .
                  .
                  .
FETCH  *------------------>*
Your local cache of the remote is updated with the origin (or multiple
external sources, that is git's distributed nature)
                  .
PULL   *-------------------------------------------------------->*
changes are merged directly into your local copy. when conflicts occur, 
you are asked for decisions.
                  .
COMMIT            .                             *<---------------*
When coming from, for example, subversion, you might think that a commit
will update the origin. In git, a commit is only done to your local repo.
                  .
PUSH   *<---------------------------------------*
Synchronizes your changes back into the origin.

रिमोट के लेटे हुए दर्पण के लिए कुछ प्रमुख फायदे हैं:

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



git fetch pulls down the code from the remote server to your tracking branches in your local repository. If your remote is named origin (the default) then these branches will be within origin/ , for example origin/master , origin/mybranch-123 , etc. These are not your current branches, they are local copies of those branches from the server.

git pull does a git fetch but then also merges the code from the tracking branch into your current local version of that branch. If you're not ready for that changes yet, just git fetch first.




यह समझने के लिए मुझे थोड़ा सा खर्च आया कि क्या अंतर था, लेकिन यह एक साधारण स्पष्टीकरण है। आपके लोकहोस्ट में master एक शाखा है।

जब आप एक रिपॉजिटरी क्लोन करते हैं तो आप स्थानीय होस्ट में संपूर्ण भंडार प्राप्त करते हैं। इसका मतलब है कि उस समय आपके पास HEAD लिए मूल / मास्टर पॉइंटर होता है और मास्टर एक ही HEAD इंगित करता है।

जब आप काम करना शुरू करते हैं और करते हैं तो आप मास्टर पॉइंटर को HEAD + पर ले जाते हैं। लेकिन मूल / मास्टर पॉइंटर अभी भी इंगित कर रहा है कि जब आपने क्लोन किया था तो यह क्या था।

तो अंतर होगा:

  • यदि आप git fetch करते हैं तो यह रिमोट रिपोजिटरी ( GitHub ) में सभी बदलाव GitHub और मूल / मास्टर पॉइंटर को HEAD । इस बीच आपका स्थानीय शाखा मास्टर इस बात पर ध्यान रखेगा कि यह कहां है।
  • यदि आप git pull , तो यह मूल रूप से लाएगा (जैसा कि पहले बताया गया है) और अपनी मास्टर शाखा में कोई भी नया बदलाव मर्ज करें और पॉइंटर को HEAD



Actually Git maintains a copy of your own code and the remote repository.

The command git fetch makes your local copy up to date by getting data from remote repository. The reason we need this is because somebody else might have made some changes to the code and you want to keep yourself updated.

The command git pull brings the changes in the remote repository to where you keep your own code. Normally, git pull does this by doing a 'git fetch' first to bring the local copy of the remote repository up to date, and then it merges the changes into your own code repository and possibly your working copy.




From Pro Git § 2.5 Git Basics - Working with Remotes: Fetching and Pulling from Your Remotes :

It's important to note that the fetch command pulls the data to your local repository — it doesn't automatically merge it with any of your work or modify what you're currently working on. You have to merge it manually into your work when you're ready.

If you have a branch set up to track a remote branch, you can use the git pull command to automatically fetch and then merge a remote branch into your current branch. This may be an easier or more comfortable workflow for you; and by default, the git clone command automatically sets up your local master branch to track the remote master branch on the server you cloned from (assuming the remote has a master branch). Running git pull generally fetches data from the server you originally cloned from and automatically tries to merge it into the code you're currently working on.




We simply say:

git pull == git fetch + git merge

If you run git pull , you do not need to merge the data to local. If you run git fetch , it means you must run git merge for getting the latest code to your local machine. Otherwise, the local machine code would not be changed without merge.

So in the Git Gui, when you do fetch, you have to merge the data. Fetch itself won't make the code changes at your local. You can check that when you update the code by fetching once fetch and see; the code it won't change. Then you merge... You will see the changed code.




OK , here are some information about git pull and git fetch , so you can understand the actual differences... in few simple words, fetch gets the latest data, but not the code changes and not going to mess with your current code, but pull get the code changes and merge it your local branch, read on to get more details about each:

गिट fetch

It will download all refs and object and any new branches to local Repository...

Fetch branches and/or tags (collectively, "refs") from one or more other repositories, along with the objects necessary to complete their histories. Remote-tracking branches are updated (see the description of below for ways to control this behavior).

By default, any tag that points into the histories being fetched is also fetched; the effect is to fetch tags that point at branches that you are interested in. This default behavior can be changed by using the --tags or --no-tags options or by configuring remote..tagOpt. By using a refspec that fetches tags explicitly, you can fetch tags that do not point into branches you are interested in as well.

git fetch can fetch from either a single named repository or URL, or from several repositories at once if is given and there is a remotes. entry in the configuration file. (See git-config 1 ).

When no remote is specified, by default the origin remote will be used, unless there's an upstream branch configured for the current branch.

The names of refs that are fetched, together with the object names they point at, are written to .git/FETCH_HEAD. This information may be used by scripts or other git commands, such as git-pull.

git pull

It will apply the changes from remote to the current branch in local...

Incorporates changes from a remote repository into the current branch. In its default mode, git pull is shorthand for git fetch followed by git merge FETCH_HEAD.

More precisely, git pull runs git fetch with the given parameters and calls git merge to merge the retrieved branch heads into the current branch. With --rebase, it runs git rebase instead of git merge.

should be the name of a remote repository as passed to git-fetch 1 . can name an arbitrary remote ref (for example, the name of a tag) or even a collection of refs with corresponding remote-tracking branches (eg, refs/heads/ :refs/remotes/origin/ ), but usually it is the name of a branch in the remote repository.

Default values for and are read from the "remote" and "merge" configuration for the current branch as set by git-branch --track.

I also create the visual below to show you how git fetch and git pull working together...

1




The only difference between git pull and git fetch is that :

git pull pulls from a remote branch and merges it.

git fetch only fetches from the remote branch but it does not merge

ie git pull = git fetch + git merge ...




बोनस:

उपरोक्त उत्तरों में पुल और लाने की बात करते हुए, मैं एक दिलचस्प चाल साझा करना चाहता हूं,

git pull --rebase

यह उपरोक्त आदेश मेरे गिट जीवन में सबसे उपयोगी कमांड है जो बहुत समय बचाता है।

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

यहां विवरण प्राप्त करें: http://gitolite.com/git-pull--rebase







git pull == ( git fetch + git merge)

git fetch does not changes to local branches.

If you already have a local repository with a remote set up for the desired project, you can grab all branches and tags for the existing remote using git fetch . ... Fetch does not make any changes to local branches, so you will need to merge a remote branch with a paired local branch to incorporate newly fetch changes. from github




What is the difference between git pull and git fetch ?

To understand this, you first need to understand that your local git maintains not only your local repository, but it also maintains a local copy of the remote repository.

git fetch brings your local copy of the remote repository up to date. For example, if your remote repository is GitHub - you may want to fetch any changes made in the remote repository to your local copy of it the remote repository. This will allow you to perform operations such as compare or merge.

git pull on the other hand will bring down the changes in the remote repository to where you keep your own code. Typically, git pull will do a git fetch first to bring the local copy of the remote repository up to date, and then it will merge the changes into your own code repository and possibly your working copy.




संक्षिप्त

git fetch pull समान है लेकिन विलय नहीं करता है। यानी यह रिमोट अपडेट ( refs और objects ) प्राप्त करता है लेकिन आपका स्थानीय वही रहता है (यानी origin/master अपडेट हो जाता है लेकिन master वही रहता है)।

git pull एक रिमोट से नीचे खींचता है और तुरंत विलीन हो जाता है।

अधिक

git clone क्लोन एक रेपो।

git rebase आपके वर्तमान शाखा से सामान बचाता है जो अपस्ट्रीम शाखा में अस्थायी क्षेत्र में नहीं है। आपकी शाखा अब आपके बदलावों से पहले जैसी ही है। तो, git pull -rebase रिमोट git pull -rebase को खींच देगा, अपनी स्थानीय शाखा को रिवाइंड करेगा, जब तक कि आप अद्यतित न हों तब तक अपनी मौजूदा शाखा के शीर्ष पर अपने बदलावों को दोबारा git pull -rebase

इसके अलावा, git branch -a आपको दिखाएगी कि आपकी सभी शाखाओं - स्थानीय और रिमोट के साथ क्या चल रहा है।

यह ब्लॉग पोस्ट उपयोगी था:

गिट पुल, गिट फ़ेच और गिट क्लोन (और गिट रिबेस) के बीच का अंतर - माइक पियर्स

और git pull , git fetch , git clone और git rebase कवर शामिल हैं।

====

अद्यतन करें

मैंने सोचा कि मैं यह दिखाने के लिए अपडेट करूंगा कि आप वास्तव में अभ्यास में इसका उपयोग कैसे करेंगे।

  1. रिमोट से अपना स्थानीय रेपो अपडेट करें (लेकिन मर्ज न करें):

    गिट fetch

  2. अपडेट डाउनलोड करने के बाद, अंतरों को देखते हैं:

    गिट diff मास्टर मूल / मास्टर

  3. यदि आप उन अपडेट से खुश हैं, तो विलय करें:

    गिट खींचो

टिप्पणियाँ:

चरण 2 पर: स्थानीय और रिमोट के बीच अंतर पर अधिक के लिए, देखें: रिमोट शाखा के साथ स्थानीय गिट शाखा की तुलना करें?

चरण 3 पर: यह संभवतः एक git rebase origin करने के लिए शायद अधिक सटीक (उदाहरण के लिए एक तेज़ बदलते रेपो पर) है। एक और जवाब में @ जस्टिन ओहम्स टिप्पणी देखें।

यह भी देखें: longair.net/blog/2009/04/16/git-fetch-and-merge






Related