1 प्रतिबद्ध द्वारा स्थानीय और दूरस्थ गिट रिपॉजिटरी को वापस लाना

Question

मैंने इस विषय पर इसी तरह की पोस्ट पढ़ी हैं, और मेरे जीवन के लिए यह पता नहीं लगा सकता कि यह कैसे ठीक से करना है।

मैंने लगभग 1000 फ़ाइलों की जाँच की जो मुझे नहीं चाहिए, और मुझे 1by1 से गुजरना नहीं पड़ेगा और उन सभी को रेपो से निकालना होगा।

• मेरी एक सुदूर masterशाखा है।
• मेरे पास स्थानीय masterशाखा है।

वे दोनों एक ही संशोधन पर हैं।

मैं अपने रिमोट को 1 कमिट द्वारा रोलबैक करना चाहता हूं।

कहो पर मेरा इतिहास masterहै A--B--C--D--E।
मैं अपने लोकल को रोलबैक करना चाहता हूं D।
फिर इसे रिमोट पर पुश करें ताकि मेरा करंट हैश रिमोट और लोकल दोनों तरह से हो जाए।

मैं यह कर रहा हूँ मुद्दों।
मैं Git Tower का उपयोग कर रहा हूं, लेकिन कमांड लाइन के साथ सहज हूं। कोई मदद?

अद्यतन: नीचे महान टिप्पणियाँ। रीसेट का उपयोग करना आंशिक रूप से हतोत्साहित करता है खासकर यदि रिपॉजिटरी को अन्य उपयोगकर्ताओं के साथ साझा किया जाता है। हार्ड रीसेट का उपयोग किए बिना पिछली प्रतिबद्ध परिवर्तनों को पूर्ववत करने का सबसे अच्छा तरीका क्या है ? क्या उधर रास्ता है?

Comments

मैंने अपना उत्तर "हार्ड रीसेट का उपयोग किए बिना पिछली प्रतिबद्ध परिवर्तनों को पूर्ववत करें" के लिए अद्यतन किया है।

— VonC

git revertहार्ड रीसेट के बिना और उपयोगकर्ताओं को परेशान किए बिना करने के लिए उपयोग करें ।

— यूजर 562374

Delete

— wjandrea

रिमोट को रोलिंग करना वह है जो हतोत्साहित करता है, लेकिन यदि आप जो करना चाहते हैं, वह करें। ऐसा करने के सैकड़ों तरीके हैं, लेकिन परिणाम सर्वर की ओर से समान होगा।

— फेलिपक

Answer 1

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

git reset --hard HEAD^ 
git push -f 

(या, यदि आपके पास दूरस्थ रेपो तक सीधी पहुंच है, तो आप इसका HEAD संदर्भ बदल सकते हैं, भले ही यह नंगे रेपो हो )

ध्यान दें, के रूप में द्वारा टिप्पणी की विदेशी प्रौद्योगिकी में नीचे टिप्पणी , विंडोज (सीएमडी सत्र) पर, आप की आवश्यकता होगी ^^:

git reset --hard HEAD^^
git push -f 

2011 के बाद से अपडेट:
का उपयोग करना git push --force-with-lease( जो मैं यहां पेश करता हूं , 2013 में Git 1.8.5 के साथ पेश किया गया) सुरक्षित है।

चित्रण के लिए श्वार्न का उत्तर देखें ।

---

क्या होगा अगर किसी ने पहले ही रेपो खींच लिया है? तब मैं क्या करूंगा?

फिर मैं कुछ ऐसा सुझाऊंगा जो इतिहास को फिर से नहीं लिखेगा:

• git revert स्थानीय रूप से आपकी पिछली कमिट (एक नई कमेटी बनाना जो पिछली कमिटमेंट को उलट देती है)
• द्वारा उत्पन्न 'रिवर्ट' को धकेलें git revert।

Comments

क्या होगा अगर किसी ने पहले ही रेपो खींच लिया है? तब मैं क्या करूंगा?

— जैमिस चार्ल्स

@gwho एक शाखा बनाता है? नहीं, यह एक शाखा के सिर को हिलाता है, लेकिन आप अभी भी उसी शाखा में हैं। हालाँकि, चूंकि अब पुश-फॉरवर्ड तेज़ नहीं है, हाँ, आपको उस पुश को लागू करने की आवश्यकता है।

— वॉन

क्या यह जानने का कोई तरीका है कि क्या किसी ने रेपो खींच लिया है?

— पिंकर्टन

Windows में, ^ वर्ण का उपयोग लाइन निरंतरता के लिए और एक चरित्र से बचने के लिए किया जाता है, जिससे कमांड बनती है: git reset --hard HEAD ^^

— Alien Technology

@AlienTechnology Powershell का उपयोग करते हुए, विंडोज़ 10 पर, मुझे केवल अंतिम कमिट रीसेट करने के लिए टाइप करना था reset --hard HEAD^और न reset --hard HEAD^^करना था।

