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




15 Answers

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

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

git git-pull git-fetch

मॉडरेटर नोट: यह देखते हुए कि इस प्रश्न में पहले से ही साठ-सात उत्तर पोस्ट किए गए हैं (उनमें से कुछ हटा दिए गए हैं), इस पर विचार करें कि आप किसी और को पोस्ट करने से पहले कुछ नया योगदान दे रहे हैं या नहीं।

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







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

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

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

तो अंतर होगा:

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



संक्षिप्त

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




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

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

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



यह इंटरैक्टिव ग्राफिकल प्रतिनिधित्व गिट को कम करने में बहुत मददगार है: http://ndpsoftware.com/git-cheatsheet.html

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




ठीक है , यहां git pull और git fetch बारे में कुछ जानकारी दी गई है, ताकि आप वास्तविक मतभेदों को समझ सकें ... कुछ सरल शब्दों में, लाने के लिए नवीनतम डेटा प्राप्त होता है, लेकिन कोड में परिवर्तन नहीं होता है और आपके वर्तमान स्थानीय शाखा कोड के साथ गड़बड़ नहीं होता है , लेकिन कोड परिवर्तन प्राप्त करें और इसे अपनी स्थानीय शाखा में विलय करें, प्रत्येक के बारे में अधिक जानकारी प्राप्त करने के लिए पढ़ें:

गिट fetch

यह आपके स्थानीय रिपोजिटरी में सभी रेफरी और ऑब्जेक्ट्स और कोई भी नई शाखा डाउनलोड करेगा ...

अपने इतिहास को पूरा करने के लिए आवश्यक वस्तुओं के साथ, एक या अधिक अन्य भंडारों से शाखाएं और / या टैग (सामूहिक रूप से, "रेफरी") प्राप्त करें। रिमोट-ट्रैकिंग शाखाएं अपडेट की गई हैं (इस व्यवहार को नियंत्रित करने के तरीकों के लिए नीचे दिए गए विवरण देखें)।

डिफ़ॉल्ट रूप से, किसी भी टैग जो इतिहास में इंगित किया जाता है उसे भी लाया जाता है; प्रभाव उन टैग्स को लाने के लिए है जो आपकी रुचि रखने वाली शाखाओं पर इंगित करते हैं। यह डिफ़ॉल्ट व्यवहार --tags या --no-tag विकल्पों का उपयोग करके या दूरस्थ..tagOpt को कॉन्फ़िगर करके बदला जा सकता है। एक रेफस्पेक का उपयोग करके जो टैग को स्पष्ट रूप से लाता है, आप टैग ला सकते हैं जो आपकी रुचि रखने वाली शाखाओं में इंगित नहीं करते हैं।

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

जब कोई रिमोट निर्दिष्ट नहीं किया जाता है, डिफ़ॉल्ट रूप से मूल रिमोट का उपयोग किया जाएगा, जब तक कि वर्तमान शाखा के लिए अपस्ट्रीम शाखा कॉन्फ़िगर नहीं की जाती है।

रेफरी के नाम जो प्राप्त किए जाते हैं, साथ ही ऑब्जेक्ट नामों के साथ वे इंगित करते हैं, .git / FETCH_HEAD पर लिखे गए हैं। यह जानकारी स्क्रिप्ट या अन्य गिट कमांड, जैसे गिट-पुल द्वारा उपयोग की जा सकती है।

गिट खींचो

यह स्थानीय से स्थानीय शाखा में रिमोट से परिवर्तन लागू करेगा ...

एक रिमोट रिपोजिटरी से मौजूदा शाखा में परिवर्तन शामिल है। अपने डिफ़ॉल्ट मोड में, गिट पुल गिट फ़ेच के लिए शॉर्टेंड होता है जिसके बाद गिट विलय FETCH_HEAD होता है।

अधिक सटीक रूप से, गिट पुल दिए गए पैरामीटर के साथ गिट फ़ेच चलाता है और पुनर्प्राप्त शाखा प्रमुखों को वर्तमान शाखा में विलय करने के लिए गिट विलय को कॉल करता है। --Rebase के साथ, यह गिट विलय के बजाय गिट रिबेस चलाता है।

