7176

मैं स्थानीय फ़ाइलों को ओवरराइट करने के लिए कैसे बाध्य करूं git pull?

परिदृश्य निम्न है:

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

यह मुझे मिलने वाली त्रुटि है:

त्रुटि: अनट्रैकेड वर्किंग ट्री फ़ाइल 'पब्लिक / इमेजेस / आइकन.गिफ' को मर्ज द्वारा अधिलेखित कर दिया जाएगा

मैं उन्हें कैसे अधिलेखित करने के लिए बाध्य करूं? व्यक्ति एक डिजाइनर है - आमतौर पर, मैं सभी संघर्षों को हाथ से हल करता हूं, इसलिए सर्वर का सबसे हाल का संस्करण है जिसे उन्हें बस अपने कंप्यूटर पर अपडेट करने की आवश्यकता है।

— जकुब ट्रोसज़ोक
स्रोत

17

इसे पढ़ने वाला कोई भी व्यक्ति सोचता है कि वे फाइलें खो सकते हैं, मैं इस स्थिति में हूं और पाया गया है कि सब्लिम टेक्स्ट के बफर ने मुझे बचा लिया है - अगर मैं किसी चीज पर काम कर रहा हूं, तो गलती से इस तरह की समस्या को हल करने की कोशिश करके या उपयोग करके सबकुछ हटा दें इस सवाल पर एक जवाब है और फाइल को सबलेम में खोल दिया है (जो कि एक अच्छा मौका है) तब फाइलें अभी भी वहां मौजूद होंगी, या तो बस वहाँ है, या फिर पूर्ववत इतिहास में

— टोनी लेईंग

61

git reset --hard origin/branch_to_overwrite

— एंड्रयू एटकिन्सन

1

मूल रूप से, केवल प्रारंभिक चेकआउट-बी के बाद विकास से एक खिंचाव है। अपना काम करो, फिर वापस अंदर

— आओ

1

