मैं कमिट के बीच आगे और पीछे कैसे जाऊं?

Question

मैं एक कर रहा हूं git bisectऔर समस्याग्रस्त प्रतिबद्ध पर पहुंचने के बाद, मैं अब यह सुनिश्चित करने के लिए एक कदम आगे / पिछड़े पाने की कोशिश कर रहा हूं कि मैं सही हूं।

मैं HEAD^इतिहास में पीछे जाना जानता हूं, लेकिन क्या मुझे आगे बढ़ाने के लिए एक और शॉर्टकट है (भविष्य में एक विशिष्ट प्रतिबद्धता की ओर) जैसे:

A - B - C(HEAD) - D - E - F

मुझे पता है कि मेरा लक्ष्य एफ है और मैं सी से डी की ओर बढ़ना चाहता हूं ।

---

नोट: यह Git का डुप्लिकेट नहीं है : कमिट्स के बीच आगे और पीछे कैसे जाएं , मेरा सवाल थोड़ा अलग है और वहां इसका जवाब नहीं दिया गया है

Comments

stackoverflow.com/questions/2263674/… भी मदद कर सकता है।

— VonC

git checkout -b new_branch HEAD~4जाने के लिए 4 से शुरू होता है HEAD से stackoverflow.com/a/4940090/911945 के

— एंटोन तारासेंको

Answer 1

मैंने थोड़ा प्रयोग किया है और यह आगे की ओर नेविगेट करने के लिए ट्रिक करने के लिए लगता है ( संपादित करें : यह तभी अच्छी तरह से काम करता है जब आपके पास मर्ज किए बिना एक रेखीय इतिहास हो):

git checkout $(git rev-list --topo-order HEAD..towards | tail -1)

जहां towardsकमेटी का SHA1 या टैग है।

स्पष्टीकरण:

• अंदर का $()अर्थ है: वर्तमान HEADऔर towardsकमिट (छोड़कर HEAD) के बीच सभी कमिट्स प्राप्त करें , और पूर्ववर्ती क्रम में उन्हें क्रमबद्ध करें (जैसे git logडिफ़ॉल्ट रूप से - कालानुक्रमिक क्रम के बजाय जो कि डिफ़ॉल्ट रूप से डिफ़ॉल्ट हैrev-list ), और फिर अंतिम एक लें ( tail), यानी हम जिस पर जाना चाहते हैं।
• इसका मूल्यांकन उपखंड में किया जाता है, और git checkoutचेकआउट करने के लिए पास किया जाता है।

आप किसी फ़ंक्शन को एक पैरामीटर के रूप में सुलभ होने के .profileलिए विशेष रूप से प्रतिबद्ध करने के लिए आगे बढ़ने के लिए अपनी फ़ाइल में एक पैरामीटर-अपेक्षा उर्फ ​​के रूप में परिभाषित कर सकते हैं :

# Go forward in Git commit hierarchy, towards particular commit 
# Usage:
#  gofwd v1.2.7
# Does nothing when the parameter is not specified.
gofwd() {
  git checkout $(git rev-list --topo-order HEAD.."$*" | tail -1)
}

# Go back in Git commit hierarchy
# Usage: 
#  goback
alias goback='git checkout HEAD~'

Comments

आगे बढ़ना इतिहास के सीधे हिस्सों पर ठीक काम करता है लेकिन मर्ज का सामना करते समय लूप में चला जाता है।

— कोस्तस

हाँ, मैंने वास्तव में मर्ज पर इसका परीक्षण नहीं किया है। मैं खाली समय में एक नज़र रखने की कोशिश करूँगा, लेकिन मेरे पास अस्थायी रूप से बहुत कम प्रोत्साहन है, क्योंकि हम अपनी परियोजना में एक सख्ती से रैखिक होने के लिए सहमत हैं;)

— जकूब.ग

बहुत बढ़िया जवाब! स्वचालित रूप से वर्तमान शाखा निर्दिष्ट करने के लिए संशोधित: stackoverflow.com/a/23172256/480608

— राइन रेवरे

