git - मैं स्थानीय फाइलों को ओवरराइट करने के लिए "गिट पुल" को कैसे मजबूर करूं?




version-control overwrite git-pull git-fetch (25)

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

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

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

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

error: Untracked working tree file 'public/images/icon.gif' would be overwritten by merge

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


Answers

मुझे एक बहुत ही आसान और कम दर्दनाक विधि पता है:

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

बस!


आवश्यकताएँ:

  1. स्थानीय परिवर्तनों को ट्रैक करें ताकि यहां कोई भी उन्हें खो देता न हो।
  2. स्थानीय भंडार को रिमोट मूल भंडार से मेल करें।

उपाय:

  1. स्थानीय परिवर्तनों को छीनें
  2. लायें एक साथ साफ की फ़ाइलें और निर्देशिकाओं अनदेखी .gitignore और हार्ड रीसेट करने के लिए मूल

    git stash --include-untracked
    git fetch --all
    git clean -fdx
    git reset --hard origin/master
    

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


ऐसा लगता है कि यहां अधिकांश उत्तरों 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}"

का आनंद लें!


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

  • अनचाहे स्थानीय फ़ाइलों को हटाया जाना चाहिए, या तो मैन्युअल रूप से (सुरक्षित) या अन्य उत्तरों में सुझाए गए अनुसार, git clean -f -d

  • रिमोट शाखा पर नहीं होने वाले स्थानीय कामों को भी हटाया जाना चाहिए। आईएमओ इसे प्राप्त करने का सबसे आसान तरीका है: git reset --hard origin/master (आप जिस भी शाखा पर काम कर रहे हैं, उसके द्वारा 'मास्टर' को प्रतिस्थापित करें, और पहले git fetch origin चलाएं)


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

git reset --hard HEAD
git pull

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


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

git checkout <your-branch> -f

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

git clean -f

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

git clean -fd

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

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

# 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
  • पहला आदेश नवीनतम डेटा प्राप्त करता है।

  • दूसरा कमांड जांचता है कि क्या ऐसी कोई भी फाइल है जो भंडार में जोड़ दी जा रही है और स्थानीय भंडार से उन अनचाहे फ़ाइलों को हटा देती है जो विवाद पैदा कर सकती हैं।

  • तीसरा आदेश उन सभी फ़ाइलों को चेक-आउट करता है जिन्हें स्थानीय रूप से संशोधित किया गया था।

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


बस करो

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

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


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

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

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

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

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


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

git rm [file]

तो मैं बस ठीक खींचने में सक्षम हूँ।


बोनस:

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

git pull --rebase

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

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

"गिट पुल --rebase" क्या करता है में विवरण प्राप्त करें?


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

निम्नलिखित संस्करण आपके स्थानीय परिवर्तनों को अस्थायी शाखा ( 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



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

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

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


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

git clean

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


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

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

  1. सभी फाइलों को हटा रहा है। बस .git निर्देशिका छोड़ दें।
  2. git reset --hard HEAD
  3. git pull
  4. git push

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


मैंने सभी उत्तरों के माध्यम से पढ़ा लेकिन मैं ऐसा करने के लिए एक ही कमांड की तलाश में था। मैंने जो किया था यह रहा। .Gitconfig में एक गिट उपनाम जोड़ा गया

[alias]
      fp = "!f(){ git fetch ${1} ${2} && git reset --hard ${1}/${2};};f"

के रूप में अपना आदेश चलाएं

git fp origin master

के बराबर

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

ये चार आदेश मेरे लिए काम करते हैं।

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

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

git pull origin master

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


सबसे पहले, मानक तरीके से प्रयास करें:

git reset HEAD --hard # Remove all not committed changes

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

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

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

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

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

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

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

  2. फाइल सिस्टम असंगतता

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

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


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

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

#/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

करने के बजाय:

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

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

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

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


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

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

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


यह वर्तमान निर्देशिका के लिए मौजूदा इंडेक्स को जांचता है, वर्तमान निर्देशिका से फ़ाइलों में सभी परिवर्तनों को नीचे फेंक देता है।

git checkout .

या यह इंडेक्स से सभी फाइलों को जांचता है, काम कर रहे पेड़ फ़ाइलों को ओवरराइट करता है।

git checkout-index -a -f




git version-control overwrite git-pull git-fetch