संक्षिप्त उत्तर: शाखा को हटाएं और फिर से बनाएं। 1. शाखा हटाएं: git branch <branch> -D2. संघर्ष से पहले एक कमेट पर रीसेट करें: git reset <commit> --hard3. शाखा फिर से बनाएं: git branch <branch>4. सर्वर पर नज़र रखना: git --set-upstream-to=origin/<branch> <branch> 5. Pull: git pull`

— Nino Filiu

1

सभी सीआरएलएफ को एलएफ एंडिंग में बदलने के लिए, (स्वच्छ शुरू)git config core.autocrlf false; git ls-files -z | xargs -0 rm; git checkout .

— क्लो

10025

महत्वपूर्ण: यदि आपके पास कोई स्थानीय परिवर्तन हैं, तो वे खो जाएंगे। `--hard`विकल्प के साथ या बिना , कोई भी स्थानीय कमिट जो पुश नहीं किया गया है वह खो जाएगा। ^[*]

यदि आपके पास कोई भी फाइल है जिसे Git (जैसे अपलोड की गई उपयोगकर्ता सामग्री) द्वारा ट्रैक नहीं किया गया है, तो ये फाइलें प्रभावित नहीं होंगी।

मुझे लगता है कि यह सही तरीका है:

git fetch --all

फिर, आपके पास दो विकल्प हैं:

git reset --hard origin/master

या यदि आप किसी अन्य शाखा में हैं:

git reset --hard origin/<branch_name>

स्पष्टीकरण:

git fetch किसी भी चीज़ को मर्ज या रीबेस करने के लिए नवीनतम को रिमोट से डाउनलोड करें।

फिर git resetमास्टर शाखा को रीसेट करता है कि आपने अभी क्या प्राप्त किया है। --hardविकल्प में फ़ाइलों को मैच के लिए अपने काम के पेड़ में सभी फ़ाइलों में परिवर्तनorigin/master

वर्तमान स्थानीय आवागमन बनाए रखें

^[*] : यह ध्यान देने योग्य है कि masterरीसेट करने से पहले एक शाखा बनाकर वर्तमान स्थानीय आवागमन को बनाए रखना संभव है :

git checkout master
git branch new-branch-to-save-current-commits
git fetch --all
git reset --hard origin/master

इसके बाद पुराने सभी कमिटमेंट को रखा जाएगा new-branch-to-save-current-commits।

असम्बद्ध परिवर्तन

अनपेक्षित परिवर्तन, हालांकि (यहां तक कि मंचन) खो जाएगा। सुनिश्चित करें कि आप जो कुछ भी करना चाहते हैं, उसे स्टैश और कमिट करें। उसके लिए आप निम्नलिखित चला सकते हैं:

git stash

और फिर इन अनकहे परिवर्तनों को फिर से लागू करने के लिए:

git stash pop

— शाही सेना
स्रोत

14

ध्यान रहे! यदि आपके पास स्थानीय अप्रकाशित कमिट हैं तो यह उन्हें आपकी शाखा से हटा देगा! यह समाधान अप्रकाशित फ़ाइलों को रिपॉजिटरी अक्षुण्ण में नहीं रखता है, लेकिन बाकी सब को अधिलेखित कर देता है।

— मैथिज पी

479

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

— रेड

14

यदि आप एक रेपो से खींच रहे हैं, जिसका रिमोट ब्रांच नाम "मास्टर" से अलग है, तो उपयोग करेंgit reset --hard origin/branch-name

— Nerrve

96

इस प्रश्न और उत्तर तक उत्थान की मात्रा को देखते हुए, मुझे लगता है कि git को एक कमांड को शामिल करना चाहिए जैसेgit pull -f

— सोफीवोरस

7

git reflogकमिट जो हार्ड रीसेट से पहले पुश नहीं किए गए थे , का उपयोग करके पुनर्प्राप्त किया जा सकता है , जो सभी कमिट्स को सूचीबद्ध करता है, वह भी बिना आधार के। जब तक आप अपनी स्थानीय कॉपी का उपयोग करके सफाई नहीं करते हैं git gc, तब तक सब खो जाता है

— कोएन।

933

इसे इस्तेमाल करे:

git reset --hard HEAD
git pull

यह वही करना चाहिए जो आप चाहते हैं।

— ट्रैविस रीडर
स्रोत

16

मैंने यह किया है और कुछ स्थानीय फाइलें जो अब रेपो में नहीं थीं, डिस्क पर छोड़ दी गईं।

— पायोत्र ओविसक

26

मुझे नहीं लगता कि यह सही है। उपरोक्त एक मर्ज का प्रदर्शन करेगा, न कि अधिलेखित किया जाएगा जो प्रश्न में अनुरोध किया गया था: "उन्हें कैसे अधिलेखित करने के लिए मजबूर करने के लिए?" मेरे पास उत्तर नहीं है, मैं वर्तमान में इसकी तलाश कर रहा हूं .. फिलहाल मैं उस कोड के साथ शाखा पर स्विच करता हूं जिसे मैं "git checkout BranchWithCodeToKeep" रखना चाहता हूं, फिर "git Branch -D BranchCoOverwrite" करें और फिर अंत में करें। "git checkout -b BranchToOverwrite"। अब आपके पास BranchWithCodeToKeep से शाखा में सटीक शाखा होगी, बिना किसी मर्ज को करने के लिए BranchToOverwrite पर शाखा।

— felbus

252

'git पुल' का उपयोग कर विलय करने के बजाय, git fetch की कोशिश करें - और उसके बाद 'git reset --hard origin / master'

— लॉयड मूर

5

हां, @lloydmoore समाधान ने मेरे लिए काम किया। केवल एक टिप्पणी के बजाय एक उत्तर होने के साथ कर सकता है।

— मैक्स विलियम्स

2

यह वर्तमान परिवर्तनों को वापस खींची गई अंतिम शाखा कमिट पर रीसेट कर देगा। फिर गिट पुल नवीनतम शाखा से परिवर्तनों को मर्ज करता है। यह वही है जो मैं इसे करना चाहता था .. धन्यवाद!

— कोड 17:14

459

चेतावनी: git cleanआपकी सभी अनट्रैक की गई फ़ाइलों / निर्देशिकाओं को हटा देता है और पूर्ववत नहीं किया जा सकता है।

कभी-कभी सिर्फ clean -fमदद नहीं करता है। यदि आपके पास निर्दिष्‍ट कार्य हैं, तो -d विकल्प की भी जरूरत है:

# WARNING: this can't be undone!

git reset --hard HEAD
git clean -f -d
git pull

चेतावनी: git cleanआपकी सभी अनट्रैक की गई फ़ाइलों / निर्देशिकाओं को हटा देता है और पूर्ववत नहीं किया जा सकता है।

पहले उपयोग करें -n( --dry-run) ध्वज पर विचार करें । यह आपको दिखाएगा कि वास्तव में कुछ भी हटाने के बिना क्या हटा दिया जाएगा:

git clean -n -f -d

उदाहरण आउटपुट:

Would remove untracked-file-1.txt
Would remove untracked-file-2.txt
Would remove untracked/folder
...

— डेविड एवसजनिस्विली
स्रोत

33

बहुत बढ़िया ... मेरे घर की निर्देशिका में मेरे डॉटफाइल्स रेपो के खिलाफ यह दौड़ा। अच्छा है कि मैं वास्तव में वहाँ कुछ भी महत्वपूर्ण नहीं है ...

— लॉरी

7

मुझे लगता है कि परिदृश्य विवरण यह स्पष्ट करता है कि वह वास्तव में सामग्री को फेंकना नहीं चाहता है। बल्कि वह जो चाहता है वह फाइलों को ओवरराइट करने पर गिट बॉकिंग को रोकना है। @ गौरी, तुम्हारे साथ ऐसा नहीं होना चाहिए था। दुर्भाग्य से लोगों को लगता है कि परिदृश्य वर्णन का सार गलत है - मेरा सुझाव देखें।

— हेजहोग

19

अंतिम रूप से । जब सब कुछ साफ करने के लिए स्वच्छ विफल हो जाता है तो git क्लीन -f -d काम में आता है।

— EarthmeLon

7

@crizCraig जब तक उन्हें जोड़ा नहीं जाता.gitignore

— ब्लीडिंग फिंगर्स

5

@earthmeLon, इसके लिए आप चाहें git clean -dfx। -xध्यान न दी .gitignore। आमतौर पर आपके निर्मित उत्पाद .gitignore में होंगे।

— पॉल ड्रेपर

384

हेजल की तरह मुझे लगता है कि उत्तर भयानक हैं। हालांकि हेजल का जवाब बेहतर हो सकता है, मुझे नहीं लगता कि यह उतना सुरुचिपूर्ण है जितना यह हो सकता है। जिस तरह से मुझे ऐसा करने के लिए मिला है वह एक परिभाषित रणनीति के साथ "लाने" और "मर्ज" करने के लिए है। जो इसे बनाना चाहिए ताकि आपके स्थानीय परिवर्तन तब तक संरक्षित रहें जब तक कि वे उन फ़ाइलों में से एक न हों जिनके साथ आप ओवरराइट करने की कोशिश कर रहे हैं।

पहले अपने बदलावों के लिए कमिट करें

 git add *
 git commit -a -m "local file server commit message"

फिर परिवर्तन लाएँ और यदि कोई विरोध हो तो उसे अधिलेखित कर दें

 git fetch origin master
 git merge -s recursive -X theirs origin/master

"-X" एक विकल्प नाम है, और "उनका" उस विकल्प का मूल्य है। यदि आप "अपने" परिवर्तन के बजाय "अपने" परिवर्तनों का उपयोग करना चुन रहे हैं, यदि कोई विरोध है।

— रिचर्ड कर्सी
स्रोत

56

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

— ह्यूज

5

डिट्टो - यह मेरे लिए एक बहुत बड़ा मर्ज (GitHub पुल अनुरोध) करते हुए काम किया, जहां मैं सिर्फ यह चाहता था कि मेरे पास जो कुछ था उसके ऊपर मैं इसे स्वीकार कर लूं। अच्छा उत्तर! मेरे मामले में अंतिम दो आदेश थे: 1) get fetch other-repo; 2)git merge -s recursive -X theirs other-repo/master

— quux00

2

यह रिपॉजिटरी फ़ाइलों के साथ किसी भी टकराव को अधिलेखित करेगा और आपके स्थानीय लोगों को नहीं, सही?

— नाथन एफ।

2

सबसे बढ़िया उत्तर। उच्चतम स्वीकृत उत्तर ने मुझे अपने मामले में अलग सिर पर छोड़ दिया। मैं वापस स्थानीय मास्टर शाखा में चला गया और भाग गयाgit merge -X theirs origin/master

— पीटर

2

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

— बॉब कर्न्स

279

करने के बजाय:

git fetch --all
git reset --hard origin/master

मैं निम्नलिखित करने की सलाह दूंगा:

git fetch origin master
git reset --hard origin/master

यदि आप मूल / मास्टर शाखा के लिए सही होने जा रहे हैं तो सभी रीमोट और शाखाओं को लाने की कोई आवश्यकता नहीं है?

— Johanneke
स्रोत

3

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

— निकोलस डी जय

5

हाँ, मेरा अधिकांश प्रतिनिधि यहाँ से आ रहा है :) यह सभी अनट्रैक की गई फ़ाइलों को भी हटा देगा। कुछ मैं भूल गया था और सिर्फ 2 दिन पहले याद दिलाया गया था ...

— जोहानेक

1

इस अन्य उत्तर पर टिप्पणियाँ देखें: stackoverflow.com/a/8888015/2151700

— जोहानेक

इसने मेरी अनट्रैक फ़ाइलों को नहीं हटाया; जो वास्तव में मैं क्या उम्मीद करूंगा। क्या कुछ लोगों के लिए इसका कारण हो सकता है और दूसरों के लिए नहीं?

— arichards

जीआईटी रीसेट द्वारा अनट्रैक की गई फाइलें प्रभावित नहीं होती हैं। आप चाहते हैं उन्हें भी निकाल दी है, तो ऐसा git add .पहले, इससे पहले किgit reset --hard

— Johanneke

131

ऐसा लगता है कि सबसे अच्छा तरीका पहले करना है:

git clean

सभी अनट्रैक की गई फ़ाइलों को हटाने के लिए और फिर सामान्य रूप से जारी रखें git pull...

— जकुब ट्रोसज़ोक
स्रोत

4

मैंने उसी मुद्दे को हल करने के लिए "गिट क्लीन" का उपयोग करने की कोशिश की, लेकिन इसका समाधान नहीं हुआ। git स्थिति कहती है, "आपकी शाखा और 'मूल / गुरु' ने विचलन किया है, # और क्रमशः 2 और 9 अलग-अलग वचन (प्रत्येक) हैं।" और गिट पुल आपके ऊपर जो कुछ है, उसके समान कुछ कहता है।

— दासता

43

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

— नील मैय्यूज

2

मुझे नहीं लगता कि यह सामान्य रूप से काम करता है। वहाँ एक रास्ता नहीं है करने के लिए मूल रूप से एक मजबूर क्लोन पुल के माध्यम से एक git क्लोन रिमोट?

— १

10

@ मैथिक:git fetch origin && git reset --hard origin/master

— एरोमास्टर

3

है git cleanसबसे अच्छा जवाब यहाँ? फ़ाइलों को हटाने की तरह लगता है जरूरी नहीं कि ओपी क्या चाहता है। उन्होंने 'स्थानीय फाइलों का एक अधिलेखित' नहीं हटाने के लिए कहा।

— जॉन एलेन

111

चेतावनी, ऐसा करने से आपकी फ़ाइलों को स्थायी रूप से हटा दिया जाएगा यदि आपके पास आपकी gitignore फ़ाइल में कोई निर्देशिका / * प्रविष्टियाँ हैं।

कुछ जवाब बहुत ही भयानक लग रहे हैं। डेविड अवाजनिस्विली के सुझाव का पालन करते हुए @Lauri के साथ क्या हुआ, इस अर्थ में भयानक।

बल्कि (git> v1.7.6):

git stash --include-untracked
git pull

बाद में आप स्टैश इतिहास को साफ कर सकते हैं।

मैन्युअल रूप से, एक-एक करके:

$ git stash list
stash@{0}: WIP on <branch>: ...
stash@{1}: WIP on <branch>: ...

$ git stash drop stash@{0}
$ git stash drop stash@{1}

बेरहमी से, एक बार में:

$ git stash clear

निश्चित रूप से यदि आप वापस वही जाना चाहते हैं जो आपने अटकाया था:

$ git stash list
...
$ git stash apply stash@{5}

— कांटेदार जंगली चूहा
स्रोत

2

नहीं, मुझे ऐसा नहीं लगता। स्ट्रैसिंग रास्ते से बाहर निकलने वाली फाइलों को हटा देता है। ऊपर भी चाल (स्टैशिंग) फाइलें चलती हैं जो गिट ट्रैक नहीं करती हैं। यह उन फ़ाइलों को रोकता है जिन्हें रिमोट में जोड़ा गया है, जो अभी तक आपकी मशीन तक नहीं खींची हैं - लेकिन जिसे आपने बनाया है (!) - नीचे खींचने के लिए। सभी बिना काम को नष्ट किए। आशा है कि समझ में आता है?

— हेजहोग

3

यदि आपके पास 1.7.6 नहीं है, तो आप --include-untrackedअस्थायी रूप से git addअपने पूरे रेपो को देखकर नकल कर सकते हैं , फिर तुरंत इसे रोक दें।

— 12'12

3

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

— गार्डियस

1

मेरे पास अन्य अनट्रेक्टेड फाइलें थीं - एक के अलावा मर्ज / पुल ओवरराइट करना चाहता था, इसलिए इस समाधान ने सबसे अच्छा काम किया। git stash applyमर्ज के अपवाद (सही तरीके से) के साथ मेरी सभी अनट्रैक की गई फ़ाइलों को वापस लाया जो पहले ही बनाई गई थीं: "पहले से मौजूद है, कोई चेकआउट नहीं।" पूरी तरह से काम किया।

— BigBlueHat

2

यह सबसे साफ उत्तर है, और इसे स्वीकार किया जाना चाहिए। कुछ टाइपिंग बचाने के लिए आप कम फार्म का उपयोग कर सकते हैं: git stash -u।

— ccpizza

93

स्थानीय परिवर्तनों को दूर करने के लिए आपको यह कमांड मददगार लग सकती है:

git checkout <your-branch> -f

और फिर एक सफाई करें (काम करने वाले पेड़ से फ़ाइलों को हटा दें):

git clean -f

यदि आप अनट्रैक की गई फ़ाइलों के अलावा अनट्रेक्ड निर्देशिकाओं को हटाना चाहते हैं:

git clean -fd

— विशाल
स्रोत

मुझे लगता है कि परिदृश्य विवरण यह स्पष्ट करता है कि वह वास्तव में सामग्री को फेंकना नहीं चाहता है। बल्कि वह जो चाहता है वह फाइलों को ओवरराइट करने पर गिट बॉकिंग को रोकना है। मेरा सुझाव देखें।

— हेजहोग 23

3

यद्यपि वह उत्तर सटीक रूप से वर्णन के लायक नहीं हो सकता है, फिर भी इसने मुझे गाड़ी वापसी के साथ गिट ट्विडलिंग की हताशा से बचाया (ऑटोक्रेट के साथ घटना झूठी)। जब git reset --hard HEAD आपको "नहीं" संशोधित फ़ाइलों के साथ नहीं छोड़ता है, तो ये "-f" झंडे काफी मददगार होते हैं। बहुत बहुत धन्यवाद।

— कालिंदिल

88

विलय के बजाय git pull, यह कोशिश करें:

git fetch --all

के बाद:

git reset --hard origin/master।

— लॉयड मूर
स्रोत

61

केवल एक चीज जो मेरे लिए काम करती थी:

git reset --hard HEAD~5

यह आपको पाँच कमिट्स और फिर वापस ले जाएगा

git pull

मैंने पाया कि जीट मर्ज को पूर्ववत करने के तरीके को देखकर ।

— क्रिस BIllante
स्रोत

यह अंततः मेरे लिए काम कर रहा था क्योंकि मैंने बल दिया था कि मैंने अपनी शाखा को मूल रेपो में धकेल दिया था और जब मेरा रिमोट रेपो पर खींचने की कोशिश कर रहा था, तब मर्ज संघर्ष हो रहा था ..

— jwfrench

नमस्ते, वास्तव में यह work aroundवास्तव में प्रभावी के लिए एक चाल है । क्योंकि कुछ संघर्ष सिर्फ कुछ कमिट्स में हो सकते हैं, फिर 5 कमिट्स को पुनः प्राप्त करने से यह सुनिश्चित हो जाएगा कि रिमोट कोड के साथ कोई विवाद नहीं है।

— होआंग ले

54

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

यहाँ सबसे साफ समाधान है जो हम उपयोग कर रहे हैं:

# Fetch the newest code
git fetch

# Delete all files which are being added, so there
# are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
    rm -f -- "$file"
done

# Checkout all files which were locally modified
for file in `git diff --name-status | awk '/^[CDMRTUX]/ {print $2}'`
do
    git checkout -- "$file"
done

# Finally pull all the changes
# (you could merge as well e.g. 'merge origin/master')
git pull

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

— स्ट्रिन्हिन्जा कस्टूडिक
स्रोत

"गिट मर्ज" के बजाय अंतिम पंक्ति के रूप में (जैसे आप अपने नोट में कहते हैं) के रूप में "गिट मर्ज मूल / मास्टर" का उपयोग करना तेज होगा क्योंकि आपने पहले ही गिट रेपो से किसी भी बदलाव को नीचे खींच लिया है।

— जोश

1

हाँ, git merge origin/masterनिश्चित रूप से तेज़ होगा और शायद सुरक्षित भी होगा। चूंकि अगर किसी ने इस स्क्रिप्ट की फ़ाइलों को हटाने के दौरान नए बदलावों को आगे बढ़ाया (जो कि होने की संभावना नहीं है, लेकिन संभव है), तो पूरा पुल विफल हो सकता है। एकमात्र कारण जो मैंने pullवहां रखा है, क्योंकि कोई व्यक्ति मास्टर शाखा पर काम नहीं कर रहा है, लेकिन कुछ अन्य शाखा और मैं चाहता था कि स्क्रिप्ट सार्वभौमिक हो।

— स्ट्रिन्हिन्जा कस्टूडिक

यदि आपके पास विकल्प फ़ाइलों जैसी स्थानीय रूप से बनाई गई फ़ाइलें हैं, तो उन्हें डालें .gitignore।

— सेबी

52

सबसे पहले, मानक तरीका आज़माएँ:

git reset HEAD --hard # To remove all not committed changes!
git clean -fd         # To remove all untracked (non-git) files and folders!

^{चेतावनी : ऊपर दिए गए आदेशों के परिणामस्वरूप डेटा / फ़ाइलें हानि हो सकती हैं, यदि आपने उन्हें प्रतिबद्ध नहीं किया है! यदि आप निश्चित नहीं हैं, तो अपने पूरे रिपॉजिटरी फ़ोल्डर का बैकअप पहले बनाएं।}

फिर इसे फिर से खींचें।

यदि उपरोक्त मदद नहीं करेगा और आप अपनी अनट्रैक की गई फ़ाइलों / निर्देशिकाओं के बारे में परवाह नहीं करते हैं (केवल पहले मामले में बैकअप लें), तो निम्न सरल चरणों का प्रयास करें:

cd your_git_repo  # where 'your_git_repo' is your git repository folder
rm -rfv *         # WARNING: only run inside your git repository!
git pull          # pull the sources again

यह सभी जीआईटी फाइलों को हटा देगा (डिस्क्म्पम .git/डायर, जहां आपके पास सभी कमिट हैं) और इसे फिर से खींचें।

git reset HEAD --hardकुछ मामलों में क्यों विफल हो सकता है?

में कस्टम नियम .gitattributes file

eol=lfनियम। Initattributes में नियम होने के कारण कुछ पाठ फ़ाइलों में CRLF लाइन-एंडिंग को LF में परिवर्तित करके कुछ फ़ाइल परिवर्तनों को संशोधित करने का कारण बन सकता है।

यदि ऐसा है, तो आपको इन CRLF / LF परिवर्तनों (उनकी समीक्षा करके git status) में बदलाव करना होगा , या कोशिश करनी चाहिए: git config core.autcrlf falseउन्हें अस्थायी रूप से अनदेखा करना।
फाइल सिस्टम की अक्षमता

जब आप फ़ाइल-सिस्टम का उपयोग कर रहे हैं जो अनुमति विशेषताओं का समर्थन नहीं करता है। उदाहरण में आप दो खजाने, पर लिनक्स / मैक एक (है ext3/ hfs+) और FAT32 पर एक और एक / NTFS आधारित फ़ाइल-प्रणाली।

जैसा कि आप नोटिस करते हैं, दो अलग-अलग प्रकार की फ़ाइल प्रणालियाँ हैं, इसलिए जो यूनिक्स अनुमतियों का समर्थन नहीं करता है वह मूल रूप से सिस्टम पर फ़ाइल अनुमतियों को रीसेट नहीं कर सकता है जो उस प्रकार की अनुमतियों का समर्थन नहीं करता है, इसलिए कोई फर्क नहीं पड़ता कि --hardआप कैसे प्रयास करते हैं, git हमेशा कुछ "परिवर्तनों" का पता लगाएं।

— kenorb
स्रोत

47

मुझे भी यही समस्या थी। किसी ने मुझे यह समाधान नहीं दिया, लेकिन इसने मेरे लिए काम किया।

मैंने इसे हल किया:

सभी फ़ाइलों को हटा दें। सिर्फ .gitडायरेक्टरी छोड़ दो ।
git reset --hard HEAD
git pull
git push

अब यह काम कर रहा है।

— जॉन जॉन पिचलर
स्रोत

1

मुझे भी। कभी-कभी केवल बहुत ही कठिन समाधान काम करता है, यह अक्सर होता है कि केवल रीसेट और स्वच्छ किसी भी तरह पर्याप्त नहीं हैं ...

— jdehaan

41

बक्शीश:

पिछले उत्तरों में खींच / लाने / मर्ज करने के संदर्भ में, मैं एक दिलचस्प और उत्पादक चाल साझा करना चाहूंगा,

`git pull --rebase`

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

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

"Git pull --rebase" में क्या विवरण मिलता है? ।

— सज्जाद हिसैन खान
स्रोत

3

संक्षेप में git pull -r:।

— केनोरब

29

मुझे भी ऐसी ही समस्या का समाधान करना पड़ा था। मुझे यह करना था:

git reset --hard HEAD
git clean -f
git pull

— रयान
स्रोत

6

git cleanसावधानी के साथ प्रयोग करें

— nategood

29

मैंने अन्य उत्तरों का सारांश दिया। आप git pullत्रुटियों के बिना निष्पादित कर सकते हैं:

git fetch --all
git reset --hard origin/master
git reset --hard HEAD
git clean -f -d
git pull

चेतावनी : यह स्क्रिप्ट बहुत शक्तिशाली है, जिससे आप अपने परिवर्तनों को खो सकते हैं।

— रॉबर्ट मून
स्रोत

2

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

— स्टाइल

3

मुझे संदेह है कि तीसरी पंक्ति git reset --hard HEADनिरर्थक हो सकती है; मेरा स्थानीय मैन पेज (2.6.3) कहता है कि resetदूसरी पंक्ति में git reset --hard origin/master "सभी रूपों में HEAD के लिए चूक"।

— 19/16

2

@arichards मुझे लगता है कि आपका संदेह सही है लेकिन अगर दूसरी लाइन काम नहीं करेगी (किसी भी कारण से) तीसरी लाइन रीसेट करने के लिए अच्छी तरह से काम करती है। इस समाधान को अनुकूलित करने की आवश्यकता नहीं है। मैंने अभी अन्य उत्तरों का सारांश दिया है। बस इतना ही। आपकी टिप्पणी के लिये धन्यवाद। :)

— राबर्ट मून

28

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

इस बात को ध्यान में रखते हुए, मैंने कस्टूडिक की स्क्रिप्ट को अपडेट किया। मैंने एक टाइपो (मूल में एक लापता) भी तय किया।

#/bin/sh

# Fetch the newest code
git fetch

# Delete all files which are being added,
# so there are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
    echo "Deleting untracked file $file..."
    rm -vf "$file"
done

# Checkout all files which have been locally modified
for file in `git diff HEAD..origin/master --name-status | awk '/^M/ {print $2}'`
do
    echo "Checking out modified file $file..."
    git checkout $file
done

# Finally merge all the changes (you could use merge here as well)
git pull

— रॉल्फ कैसर
स्रोत

"गिट मर्ज" के बजाय अंतिम पंक्ति के रूप में (जैसे आप अपने नोट में कहते हैं) के रूप में "गिट मर्ज मूल / मास्टर" का उपयोग करना तेज होगा क्योंकि आपने पहले ही गिट रेपो से किसी भी बदलाव को नीचे खींच लिया है।

— जोश

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

— स्ट्रिन्हिन्जा कस्टुडिक

24

मेरा मानना है कि संघर्ष के दो संभावित कारण हैं, जिन्हें अलग से हल किया जाना चाहिए, और जहां तक मैं बता सकता हूं कि उपरोक्त उत्तर सौदों में से कोई भी नहीं है:

स्थानीय फ़ाइलें जो अनट्रैक की जाती हैं, उन्हें या तो मैन्युअल रूप से (सुरक्षित) या के रूप में अन्य उत्तरों में सुझाए गए हटाए जाने की आवश्यकता होती है git clean -f -d
स्थानीय शाखाएं जो दूरस्थ शाखा पर नहीं हैं, उन्हें भी हटाने की आवश्यकता है। IMO इसे प्राप्त करने का सबसे आसान तरीका है: git reset --hard origin/master(जिस भी शाखा में आप काम कर रहे हैं, उसके द्वारा 'मास्टर' को बदलें और git fetch originपहले भाग लें )

— tiho
स्रोत

22

एक आसान तरीका यह होगा:

git checkout --theirs /path/to/file.extension
git pull origin master

यह आपकी स्थानीय फ़ाइल को फ़ाइल पर फ़ाइल के साथ ओवरराइड करेगा

— अधिकतम 69
स्रोत

21

ऐसा लगता है कि यहां अधिकांश उत्तर masterशाखा पर केंद्रित हैं ; हालांकि, ऐसे समय होते हैं जब मैं एक ही फीचर शाखा पर दो अलग-अलग स्थानों पर काम कर रहा होता हूं और मैं चाहता हूं कि एक में एक रिबास हो जो दूसरे में परिलक्षित होता है बिना हुप्स के बहुत से कूदते हुए।

आरएनए के उत्तर के संयोजन और एक समान प्रश्न के उत्तर के आधार पर , मैं इसके साथ आया हूं जो शानदार काम करता है:

git fetch
git reset --hard @{u}

इसे एक शाखा से चलाएँ और यह केवल आपकी स्थानीय शाखा को अपस्ट्रीम संस्करण में रीसेट करेगा।

यह अच्छी तरह से एक उर्फ ( git forcepull) में डाला जा सकता है :

git config alias.forcepull "!git fetch ; git reset --hard @{u}"

या, आपकी .gitconfigफ़ाइल में:

[alias]
  forcepull = "!git fetch ; git reset --hard @{u}"

का आनंद लें!

— JacobEvelyn
स्रोत

यह उत्तर भी अच्छा है क्योंकि यह इस बात पर ध्यान दिए बिना काम करता है कि आप किस शाखा में हैं!

— पत्ती

19

मुझे भी यही समस्या थी और किसी कारण से, यहाँ तक git clean -f -dकि यह भी नहीं करता था। किसी कारण के लिए, यदि आपकी फ़ाइल Git द्वारा नजरअंदाज कर दिया है (एक .gitignore प्रविष्टि के माध्यम से, मुझे लगता है), यह अभी भी एक बाद के साथ इस ओवरराइट करने के बारे परेशान: यहाँ क्यों है पुल , लेकिन एक स्वच्छ उसे निकाल नहीं होगा, जब तक आप जोड़ना -x।

— Tierlieb
स्रोत

19

मैं एक बहुत आसान और कम दर्दनाक विधि के बारे में जानता हूं:

$ git branch -m [branch_to_force_pull] tmp
$ git fetch
$ git checkout [branch_to_force_pull]
$ git branch -D tmp

बस!

— ddmytrenko
स्रोत

18

मैंने इसे स्वयं हल किया:

git checkout -b tmp # "tmp" or pick a better name for your local changes branch
git add -A
git commit -m 'tmp'
git pull
git checkout master # Or whatever branch you were on originally
git pull
git diff tmp

जहां अंतिम आदेश आपके स्थानीय परिवर्तनों के बारे में बताता है। "Tmp" शाखा को तब तक संशोधित करते रहें जब तक कि यह स्वीकार्य न हो जाए और फिर इसके साथ मास्टर पर वापस आ जाएँ:

git checkout master && git merge tmp

अगली बार, आप संभवतः "गिट स्टैश ब्रांच" को देखकर इसे साफ-सुथरे तरीके से संभाल सकते हैं, हालांकि स्टैश से आपको पहले कुछ प्रयासों में परेशानी होने की संभावना है, इसलिए पहले एक गैर-महत्वपूर्ण प्रोजेक्ट पर प्रयोग करें ...

— साइमन बी।
स्रोत

17

मैं एक अजीब स्थिति है कि न तो है git cleanया git resetकाम करता है। मुझे git indexहर अनट्रैक फ़ाइल पर निम्न स्क्रिप्ट का उपयोग करके परस्पर विरोधी फ़ाइल को हटाना होगा :

git rm [file]

फिर मैं बस ठीक खींचने में सक्षम हूं।

— चेन झांग
स्रोत

16

git fetch --all && git reset --hard origin/master && git pull

— Suge
स्रोत

14

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

निम्न संस्करण आपके स्थानीय परिवर्तनों को एक अस्थायी शाखा ( tmp) में भेजता है, मूल शाखा की जाँच करता है (जो मैं मान रहा हूँ master) और अद्यतनों का विलय करता है। आप ऐसा कर सकते हैं stash, लेकिन मैंने पाया है कि आमतौर पर शाखा / मर्ज दृष्टिकोण का उपयोग करना आसान होता है।

git checkout -b tmp
git add *; git commit -am "my temporary files"
git checkout master

git fetch origin master
git merge -s recursive -X theirs origin master

जहां हम मानते हैं कि अन्य भंडार है origin master।

— Snowcrash
स्रोत

13

ये चार आज्ञाएँ मेरे लिए काम करती हैं।

git reset --hard HEAD
git checkout origin/master
git branch -D master
git checkout -b master

इन आदेशों को निष्पादित करने के बाद जाँच / खींचने के लिए

git pull origin master

मैंने बहुत कोशिश की लेकिन आखिरकार इन आदेशों के साथ सफलता मिली।

— विनेश चंद्रा
स्रोत

2

"गिट शाखा -D मास्टर" शाखा को हटाएं। इसलिए इसके साथ सावधान रहें। मैं "git चेकआउट मूल / मास्टर -b <नई शाखा नाम>" का उपयोग करना पसंद करता हूं, जो एक नए नाम के साथ एक नई शाखा बनाता है और आपको 3,4 लाइनों की आवश्यकता होती है। साथ ही "git clean -f" का उपयोग करने की भी सिफारिश की गई है।

— चांद प्रियांकरा

13

बस करो

git fetch origin branchname
git checkout -f origin/branchname // This will overwrite ONLY new included files
git checkout branchname
git merge origin/branchname

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

— user2696128
स्रोत

12

सूचकांक और सिर को origin/masterरीसेट करें, लेकिन काम करने वाले पेड़ को रीसेट न करें:

git reset origin/master

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

— जेसन सेब्रिंग

12

आवश्यकताएँ:

स्थानीय परिवर्तनों को ट्रैक करें, इसलिए यहां कोई भी उन्हें खोता नहीं है।
स्थानीय रिपॉजिटरी का मिलान दूरस्थ मूल भंडार से करें।

समाधान:

स्थानीय परिवर्तनों को रोकें ।
लायें एक साथ साफ की फ़ाइलें और निर्देशिकाओं अनदेखी .gitignore और हार्ड रीसेट करने के लिए मूल ।
```
git stash --include-untracked
git fetch --all
git clean -fdx
git reset --hard origin/master
```

— vezenkov
स्रोत