यह गलत है। git logकालानुक्रमिक क्रम में दिखाता है, डिफ़ॉल्ट रूप से, उसी तरह rev-list, जैसे --graphध्वज का उपयोग करते समय ।

— पैपीरो

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

— स्नोक्रैश

Answer 2

आपको केवल स्पष्ट होने की आवश्यकता है, अलग नहीं किया गया हेड स्टेट रीसेट करना है, चेकआउट नहीं।

git reset HEAD@{1}

Comments

या git reset "HEAD@{1}"मछली और शक्तियों जैसे कुछ गोले में .. git reflogसही कमिट खोजने के लिए भी उपयोगी हो सकता है।

— कुक

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

— क्रिस पेज

मैंने ऐसा किया था कि समय पर वापस देखने के लिए, फिर मैंने git reset HEADजहाँ मैं था वहाँ वापस जाने के लिए किया ... अब मुझे नहीं पता कि मेरा भंडार किस राज्य में है और सब कुछ डरावना है। अब मुझे क्या करना चाहिए?

— Theonlygusti

Answer 3

मेरा मानना ​​है कि आप कर सकते हैं:

git reset HEAD@{1}

एक समय में आगे बढ़ने के लिए। कई कमिट्स को आगे बढ़ाने के लिए, HEAD @ {2}, HEAD @ {3}, आदि का उपयोग करें।

Answer 4

यह वही है जो मैं आगे और पीछे नेविगेट करने के लिए उपयोग कर रहा हूं।

अगले कमिट में जा रहे हैं

function n() {
    git log --reverse --pretty=%H master | grep -A 1 $(git rev-parse HEAD) | tail -n1 | xargs git checkout
}

पिछले प्रतिबद्ध करने के लिए चल रहा है

function p() {
    git checkout HEAD^1
}

Comments

धन्यवाद! मैं इस का उपयोग कर रहा हूँ! मेरे जैसे अन्य शुरुआती लोगों के लिए नोट्स : HEAD को git checkout <current branch>रीटेट करने के लिए, नवीनतम प्रतिबद्ध के लिए संलग्न करता है। git checkout -b <new-branch-name>वर्तमान प्रतिबद्ध से नई शाखा में परिवर्तन की अनुमति देता है। git rebase -iभी काम करता है। इसके अलावा , मैंने नोड n()फ़ंक्शन nx()मैनेजर "n" के साथ विरोध से बचने के लिए अपने फ़ंक्शन का नाम दिया । उपनामों की जांच करना सुनिश्चित करें!

— स्टीवन चोई

फ़ंक्शन () {...} एक यूनिक्स / लिनक्स बैश स्क्रिप्टिंग फ़ाइल को संलेखन करने के लिए है, मैं विंडोज से आता हूं, मेरे लिए सबसे पहले इसे समझना थोड़ा कठिन है

— IcyBrk

Answer 5

कहते हैं कि एफ नवीनतम प्रतिबद्धता है trunk(अपनी शाखा का नाम यहां डालें) ... आप इसे trunk~0(या सिर्फ trunk), ई के रूप में trunk~1, डी trunk~2आदि के रूप में संदर्भित कर सकते हैं ।

अपने तरीके से नाम वापसी के लिए और अधिक तरीकों के लिए फिर से देखें।

Comments

~ वापस चला जाता है, foward नहीं, ट्रंक ~ 2 एक है

— EmmanuelMess

हाँ। यह उत्तर मानता है कि आपके पास एक शाखा है जिसे ट्रंक की ओर इशारा किया गया है F, और यह कि आप जानते हैं कि उस शाखा के इतिहास में आप कहाँ जाना चाहते हैं। यह HEAD के सापेक्ष आगे बढ़ने की कोशिश नहीं कर रहा है, लेकिन ट्रंक के सापेक्ष कम-दूर-पीछे है।

— बेकार

@EmmanuelMess trunk~2A कैसे है ?

— Theonlygusti

@theonlygusti आप दो बार HEAD से वापस जाते हैं।

— इमैनुएलमेस