गिट-फ़ेच 1 को पास किए गए रिमोट रिपोजिटरी का नाम होना चाहिए। एक मनमानी रिमोट रेफ (उदाहरण के लिए, टैग का नाम) या यहां तक ​​कि संबंधित रिमोट-ट्रैकिंग शाखाओं (जैसे, रेफ / हेड / : रेफ / रिमोट / मूल / ) के साथ रेफरी का संग्रह भी हो सकता है, लेकिन आमतौर पर यह नाम है रिमोट रिपोजिटरी में एक शाखा का।

गिट-शाखा --track द्वारा निर्धारित वर्तमान शाखा के लिए "दूरस्थ" और "विलय" कॉन्फ़िगरेशन से डिफ़ॉल्ट मान और पढ़े जाते हैं।

मैं आपको यह दिखाने के लिए नीचे दिया गया दृश्य भी बनाता हूं कि कैसे git fetch और git pull एक साथ काम कर रहा है ...

1




मैंने इसके साथ भी संघर्ष किया है। वास्तव में मैं यहां एक ही प्रश्न की एक Google खोज के साथ मिला। आखिरकार इन सभी उत्तरों को पढ़ने से मेरे सिर में एक तस्वीर पेंट हो गई और मैंने इसे 2 रिपॉजिटरीज़ और 1 सैंडबॉक्स की स्थिति और समय के साथ किए गए कार्यों को देखने के लिए इसे देखने का प्रयास करने का फैसला किया। तो यहां मैं क्या आया था। अगर मैं कहीं भी गड़बड़ कर दूं तो कृपया मुझे सही करें।

एक fetch के साथ तीन repos:

---------------------     -----------------------     -----------------------
- Remote Repo       -     - Remote Repo         -     - Remote Repo         -
-                   -     - gets pushed         -     -                     -
- @ R01             -     - @ R02               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Repo        -     - Local Repo          -     - Local Repo          -
- pull              -     -                     -     - fetch               -
- @ R01             -     - @ R01               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Sandbox     -     - Local Sandbox       -     - Local Sandbox       -
- Checkout          -     - new work done       -     -                     -
- @ R01             -     - @ R01+              -     - @R01+               -
---------------------     -----------------------     -----------------------

एक पुल के साथ तीन repos

---------------------     -----------------------     -----------------------
- Remote Repo       -     - Remote Repo         -     - Remote Repo         -
-                   -     - gets pushed         -     -                     -
- @ R01             -     - @ R02               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Repo        -     - Local Repo          -     - Local Repo          -
- pull              -     -                     -     - pull                -
- @ R01             -     - @ R01               -     - @ R02               -
---------------------     -----------------------     -----------------------

---------------------     -----------------------     -----------------------
- Local Sandbox     -     - Local Sandbox       -     - Local Sandbox       -
- Checkout          -     - new work done       -     - merged with R02     -
- @ R01             -     - @ R01+              -     - @R02+               -
---------------------     -----------------------     -----------------------

इससे मुझे समझने में मदद मिली कि एक fetch क्यों महत्वपूर्ण है।




हम बस कहते हैं:

git pull == git fetch + git merge

यदि आप चलाते हैं git pull, तो आपको डेटा को स्थानीय में मर्ज करने की आवश्यकता नहीं है। यदि आप चलाते हैं git fetch, तो इसका मतलब है कि आपको git mergeअपनी स्थानीय मशीन पर नवीनतम कोड प्राप्त करने के लिए भाग लेना चाहिए । अन्यथा, स्थानीय मशीन कोड मर्ज किए बिना बदला नहीं जाएगा।

तो गिट गुई में, जब आप प्राप्त करते हैं, तो आपको डेटा मर्ज करना होगा। खुद को प्राप्त करें आपके स्थानीय पर कोड परिवर्तन नहीं करेगा। आप यह जांच सकते हैं कि जब आप एक बार लाने और देखने के द्वारा कोड अपडेट करके अपडेट करते हैं; कोड यह नहीं बदलेगा। फिर आप विलय करते हैं ... आप बदले गए कोड को देखेंगे।