— गैसपंचियो

Answer 2

स्थानीय शाखा एक संशोधन वापस सेट करें ( HEAD^मतलब एक संशोधन वापस):

git reset --hard HEAD^

मूल में परिवर्तन धक्का:

git push --force

आपको जोर लगाने पर मजबूर होना पड़ेगा क्योंकि अन्यथा यह समझ जाएगा कि आप originएक कमिट के पीछे हैं और कुछ भी नहीं बदलेगा।

यह करने के साथ वहाँ किसी भी अग्रिम का सम्मान किए बिना रिमोट रेपो में --forceअधिलेखित करने के लिए कहता है HEAD।

Comments

मेरा सुझाव है कि इसे वापस नहीं बुलाएंगे, क्योंकि यह एक विशिष्ट शब्द है जिसका अर्थ बहुत अलग अर्थ है।

— कास्कैबेल

@ जेफ्रोमी: संकेत के लिए धन्यवाद। संपादित।

— eckes

बहुत बढ़िया जवाब। मैंने पढ़ा है कि रीसेट का उपयोग करने से आंशिक रूप से हतोत्साहित किया जाता है, खासकर यदि रिपॉजिटरी को अन्य उपयोगकर्ताओं के साथ साझा किया जाता है। क्या ऐसा करने के लिए एक क्लीनर तरीका है, जो आपके पिछले सभी परिवर्तनों को पूर्ववत करता है?

— जैमिस चार्ल्स

सावधान रहे! अपने अनचाहे बदलावों को या अपने खोए हुए को

— छुड़ाएं

यह अच्छा है। तो, क्या इसका मतलब यह है कि जब हम ऐसा करते हैं git push origin master, तो Git रिमोट पर एक नई कमिट बनाने में सक्षम है क्योंकि स्थानीय ब्रांच कम से कम एक बार कमिट करने से पहले है? इसके अलावा, बाद वाले को निश्चित रूप से अलग होना चाहिए कि रिमोट रेपो में सिर किस ओर इंगित करता है?

— MadPhysicist

Answer 3

यदि आप अंतिम प्रतिबद्ध सुनना चाहते हैं:

चरण 1:

संदेशों के साथ अपने स्थानीय आवागमन की जाँच करें

$ git log

चरण 2:

स्थानीय शाखा (या मास्टर) से परिवर्तनों को रीसेट किए बिना अंतिम प्रतिबद्ध निकालें

$ git reset HEAD^

या यदि आप अंतिम प्रतिबद्ध फ़ाइलें और अद्यतन नहीं सुनना चाहते हैं

$ git reset HEAD^ --hard

चरण 3:

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

$ git push origin branch -f

बस!

Comments

यही कारण है कि नहीं कर रहा है को वापस लाने में एक प्रतिबद्ध, यह एक जगह है। कृपया हमें पारंपरिक शब्दों का दुरुपयोग करके नौसिखियों को भ्रमित न करें।

— Suncat2000

Answer 4

Bellow कमांड डालकर आप अपना git कमिट इतिहास देख सकते हैं -

$ git लॉग

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

चरण 1: स्थानीय रूप से अंतिम प्रतिबद्ध निकालें -

$ जीआईटी रीसेट - भार हेड ~

यह आपके कमिट HEAD को कम्‍पनी_C में बदल देगा

चरण 2: दूरस्थ के लिए नए HEAD के लिए अपना परिवर्तन पुश करें

$ git पुश ओरिजिन + HEAD

यह कमांड रिमोट से अंतिम कमिट को हटा देगा।

PS इस कमांड का मैक OSX पर परीक्षण किया गया है और इसे अन्य ऑपरेटिंग सिस्टम पर भी काम करना चाहिए (हालांकि अन्य OS के बारे में दावा नहीं करना चाहिए)

Answer 5

विंडोज मशीनों के लिए, उपयोग करें:

git reset HEAD~1  #Remove Commit Locally

Answer 6

यहां प्रक्रिया का एक अद्यतन संस्करण है जो सुरक्षित है।

git reset --hard HEAD^ 
git push --force-with-lease

git push -fअंधाधुंध रूप से दूरस्थ रिपॉजिटरी को आपके स्वयं के परिवर्तनों से बदल देगा। अगर किसी और ने बदलाव को धक्का दिया है तो वे खो जाएंगे। git push --force-with-leaseयदि रिपॉजिटरी आपकी अपेक्षा के अनुसार है तो केवल आपके रिबेस को आगे बढ़ाएगी। यदि किसी और ने पहले से ही धक्का दिया है तो आपका धक्का विफल हो जाएगा।

देखें- हानिकारक माना जाता है; समझ-के -फोर्स-लीज़ के साथ ।

मैं इस के रूप में उर्फ ​​करने की सलाह देता हूं repush = push --force-with-lease।

