git - गिट का उपयोग करके किसी विशिष्ट फ़ाइल को एक विशिष्ट संशोधन में रीसेट या वापस लाएं?




version-control (20)

बचाव के लिए गिट-एलियास, अजीब और खोल-कार्य!

git prevision <N> <filename>

जहां फ़ाइल <filename> फ़ाइल के लिए रोलबैक के लिए फ़ाइल के संशोधन की संख्या है।
उदाहरण के लिए, एक फ़ाइल x/y/zc के तत्काल पिछले संशोधन को चेकआउट करने के लिए, चलाएं

git prevision -1 x/y/z.c

गिट रोकथाम कैसे काम करता है?

अपने gitconfig में निम्नलिखित जोड़ें

[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

मूल रूप से आदेश

  • निर्दिष्ट फ़ाइल पर एक git log करता है और
  • फ़ाइल के इतिहास में उपयुक्त प्रतिबद्धता आईडी बनाता है और
  • निर्दिष्ट फ़ाइल के लिए प्रतिबद्ध-आईडी पर एक git checkout निष्पादित करता है।

अनिवार्य रूप से, वह सभी जो इस स्थिति में मैन्युअल रूप से करेंगे,
एक सुंदर, कुशल गिट-उर्फ में लपेटा हुआ - गिट-प्रेसिजन

मैंने फाइल में कुछ बदलाव किए हैं जो फाइलों के समूह के हिस्से के रूप में कुछ बार किए गए हैं, लेकिन अब पिछले संस्करणों में बदलावों को रीसेट / रीवर्ट करना चाहते हैं।

मैंने जिस संशोधन की आवश्यकता है उसे ढूंढने के लिए मैंने git diff के साथ एक git log किया है, लेकिन मुझे पता नहीं है कि फ़ाइल को अतीत में अपने पूर्व राज्य में कैसे वापस लेना है।


आप diff कमांड का उपयोग कर फ़ाइल में किए गए परिवर्तनों की त्वरित समीक्षा कर सकते हैं:

git diff <commit hash> <filename>

फिर उस प्रतिबद्धता को एक विशिष्ट फ़ाइल को वापस करने के लिए रीसेट कमांड का उपयोग करें:

git reset <commit hash> <filename>

यदि आपके पास स्थानीय संशोधन हैं तो आपको --hard विकल्प का उपयोग करने की आवश्यकता हो सकती है।

मैनेजिंग वेप पॉइंट्स के लिए एक अच्छा वर्कफ़्लो टैग्स का उपयोग अपनी टाइमलाइन में अंक को स्पष्ट रूप से चिह्नित करने के लिए करना है। मैं आपकी आखिरी वाक्य को काफी समझ नहीं पा रहा हूं लेकिन आप जो चाहते हैं वह पिछले समय से एक शाखा को अलग कर सकता है। ऐसा करने के लिए, आसान चेकआउट कमांड का उपयोग करें:

git checkout <commit hash>
git checkout -b <new branch name>

जब आप उन परिवर्तनों को मर्ज करने के लिए तैयार हों तो आप अपनी मुख्य लाइन के खिलाफ इसे फिर से दबा सकते हैं:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

आश्चर्यजनक रूप से, 'गिट चेकआउट फू' ​​काम नहीं करेगा अगर काम करने वाली प्रति foo नामक निर्देशिका में है; हालांकि, दोनों 'गिट चेकआउट हेड फू' और 'गिट चेकआउट। / फू' दोनों होंगे:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

इस मामले में कि आप किसी फ़ाइल को पिछली प्रतिबद्धता (और जिस फ़ाइल को आप पहले से ही वापस करना चाहते हैं) पर वापस करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं

git checkout HEAD^1 path/to/file

या

git checkout HEAD~1 path/to/file

फिर बस मंच और "नया" संस्करण प्रतिबद्ध करें।

ज्ञान के साथ सशस्त्र है कि एक प्रतिबद्धता के मामले में एक प्रतिबद्धता के दो माता-पिता हो सकते हैं, आपको पता होना चाहिए कि HEAD ^ 1 पहला अभिभावक है और हेड ~ 1 दूसरा माता-पिता है।

पेड़ में केवल एक ही माता-पिता होने पर या तो काम करेगा।


गिट चेकआउट रेफ | प्रतिबद्ध हैश - फ़ाइलपैथ

जैसे

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

जब आप "रोलबैक" कहते हैं तो आपको सावधान रहना होगा। यदि आपके पास $ ए को प्रतिबद्ध करने में फ़ाइल का एक संस्करण होता था, और उसके बाद बाद में दो अलग-अलग दो बिट्स में $ 2 और $ सी (जो आप देख रहे हैं वह फ़ाइल का तीसरा पुनरावृत्ति है), और यदि आप कहते हैं " मैं पहले व्यक्ति को वापस रोल करना चाहता हूं ", क्या आपको वाकई इसका मतलब है?

यदि आप दूसरे और तीसरे पुनरावृत्ति दोनों में बदलावों से छुटकारा पाना चाहते हैं, तो यह बहुत आसान है:

$ git checkout $A file

और फिर आप परिणाम प्रतिबद्ध करते हैं। आदेश पूछता है "मैं प्रतिबद्ध $ ए द्वारा दर्ज राज्य से फ़ाइल को देखना चाहता हूं"।

दूसरी तरफ, आपका मतलब यह है कि दूसरा पुनरावृत्ति (यानी $ बी प्रतिबद्ध) को बदलने से छुटकारा पाने के लिए, फाइल को $ सी करने के लिए प्रतिबद्ध करते हुए, आप $ B को वापस करना चाहते हैं

$ git revert $B

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


नोट, हालांकि, वह git checkout ./foo और git checkout HEAD ./foo बिल्कुल वही बात नहीं है ; इसका स्पष्ट उदाहरण:

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

(दूसरा add इंडेक्स में फ़ाइल को चरणबद्ध करता है, लेकिन यह प्रतिबद्ध नहीं होता है।)

Git checkout ./foo अर्थ है इंडेक्स से पथ ./foo वापस करें; HEAD ने इंडेक्स में उस पथ को अपने HEAD संशोधन में ऐसा करने से पहले इसे वापस करने के लिए गिट को निर्देश दिया।


फ़ाइल के पिछले प्रतिबद्ध संस्करण पर जाने के लिए, प्रतिबद्ध संख्या प्राप्त करें, फिर eb917a1 कहें

git checkout eb917a1 YourFileName

यदि आपको अभी अंतिम अंतिम संस्करण पर वापस जाने की आवश्यकता है

git reset HEAD YourFileName
git checkout YourFileName

यह आपको फ़ाइल की आखिरी प्रतिबद्ध स्थिति में ले जाएगा


मुझे लगता है कि मैंने इसे पाया है .... http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

कभी-कभी आप वापस जाना चाहते हैं और एक निश्चित बिंदु से हर बदलाव के बारे में भूल जाते हैं क्योंकि वे सभी गलत हैं।

के साथ शुरू:

$ git log

जो आपको हालिया प्रतिबद्धताओं की सूची दिखाता है, और उनके SHA1 हैश।

अगला, टाइप करें:

$ git reset --hard SHA1_HASH

किसी दिए गए प्रतिबद्धता को राज्य को बहाल करने और रिकॉर्ड से सभी नए कामों को स्थायी रूप से मिटाने के लिए।


मेरे पास अभी भी एक ही समस्या थी और मुझे यह जवाब समझने में आसान लगता है ( commit-ref उस लॉग में परिवर्तन का SHA मान है जिसे आप वापस जाना चाहते हैं):

git checkout [commit-ref] [filename]

यह आपके पुराने निर्देशिका में उस पुराने संस्करण को रखेगा और वहां से यदि आप चाहें तो इसे प्रतिबद्ध कर सकते हैं।


यदि आप अपने अंतिम काम में गलत फाइल करते हैं तो निर्देश का पालन करें:

  1. ओपन सोर्स पेड़, इस प्रतिबद्धता में बदलें

  1. लाइनों को बदलें और अपनी प्रतिबद्धता को खोजें कि गलत फ़ाइल प्रतिबद्ध के रूप में भेजी गई है

  1. आप उस प्रतिबद्धता में अपने परिवर्तनों की सूची देख सकते हैं
  2. इसे चुनें और फिर ... बटन दाहिने हाथ पर क्लिक करें ... रिवर्स फ़ाइल पर क्लिक करें
  3. तो आप इसे नीचे बाईं ओर फ़ाइल स्थिति टैब पर देख सकते हैं और फिर unstage पर क्लिक करें:

  1. अपना विजुअल स्टूडियो कोड खोलें और अपनी हटाई गई फाइलों को वापस करके वापस लाएं
  2. उनके बाद, आप स्रोत पेड़ में अपनी आखिरी प्रतिबद्धता में परिणाम देख सकते हैं


यदि आप गिट एक्सटेंशन का उपयोग कर रहे हैं और आप केवल फ़ाइल के लिए मूल प्रतिबद्धता पर वापस जाना चाहते हैं, तो आप उस परिवर्तन का चयन कर सकते हैं जिसमें वे परिवर्तन शामिल हैं जिन्हें आप वापस करना चाहते हैं, फिर विवरण फलक में 'डिफ' टैब का चयन करें, राइट-क्लिक करें वह फ़ाइल जिसे आप वापस करना चाहते हैं, फिर 'फ़ाइल को रीसेट करें' ...., फिर 'ए' (अभिभावक)


यदि आप सबसे सुविधाजनक हैं तो आप SHA-1 समेत गिट प्रतिबद्ध के किसी भी संदर्भ का उपयोग कर सकते हैं। मुद्दा यह है कि आदेश इस तरह दिखता है:

git checkout [commit-ref] -- [filename]


यह मेरे लिए काम किया:

git checkout <commit hash> file

फिर परिवर्तन करें:

git commit -a

यहां कई जवाब git reset ... <file> का उपयोग करने का दावा करते हैं git reset ... <file> या git checkout ... <file> लेकिन ऐसा करके, आप <file> प्रतिबद्धता के बाद प्रतिबद्ध किए गए प्रत्येक संशोधन को खो देंगे।

यदि आप एक ही फाइल पर केवल एक ही फाइल पर बदलावों को वापस करना चाहते हैं, जैसे कि git revert करेगा, लेकिन केवल एक फ़ाइल के लिए (या प्रतिबद्ध फाइलों का सबसेट कहें), तो मैं सुझाव देता हूं कि दोनों git diff और git apply दोनों का उपयोग करें ( <sha> = उस प्रतिबद्धता का हैश जिसे आप वापस करना चाहते हैं):

git diff <sha>^ <sha> path/to/file.ext | git apply -R

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

बेशक, यह काम नहीं करेगा अगर <sha1> और HEAD (संघर्ष) के बीच किसी भी प्रतिबद्धता से वापस की गई रेखाओं को संशोधित किया गया है।


यहां बताया गया है कि rebase कैसे काम करता है:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

मान लें कि आपके पास है

---o----o----o----o  master
    \---A----B       <my branch>

पहले दो कमांड ... गिट चेकआउट गिट रीबेस मास्टर को प्रतिबद्ध करें

... master शाखा में लागू होने वाले परिवर्तनों की शाखा देखें। rebase आदेश कमांड <my branch> (जो master में नहीं मिलता है) से आता है और उन्हें master के सिर पर लागू करता है। दूसरे शब्दों में, <my branch> में पहली प्रतिबद्धता के माता-पिता अब master इतिहास में पिछली प्रतिबद्धता नहीं है, बल्कि master के वर्तमान प्रमुख हैं। दो आदेश इस प्रकार हैं:

git rebase master <my branch>

इस आदेश को याद रखना आसान हो सकता है क्योंकि "आधार" और "संशोधित" शाखाएं स्पष्ट हैं।

। अंतिम इतिहास परिणाम है:

---o----o----o----o   master
                   \----A'----B'  <my branch>

अंतिम दो आदेश ...

git checkout master
git merge <my branch>

... सभी <my branch> master पर परिवर्तन लागू करने के लिए एक तेज़-आगे विलय करें। इस चरण के बिना, रीबेज प्रतिबद्ध master जोड़ा नहीं जाता है। अंतिम परिणाम यह है:

---o----o----o----o----A'----B'  master, <my branch>

master और <my branch> दोनों संदर्भ B' । साथ ही, इस बिंदु से <my branch> संदर्भ को हटाना सुरक्षित है।

git branch -d <my branch>

विशिष्ट संस्करण के लिए हैश कुंजी प्राप्त करने के लिए git log का उपयोग करें और फिर git checkout <hashkey> उपयोग करें

नोट: पिछले एक से पहले हैश टाइप करना न भूलें। अंतिम हैश आपकी वर्तमान स्थिति (HEAD) को इंगित करता है और कुछ भी नहीं बदलता है।


git checkout $revision -- $file की लाइनों के साथ सबसे अधिक सुझाव यहां। कुछ अस्पष्ट विकल्प:

git show $revision:$file > $file

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

git show $revision:$file

या

git show $revision:$file | vim -R -

(ओबीएस: $file को prefixed करने की आवश्यकता है ./ अगर यह git show $revision:$file लिए एक सापेक्ष पथ है git show $revision:$file काम करने के लिए git show $revision:$file )

और भी अजीब:

git archive $revision $file | tar -x0 > $file

git checkout -- foo

वह HEAD को foo रीसेट कर देगा। आप भी कर सकते हैं:

git checkout HEAD^ foo

एक संशोधन के लिए, आदि के लिए


git revert <hash>

एक दी गई प्रतिबद्धता वापस कर देगा। ऐसा लगता है जैसे आपको लगता है कि git revert केवल सबसे हालिया प्रतिबद्धता को प्रभावित करता है।

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





version-control