git fetchरिमोट शाखाएं पुनर्प्राप्त करें ताकि आप वर्तमान शाखा के साथ git diffया git mergeउन्हें कर सकें। git pullवर्तमान शाखा द्वारा ट्रैक किए गए रिमोट ब्रैच पर लाएगा और फिर परिणाम मर्ज करेगा। आप यह git fetchदेखने के लिए उपयोग कर सकते हैं कि रिमोट ब्रांच के लिए कोई भी अपडेट आपके स्थानीय शाखा के साथ विलय कर रहा है या नहीं।




के बीच एकमात्र अंतर git pullऔर git fetchयह है कि:

git pull एक दूरस्थ शाखा से खींचता है और इसे विलय करता है।

git fetch केवल रिमोट शाखा से लाता है लेकिन यह विलय नहीं करता है

यानी गिट पुल = गिट fetch + गिट विलय ...




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

इसे समझने के लिए, आपको सबसे पहले यह समझने की आवश्यकता है कि आपका स्थानीय गिट न केवल आपके स्थानीय भंडार को बनाए रखता है, बल्कि यह रिमोट रिपोजिटरी की स्थानीय प्रति भी बनाए रखता है।

git fetchरिमोट रिपोजिटरी की अपनी स्थानीय प्रति अद्यतित लाता है। उदाहरण के लिए, यदि आपका रिमोट रिपोजिटरी गिटहब है - तो आप रिमोट रिपॉजिटरी में रिमोट रिपोजिटरी की अपनी स्थानीय प्रतिलिपि में किए गए किसी भी बदलाव को प्राप्त करना चाह सकते हैं। यह आपको तुलना या विलय जैसे संचालन करने की अनुमति देगा।

git pullदूसरी तरफ रिमोट रिपोजिटरी में बदलावों को नीचे लाएगा जहां आप अपना कोड रखते हैं। आम तौर पर, रिमोट रिपोजिटरी की स्थानीय प्रतिलिपि को अद्यतित करने के लिए पहला git pullऐसा करेगा git fetch, और फिर यह आपके कोड संग्रह और संभवतः आपकी कार्यशील प्रति में परिवर्तनों को विलय करेगा।




गिट पुल == (गिट fetch + गिट मर्ज)

गिट फ़ेच स्थानीय शाखाओं में नहीं बदलता है।

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




असल में गिट आपके अपने कोड और रिमोट रिपोजिटरी की एक प्रति रखता है।

आदेश git fetchरिमोट रिपोजिटरी से डेटा प्राप्त करके आपकी स्थानीय प्रतिलिपि को अद्यतित करता है। कारण हमें इसकी आवश्यकता है क्योंकि किसी और ने कोड में कुछ बदलाव किए हैं और आप स्वयं को अद्यतन रखना चाहते हैं।

आदेश git pullरिमोट रिपोजिटरी में परिवर्तन लाता है जहां आप अपना कोड रखते हैं। आम तौर पर, git pullयह रिमोट रिपोजिटरी की स्थानीय प्रतिलिपि को अद्यतित करने के लिए पहले 'गिट फ़ेच' कर कर करता है, और फिर यह आपके स्वयं के कोड भंडार और संभवतः आपकी कार्यशील प्रति में परिवर्तन विलय करता है।




शुरुआती के लिए एक साधारण ग्राफिकल प्रतिनिधित्व,

यहाँ,

git pull  

भंडार से कोड लाएगा और आपके स्थानीय के साथ पुन: प्रयास करेगा ... गिट खींचने में नए कामों की संभावना है।

लेकीन मे ,

गिट fetch

भंडार से कोड लाएगा और हमें इसका उपयोग करके इसे मैन्युअल रूप से रीबेज करने की आवश्यकता है git rebase

उदाहरण: मैं सर्वर मास्टर से लाने और अपने स्थानीय मास्टर में इसे पुन: प्राप्त करने जा रहा हूं।

1) गिट पुल (रीबेस स्वचालित रूप से किया जाएगा):

git pull origin master

यहां मूल है आपका रिमोट रेपो मास्टर आपकी शाखा है

2) गिट fetch (मैन्युअल रूप से rebase की जरूरत है):

git fetch origin master

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

git rebase origin/master

यह कोड को स्थानीय में रीबेस कर देगा। इससे पहले कि आप सही शाखा में हैं सुनिश्चित करें।




Related