आप अभी भी यह मान रहे हैं कि शाखा trunkऔर आपका करंट HEADसमान है जो कि प्रश्न में नहीं दिखाया गया है, जो मैंने कहा है कि मैं ऐसा नहीं मान रहा हूँ, और जो बहुत संभावना नहीं हैbisect

— बेकार

Answer 6

जब से आप पेड़ से नीचे जा रहे हैं, तब पीछे की ओर जाना तुच्छ है, और जाने के लिए हमेशा एक ही रास्ता है

  function git_down
        git checkout HEAD^
  end

जब आप आगे बढ़ रहे हैं तो आप पेड़ को आगे बढ़ा रहे हैं, इसलिए आपको स्पष्ट होना चाहिए कि आप किस शाखा को लक्षित कर रहे हैं:

  function git_up 
        git log --reverse --pretty=%H $argv | grep -A 1 (git rev-parse HEAD) | tail -n1 | xargs git checkout
  end

उपयोग: git down ,git up <branch-name>

Comments

जब विलय शामिल होता है तो पिछड़ जाना पूरी तरह से अद्वितीय नहीं होता है। हालांकि HEAD^आमतौर पर एक उचित डिफ़ॉल्ट है।

— kdb

Answer 7

यदि आप आगे देखना चाहते हैं, तो आप इस ट्रिक को कर सकते हैं, क्योंकि Git में इसके लिए सख्त कमांड नहीं है।

git log --reverse COMMIT_HASH..

उदाहरण

लॉग इतिहास हैश की सूची:

A
B
C -> put this
D

कमांड का उपयोग करते हुए git log --reverse C.., आउटपुट में आप बी और ए देखेंगे ।

Answer 8

शायद सबसे अच्छा तरीका नहीं है, लेकिन आप git logकमिट्स की सूची देखने के लिए उपयोग कर सकते हैं और फिर git checkout [sha1 of D]डी पर जाने के लिए उपयोग कर सकते हैं।

Comments

मुझे यह नहीं मिला, अगर वह सी में है, तो गिट लॉग केवल उसे सी, बी और ए

— दिखाएगा

ठीक है, मिल गया, लेकिन आपको एक मुश्किल

— गाइट

Answer 9

मैंने बस इस पर एक परीक्षण किया। उदाहरण के लिए कहें तो आप मास्टर ब्रांच में हैं:

git checkout HEAD@{3}

इसलिए सिर अलग हो जाता है, और आप फिर से किसी अन्य प्रतिबद्ध पर जाने की कोशिश कर सकते हैं:

git checkout HEAD@{4}

एक बार जब आप चारों ओर देख रहे हैं, तो आप उस शाखा की जाँच करके अपने मूल राज्य में वापस जा सकते हैं। मेरे उदाहरण में: मास्टर शाखा

git checkout master

यदि आप मूल स्थिति में नहीं जाना चाहते हैं, और चाहते हैं कि एक कमिट को अपने सिर के रूप में रखें और वहां से जारी रहें, तो आपको वहां से बाहर जाने की आवश्यकता है। उदाहरण के लिए "git checkout HEAD @ {4}" के बाद, आप जारी कर सकते हैं

git checkout -b MyNewBranch

Answer 10

वर्कअराउंड के रूप में, आप बस HEAD के साथ वापस आ सकते हैं

git checkout <branch>

और फिर आप जिस कमिटमेंट के साथ जाना चाहेंगे

git checkout HEAD~<offset>

Answer 11

यदि आप बनाम कोड का उपयोग कर रहे हैं तो गेट इतिहास एक भयानक प्लगइन है जहां आप कुशलता से संपादक में ही अपनी सामग्री देख सकते हैं और जांच सकते हैं। बाहर की जाँच लिंक

Answer 12

branchName=master; commitInOrder=1; git checkout $(git log --pretty=%H "${branchName}" | tac | head -n "${commitInOrder}" | tail -n 1)

कहाँ पे:

branchName शाखा नाम के बराबर

commitInOrder चयनित शाखा में बहुत पहले से क्रम में एक प्रतिबद्ध है (इसलिए 1 बहुत पहली प्रतिबद्ध है, 2 शाखा में दूसरी प्रतिबद्ध है, आदि)