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

यहाँ,

git pull  

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

लेकीन मे ,

गिट fetch

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

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

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

git pull origin master

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

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

git fetch origin master

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

git rebase origin/master

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

git pull = git fetch + git merge 

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

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

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

git-pull - Fetch from and merge with another repository or a local branch
SYNOPSIS

git pull   …
DESCRIPTION

Runs git-fetch with the given parameters, and calls git-merge to merge the 
retrieved head(s) into the current branch. With --rebase, calls git-rebase 
instead of git-merge.

Note that you can use . (current directory) as the <repository> to pull 
from the local repository — this is useful when merging local branches 
into the current branch.

Also note that options meant for git-pull itself and underlying git-merge 
must be given before the options meant for git-fetch.

अगर आप इतिहास को विलय करना चाहते हैं तो आप खींचेंगे, अगर आप सिर्फ 'कोडेज़ चाहते हैं' तो आप कुछ लोग यहां कुछ लेख टैग कर रहे हैं।

यहां ओलिवर स्टील की छवि है कि यह सब कैसे एक साथ फिट बैठता है :

यदि पर्याप्त रुचि है, तो मुझे लगता है कि मैं git clone और git merge जोड़ने के लिए छवि को अपडेट कर सकता हूं ...

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

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

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

तो अंतर होगा:

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

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

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

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

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

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

1. स्थानीय रिपो के अंदर इस रिमोट शाखा की प्रतिलिपि बनाने के लिए रिमोट शाखा से नई प्रतिबद्धताओं की प्रतिलिपि बनाना।

   (रेपो ऑपरेशन के लिए रेपो) [email protected] >> remote/origin/[email protected]

2. स्थानीय शाखा में नए कामों को एकीकृत करना

   (अंदर-रेपो ऑपरेशन) remote/origin/[email protected] >> [email protected]

चरण 2 करने के दो तरीके हैं। आप कर सकते हैं:

1. पिछले आम पूर्वजों के बाद कांटा स्थानीय शाखा और स्थानीय कामकाज के लिए अनूठे नए कामों को जोड़ते हैं, जो विलय को बंद करके, फोर्क बंद करके अंतिम रूप दिया जाता है।
2. पिछले आम पूर्वजों के बाद नई प्रतिबद्धता डालें और फिर से स्थानीय भंडार के लिए अद्वितीय काम करता है।

में gitशब्दावली, चरण 1 है git fetch, चरण 2 है git mergeयाgit rebase

git pullहै git fetchऔरgit merge

बोनस:

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

git pull --rebase

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

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

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

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

git fetch
git diff ...origin

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

गिट fetch

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

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

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

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

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

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

गिट खींचो

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

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

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

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

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

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

1

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

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

जीआईटी फ़ेच और जीआईटी पुल के बीच का अंतर निम्नलिखित परिदृश्य के साथ समझाया जा सकता है: (ध्यान रखें कि चित्र शब्दों से ज़ोर से बोलते हैं !, मैंने चित्रमय प्रतिनिधित्व प्रदान किया है)

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

तो, प्रारंभिक अवस्था दो शाखाओं के लिए जब आप अपने स्थानीय भंडार पर मुख्य परियोजना विभाजित है- तरह होगा ( A, Bऔर Cमॉड्यूल पहले से ही इस परियोजना के पूरा कर रहे हैं)

अब, आपने नए मॉड्यूल (मान लीजिए D) पर काम करना शुरू कर दिया है और जब आपने Dमॉड्यूल पूरा कर लिया है तो आप इसे मुख्य शाखा में धक्का देना चाहते हैं, लेकिन इस बीच क्या होता है कि आपके साथियों में से एक ने नया मॉड्यूल विकसित किया है E, Fऔर संशोधित किया है C।
तो अब क्या हुआ है कि आपके स्थानीय भंडार में परियोजना की मूल प्रगति के पीछे कमी है और इस प्रकार मुख्य शाखा में आपके परिवर्तनों को धक्का देकर संघर्ष हो सकता है और आपके मॉड्यूल Dको खराब होने का कारण बन सकता है ।

इस तरह के मुद्दों से बचने के लिए और परियोजना की मूल प्रगति के साथ समानांतर काम करने के लिए उनके दो तरीके हैं:

1. गिट फ़ेच- यह मूल / मुख्य शाखा प्रोजेक्ट में किए गए सभी परिवर्तनों को डाउनलोड करेगा जो आपकी स्थानीय शाखा में मौजूद नहीं हैं। और आपके रिपोजिटरी या शाखा में किए गए परिवर्तनों को लागू करने के लिए गिट मर्ज कमांड की प्रतीक्षा करेगा।

तो अब आप इसे अपने भंडार में विलय करने से पहले फ़ाइलों की सावधानीपूर्वक निगरानी कर सकते हैं। और संशोधित Dहोने के कारण यदि आप आवश्यक हो तो भी संशोधित कर सकते हैं C।

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

स्पष्ट और सरल होने की कोशिश कर रहा है।

Git पुल आदेश वास्तव में एक है shortcutके लिए Git लाने के बाद Git मर्ज या Git rebase अपने कॉन्फ़िगरेशन के आधार पर आदेश। आप अपने गिट भंडार को कॉन्फ़िगर कर सकते हैं ताकि गिट पुल एक रिटर्न के बाद एक fetch हो।

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

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

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

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

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

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

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

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

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

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

सबसे सरल शब्दों में, git pull एक git merge करता है जिसके बाद git merge ।

आप रिमोट refs/remotes/<remote>/ तहत अपनी रिमोट-ट्रैकिंग शाखाओं को अपडेट करने के लिए किसी भी समय git fetch कर सकते हैं।

यह ऑपरेशन कभी भी आपकी अपनी स्थानीय शाखाओं को refs/heads तहत कभी नहीं बदलता है, और आपकी कार्यशील प्रति को बदले बिना करना सुरक्षित है। मैंने पृष्ठभूमि में क्रॉन नौकरी में समय-समय पर git fetch चलाने वाले लोगों के बारे में भी सुना है (हालांकि मैं ऐसा करने की अनुशंसा नहीं करता)।

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

गिट दस्तावेज: गिट पुल

कभी-कभी एक दृश्य प्रतिनिधित्व मदद करता है।

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

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

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

संक्षिप्त

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

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

                                         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.

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

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

SourceTree (GitHub के लिए जीयूआई) पर, आप प्रतिबद्धता पर राइट-क्लिक कर सकते हैं और 'रिवर्स कमिट' कर सकते हैं। यह आपके परिवर्तनों को पूर्ववत करना चाहिए।

टर्मिनल पर:

आप वैकल्पिक रूप से उपयोग कर सकते हैं:

git revert

या:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.