क्या होगा अगर किसी ने पहले ही रेपो खींच लिया है? तब मैं क्या करूंगा?

उन्हें बताओ git pull --rebase=merges। के बजाय git fetch originऔर git merge origin/masterयह होगा git fetch originऔर git rebase -r origin/master। यह masterनए विद्रोह के शीर्ष पर उनके किसी भी स्थानीय परिवर्तन को फिर से लिखेगा origin/master। -rउनके द्वारा किए गए किसी भी विलय को संरक्षित करेगा।

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

[pull]
        rebase = merges

Comments

सहमत हुए, और उत्थान किया। मेरे बचाव के लिए, मेरे पुराने 2011 के उत्तर को विकल्प की शुरुआत से दो साल पहले लिखा गया था --force-with-lease।

— वॉन

मुझे लगा कि मैंने पहले ही (कल): stackoverflow.com/posts/4647362/revisions

— VonC

Answer 7

मैंने इस आदेश द्वारा आपकी तरह समस्या का हल किया:

git reset --hard HEAD^
git push -f <remote> <local branch>:<remote branch> 

Answer 8

यदि आपके पास दूरस्थ रेपो तक सीधी पहुंच है, तो आप हमेशा उपयोग कर सकते हैं:

git reset --soft HEAD^

यह काम करता है क्योंकि गैर-मौजूद कार्यशील निर्देशिका को संशोधित करने का कोई प्रयास नहीं है। अधिक जानकारी के लिए कृपया मूल उत्तर देखें:

मैं एक गीले नंगे रिपॉजिटरी में अंतिम प्रतिबद्ध को कैसे अनफिट कर सकता हूं?

Answer 9

मैं सिर्फ रिमोट और क्लियर कमिट हिस्ट्री से भी आखिरी कमिटमेंट निकालना चाहता था। निम्नलिखित एक आकर्षण की तरह काम किया

git reset --hard HEAD^ 
git push -f 

Comments

लेकिन ऊपर दिए गए मेरे उत्तर से "निम्नलिखित" कैसे अलग है ?

— VonC

Answer 10

सिर को रीसेट करने और पिछली कमिट को वापस करने का तरीका है

$ git reset HEAD^ --hard
$ git push <branchname> -f

लेकिन कभी-कभी इसे दूरस्थ शाखा में स्वीकार नहीं किया जा सकता है:

To ssh:<git repo>
 ! [rejected]        develop -> develop (non-fast-forward)
error: failed to push some refs to 'ssh:<git repo>'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

तो दूसरा तरीका है

git revert HEAD
git push <remote branch>

यह ठीक काम करता है।

नोट: याद रखें कि क्या git push -f <force>विफल हुआ और फिर आप वापस लौटने का प्रयास करते हैं। पहले एक करें git pull, ताकि दूरस्थ और स्थानीय सिंक में हों और फिर प्रयास करें git revert।
साथ की जाँच करें git logसुनिश्चित करें कि दूरस्थ बनाने के लिए और स्थानीय ही SHA1 साथ प्रतिबद्ध के एक ही बिंदु पर कर रहे हैं ..

git revert 
A --> B --> C -->D
A--> B --> C --> D --> ^D(taking out the changes and committing reverted diffs)

Answer 11

स्थानीय स्वामी पर

git reflog
-- this will list all last commit
  e.g Head@{0} -- wrong push
      Head@{1} -- correct push  
git checkout Head@{1} .
  -- this will reset your last modified files

git status 
git commit -m "reverted to last best"
git push origin/master

अगर दूसरे ने खींचा या नहीं, तो परेशान होने की जरूरत नहीं।

किया हुआ!

Answer 12

यदि आप केवल अपने स्थानीय भंडार के साथ खिलवाड़ किए बिना दूरस्थ भंडार से अंतिम प्रतिबद्ध निकालना चाहते हैं, तो यहां एक-लाइनर है:

git push origin +origin/master~:master

---

यह निम्नलिखित सिंटैक्स का उपयोग करता है:

git push <remote> <refspec>

यहाँ, <remote>है origin, और <refspec>निम्नलिखित संरचना है:

+origin/master~:master

विवरण में पाया जा सकता है git-push(1)। पूर्ववर्ती +मतलब है, और "से दूसरे भाग का अर्थ है" बल इस रेफरी धक्का " origin/master~के लिए master(रिमोट का origin)"। यह जानना मुश्किल नहीं origin/master~है कि अंतिम प्रतिबद्ध पहले है origin/master, है ना?

Answer 13

मेरे लिए यह दो काम करता है:

git checkout commit_id
git push origin +name_of_branch

Answer 14

आप यह भी कर सकते हैं:

git reset --hard <commit-hash>
git push -f origin master

और हर कोई है जो नवीनतम बुरे आवागमन रीसेट मिला है:

git reset --hard origin/master