78 Soru: Git'teki en son yerel taahhütleri nasıl geri alabilirim?

tarafından oluşturulan soru Wed, May 29, 2019 12:00 AM

Yanlışlıkla yanlışlıkla dosyaları Git 'e verdim, ancak taahhüdüm için itmedim sunucu henüz.

Bu taahhütleri yerel depodan nasıl geri alabilirim?

    
19738
  1. Uyarı: Bunu yalnızca bir uzaktaki taahhüde itmediğiniz takdirde yapmalısınız, aksi takdirde daha önce taahhüdü yerine getiren başkalarının geçmişini karıştırırsınız uzaktan kumanda!
    2015-05-13 21: 18: 57Z
  2. 2015-06-08 19: 39: 17Z
  3. Yeni bir cevap göndermeden önce, bu soru için zaten 65+ cevap olduğunu düşünün. Cevabınızın mevcut cevaplar arasında olmayanlara katkıda bulunduğundan emin olun.
    2017-06-15 15: 26: 36Z
  4. Git'in neye ihtiyacı olduğunu biliyor musunuz? git undo, işte bu. O zaman git, bizim yaptığımız hataların üstesinden gelme konusundaki ünü, ölümlülerin yok olması gibi. Herhangi bir git komutunu çalıştırmadan önce mevcut durumu bir git yığına iterek uygulamak. Performansı etkileyeceğinden, etkinleştirip etkinleştirmeyeceğinize bir yapılandırma bayrağı eklemek en iyisidir.
    2018-03-20 01: 45: 28Z
  5. @ YiminRong Git'in alias özelliği ile yapılabilir: git-scm.com/book/tr/v2/Git-Basics-Git-Aliases
    2018-10-05 14: 50: 08Z
30 Yanıtlar                              30                         

Bir taahhüdü geri al ve yinele

 
$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
<< edit files as necessary >>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)
  1. Bu geri almak istediğiniz şeydir.
  2. Bu, çalışma ağacınızı (dosyalarınızın diskteki durumunu) değiştirmez, ancak işleme almayı geri alır ve işlediğiniz değişiklikleri işaretlenmemiş bırakır (böylece, git status'da "İşleme yönelik olmayan değişiklikler" olarak görünürler. taahhüt etmeden önce bunları tekrar eklemeniz gerekir). yalnızca önceki işleminize daha fazla değişiklik eklemek veya eklemek istiyorsanız ya da 1 işlem iletisini değiştirin, bunun yerine git reset --soft HEAD~’u kullanabilirsiniz. git reset HEAD~ (HEAD~, HEAD~1 ile aynıdır) ancak mevcut değişikliklerinizi aşamalı olarak bırakır.
  3. Çalışan ağaç dosyalarında düzeltmeler yapın.
  4.  git add yeni taahhüdünüze eklemek istediğiniz herhangi bir şey.
  5. Eski taahhüt mesajını tekrar kullanarak değişiklikleri kabul edin. reset, eski kafayı .git/ORIG_HEAD'a kopyaladı; commit ile -c ORIG_HEAD, başlangıçta eski işlemden gelen günlük iletisini içeren ve düzenlemenizi sağlayan bir düzenleyici açar. Mesajı düzenlemeniz gerekmiyorsa, -C seçeneğini kullanabilirsiniz.

Ancak dizinde herhangi bir değişiklik yaptıysanız, commit --amend'u kullanmanızın önceki işleminize ekleyeceğini unutmayın.

Kod zaten sunucunuza gönderildiyse ve geçmişin (yeniden oluşturmanın) üzerine yazma izniniz varsa, o zaman:

 
git push origin master --force

Bu cevaba da bakabilirsiniz:

Nasıl taşınır HEAD önceki bir yere mi döndü? (Ayrılmış kafa) & Taahhütleri geri al

Yukarıdaki cevap size, geri dönmek istediğiniz SHA-1'in ne olduğunu bulmak için kullanılan git reflog'u gösterecektir. Yukarıda açıklandığı gibi komut dizisini kullanmak istemediğiniz noktayı bulduğunuzda.


1 Ancak, taahhüt mesajınızda bir hata yaptıysanız daha önceki bir işlem için sıfırlamanıza gerek olmadığını unutmayın. En kolay seçenek git reset (o zamandan beri yaptığınız değişiklikleri denetlememek) ve ardından varsayılan ayarınızı açacak olan git commit --amend mesaj editörü önlemeSon taahhüt mesajı ile doldurulur.

    
21340
2019-05-20 20: 06: 45Z
  1. Eğer taahhüdün yanlış dalda olması durumunda tüm değişiklik aşamalarında git checkout theRightBranch olabilir. Sadece yapmam gerektiği gibi.
    2010-10-05 15: 44: 20Z
  2. DOS'ta çalışıyorsanız, git reset --soft HEAD^ yerine git reset --soft HEAD~1 kullanmanız gerekir. ^, DOS'ta bir devam karakteridir, bu yüzden düzgün çalışmayacaktır. Ayrıca, --soft varsayılandır, bu nedenle isterseniz git reset HEAD~1 diyerek çıkarırsınız.
    2011-04-13 14: 15: 10Z
  3. Ayrıca, zsh içinde ^ 'den alıntı yapmalısınız, yani git reset --soft 'HEAD^' ... en azından yaptım
    2011-10-27 18: 24: 16Z
  4. (Yukarıda yazdıklarımın düzeltilmesi; --mixed varsayılandır. --mixed değiştirilen dosyaları saklamak anlamına gelir, ancak dizinde kalmaz. --soft değiştirilen dosyaları saklar. ve onları değişiklikten hemen önce olduğu gibi dizinde tutun. Karışıklık için üzgünüm.)
    2011-11-17 02: 40: 53Z
  5. zsh kullanıcıları bulabilir: zsh: no matches found: HEAD^ - kaçmanız gerekir ^ i.e. git reset --soft HEAD\^
    2013-02-21 17: 47: 56Z

Nasıl çalıştığını bilmiyorsanız, taahhüdün geri alınması biraz korkutucu olabilir. Ama eğer anlarsan, aslında inanılmaz derecede kolay.

Buna sahip olduğunuzu söyleyin, burada C HEAD'iniz ve (F) dosyalarınızın durumudur.

 
   (F)
A-B-C
    ↑
  master

Nuke'ye C taahhüt edip bir daha asla görmemeyi istiyorsun. Bunu siz yapın:

 
git reset --hard HEAD~1

Sonuç:

 
 (F)
A-B
  ↑
master

Şimdi B, HEAD'dir. --hard kullandığınız için, dosyalarınız B taahhüdündeki durumuna geri döndürülür.

Ah, ancak C'nin felaket olmadığını, ancak biraz kapalı olduğunu varsayalım. Daha iyi bir taahhütte bulunmadan önce düzenlemeyi geri almak, ancak değişikliklerinizi korumak için biraz düzenleme yapın. Buradan başlayarak, başınız olarak C ile:

 
   (F)
A-B-C
    ↑
  master

Bunu --hard’u bırakarak yapabilirsiniz:

 
git reset HEAD~1

Bu durumda sonuç şöyledir:

 
   (F)
A-B-C
  ↑
master

Her iki durumda da, HEAD en son taahhüdün yalnızca bir göstergesidir. git reset HEAD~1 yaptığınızda, Git'e HEAD imlecini bir işlem geri getirmesini söyleyin. Ancak (--hard kullanmazsanız) dosyalarınızı oldukları gibi bırakırsınız. Şimdi git status, C'ye dahil ettiğiniz değişiklikleri gösterir. Hiçbir şey kaybetmediniz!

En hafif dokunuş için taahhütlerinizi geri alabilirsiniz, ancak dosyalarınızı ve dizin :

 
git reset --soft HEAD~1

Bu sadece dosyalarınızı yalnız bırakmaz, hatta indeksinizi de bırakır. git status yaptığınızda, aynı dosyaların daha önce olduğu gibi dizinde olduğunu göreceksiniz. Aslında, bu komuttan hemen sonra git commit yapabilirdiniz ve az önce yaptığınız taahhütleri tekrar edersiniz.

Bir şey daha: İlk örnekte olduğu gibi bir taahhüdü yok ettiğinizi varsayalım , sonra da gerekli gördükten sonra keşfedin ? Zor şans, değil mi?

Hayır, onu geri almanın bir yolu var hala . git reflog yazdığınızda, (kısmi) işlediğiniz bir liste göreceksiniz shas ( 'da, etrafta dolaştığınız kareler). Yok ettiğiniz taahhüdü bulun ve şunu yapın:

 
git checkout -b someNewBranchName shaYouDestroyed

Artık bu taahhüdü yeniden başlattınız. Taahhütler Git'te yaklaşık 90 gün boyunca tahrip edilmiyor, bu yüzden genellikle geri dönüp kurtulmak istemediğiniz birini kurtarabilirsiniz.

    
10293
2018-12-07 09: 56: 29Z
  1. @ dma_k, evet. Veya bir kere git reset --hard HEAD^^ yapabilirsin. Tilde (~) notasyonunu kullanıyorum çünkü şapka (^) notasyonu DOS'ta çalışmıyor.
    2012-02-25 15: 02: 44Z
  2. Başka bir güzel ipucu: Şubeyi remo yaptığınız taahhütte yeniden ekleyebilirsinizgit branch -f <branch> <commit-id> ile sundu. Taahhütleri yeniden oluşturmak zorunda kalmaz!
    2012-06-22 13: 11: 11Z
  3. Bir yeni başlayanlar için, son iki seçenek arasındaki farkın ne olduğu belli değil (--soft ve üstündeki). Dizinden bahsetmek işe yaramıyor, bunun ne anlama geldiğini henüz bilmiyoruz. @ Nessur'un yumuşak ve Ctrl-Z arasındaki bağlantısı gerçekten yardımcı oldu! Ancak iki seçenek arasındaki farkı hala tam olarak anlamadım.
    2012-06-26 15: 56: 52Z
  4. 'Neden' bir şeyin işe yaradığını söylemek, sadece cevabın söylenmesinden daha iyidir. Bu açıklama için Kudos - Git 'olsun' yardımcı oldu.
    2012-07-03 19: 13: 35Z
  5. Çok önemli bir noktayı kaçırmak: Eğer söz konusu taahhüt daha önce uzaktan kumandaya “itilmiş” ise, ne kadar basit olursa olsun, herhangi bir “geri alma” operasyonu muazzam bir acıya ve ıstıraba neden olur Bu işlemi yapan kullanıcıların geri kalanında yerel kopyasında, gelecekte bir 'git çek' yaptıklarında. Dolayısıyla, eğer taahhüt zaten “zorlanmış” ise, bunun yerine şunu yapın: git revert < bad-commit-sha1-id > git push kökeni:
    2013-11-08 23: 43: 18Z

Bu beni bulmam biraz zaman aldı, bu yüzden belki bu birine yardımcı olabilir ...

Son taahhüdünüzü "geri almanın" iki yolu vardır; bu işlemden önce herkese açık olup olmadığına (uzak havuzunuza itti) bağlı olarak:

Yerel bir taahhüt nasıl geri alınır

Diyelim ki yerel olarak taahhütte bulundum, ancak şimdi bu taahhüdü kaldırmak istiyorum.

 
git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

Her şeyi en son işlemden önceki haline geri döndürmek için, reset’dan önceki işlem için HEAD’a ihtiyacımız var:

 
git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

Şimdi git log, son taahhüdümüzün kaldırıldığını gösterecek.

Genel bir taahhüt nasıl geri alınır

Taahhütlerinizi daha önce kamuya açıkladıysanız, önceki taahhüdünüzde (mevcut HEAD) yaptığınız değişiklikleri "geri alan" yeni bir taahhüt oluşturmak isteyeceksiniz.

 
git revert HEAD

Değişiklikleriniz şimdi geri alınacak ve taahhütte bulunmaya hazır olacak:

 
git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Daha fazla bilgi için Git Basics - Şeyleri Geri Alma

    
1966
2018-01-30 23: 27: 24Z
  1. Bu cevabı en net buldum. git revert HEAD^ önceki değil, önceki değil. Yaptım: git revert HEAD ve sonra tekrar zorladım ve işe yaradı :)
    2011-07-14 08: 32: 53Z

İşleri istediğiniz şekilde almak için dosya ekleyin /kaldırın:

 
git rm classdir
git add sourcedir

O zaman taahhüdünde değişiklik yapın:

 
git commit --amend

Önceki, hatalı olan taahhüt, yeni endeks durumunu yansıtacak şekilde düzenlenecek - başka bir deyişle, ilk başta hatayı hiç yapmamış gibi olacaksınız.

Bunu yalnızca henüz itmediyseniz yapmanız gerektiğini unutmayın. Eğer zorladıysanız, normal olarak bir düzeltme yapmanız gerekir.

    
1685
2016-10-12 06: 45: 55Z
  1. Bu, git commit --amend yaptığımda ve gerçekten yapmak istediğim şey git commit olduğunda işe yarıyor mu?
    2011-05-18 13: 07: 31Z
  2. @ dbm, yanlışlıkla değiştirdiyseniz, git reset --soft <oldref>'u kullanın, burada oldref değişiklikten önceki taahhüt numarasıdır. Eski işleme kimliğini tanımlamak için git reflog'u kullanabilirsiniz. Bu, değişikliğin etkilerini geri alacak, ancak değişiklikleri aşamalı olarak bırakacaktır. O zaman sadece git commit'u düzenli bir taahhüt olarak kabul edin.
    2011-05-18 14: 20: 48Z
  3. @ Dennis, git commit --amend mevcut ağacı (örneğin, değişiklik değişiklikleri) geçerli, üzerine yazılan bir perdeye dönüştürürkiralamak. Bu noktadan sonra, daha fazla aşamalı sayılmazlar, çünkü taahhüdün bir parçası olurlar (yani git diff - cached boş), ancak "kaldırılmış" veya "kayıp" değillerdir.
    2012-02-01 03: 08: 06Z
  4. --amend seçeneği, sahte işlemelerden kaçınmak için püf noktalarıydı!
    2019-03-22 19: 58: 29Z
 
git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

veya

 
git reset --hard HEAD~1

Uyarı: Yukarıdaki komut, işlemek istediğiniz .java dosyadaki (ve diğer dosyalardaki) değişiklikleri kalıcı olarak kaldıracaktır.

hard reset - HEAD-1, çalışma kopyanızı yanlış taahhüdünüzden önce taahhüdün durumuna getirecektir.

    
954
2017-12-13 22: 03: 28Z
  1. "- hard", çalışmak istediği çalışma dizinindeki değiştirilmiş .java dosyalarından kurtulacak.
    2009-05-29 18: 26: 59Z
  2. Çalışan kopya değişikliklerini "git stash save" yapabilirsiniz, sert bir sıfırlama yapın ve sonra geri almak için "git stash pop" yazabilirsiniz, ancak yumuşak bir sıfırlama olur. daha basit.
    2011-04-15 13: 33: 03Z
  3. Doğal olarak git commit -a -m "" veya git commit -am ""! :]
    2014-06-21 16: 31: 59Z
  4. stash'ın başka bir 'kısayol' kullanımı; Eğer her şeyi serbest bırakmak istiyorsanız (git add 'i geri almak), sadece git stash, sonra git stash pop
    2015-12-08 22: 30: 29Z

Son işlemi değiştirmek için

Dizindeki dosyaları değiştirin:

 
git rm --cached *.class
git add *.java

Öyleyse, özel bir şube ise, taahhüdü değiştirin :

 
git commit --amend

Veya paylaşılan bir şubeyse, yeni bir taahhütte bulunun:

 
git commit -m 'Replace .class files with .java files'


( önceki bir taahhüdü değiştirmek için ) harika etkileşimli rebase'i kullanın )


ProTip ™: Bunu tekrar durdurmak için bir gitignore 'a *.class ekleyin.


Bir taahhütü geri almak için

Son taahhüdü değiştirmeniz gerekirse, bir taahhüdü değiştirmek ideal bir çözümdür, ancak daha genel bir çözüm reset'dur.

Git'i, ile yapılan herhangi bir işleme sıfırlayabilirsiniz:

 
git reset @~N

N’un HEAD’dan önceki taahhüt sayısı ve @~ önceki işlemine sıfırlanır.

Dolayısıyla, taahhüdü değiştirmek yerine, kullanabilirsiniz:

 
git reset @~
git add *.java
git commit -m "Add .java files"

Bunun ne olduğunu daha iyi anlamak için git help reset, özellikle --soft --mixed ve --hard'daki bölümleri inceleyin.

Reflog

Eğer karışırsanız, bırakılan taahhütleri bulmak için her zaman reflog kullanabilirsiniz:

 
$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started


    
724
2017-05-23 12: 03: 09Z
  1. Gelecekte okuyanlar için - lütfen git revert’un ayrı bir komut olduğunu unutmayın; bu, temel olarak tek bir komisyonu 'sıfırlar'.
    2018-08-08 07: 11: 00Z

git revert <commit-id> Kullanın

Taahhüt kimliğini almak için yalnızca git log kullanın

    
612
2018-11-10 09: 36: 11Z
  1. Yanlış şubeye karar verdiyseniz: geri alındıktan sonra doğru şubeye geçin ve isteğinize uygun bir seçim yapın.
    2012-06-27 11: 02: 58Z
  2. Bu ne anlama geliyor, cherry taahhüdü seçiyor mu? Benim durumumda bir dosyayı düzenlediğimde yanlış daldaydım. Kabul ettim sonra yanlış dalda olduğumu fark ettim. "Git reset --soft HEAD ~ 1" kullanmak, işlemden hemen önce bana geri döndü, ancak şimdi doğru dalı seçtiysem, dosyada yapılan değişiklikleri yanlış dalda nasıl geri alırım ancak bunun yerine bunları (aynı adlandırılmış şekilde) yaparım dosya) doğru şubede?
2015-01-13 22: 05: 57Z
  • git revert commit-id'dan bir cazibe gibi çalıştım. Tabii ki değişikliklerinizi zorlamanız gerekecektir.
    2016-01-25 21: 07: 16Z
  • Bunun git cherry-pick <<erroneous-commit-sha>> @astronomerdave olacağına inanıyorum. Nereden, Bay Neredeyse-2 Yıl-Geç-Partiye.
    2016-10-20 18: 19: 50Z
  • @ Kris: Vişne toplama kullanımı yerine rebase. Çünkü gelişmiş kiraz toplama
    2018-11-10 09: 38: 58Z
  • Eğer yerel bir taahhüdün tamamını geri almayı planlıyorsanız, taahhüdünüzde yaptığınız her şeyi değiştirdiyseniz ve bu konuda endişelenmiyorsanız, sadece aşağıdaki komutu uygulayın.

     
    git reset --hard HEAD^1
    

    (Bu komut tüm taahhüdünüzü görmezden gelecek ve değişiklikleriniz yerel çalışma ağacınızdan tamamen kaybolacak). Taahhüdünüzü geri almak istiyorsanız, ancak aşama alanındaki değişikliklerinizi (git add'dan sonra da yapmadan önce) istiyorsanız, aşağıdaki komutu uygulayın.

     
    git reset --soft HEAD^1
    

    Artık taahhütlü dosyalarınız hazırlama alanına geliyor. Bazı yanlış içerikleri düzenlemeniz gerektiğinden, dosyaları büyütmek istiyorsanız, aşağıdaki komutu uygulayın

     
    git reset HEAD
    

    Şimdi, aşamalı alandan sıralanmamış alana gelmek için dosyalar işlendi. Artık dosyalar düzenlemeye hazır, bu nedenle neyi değiştirirseniz düzeltmek ve eklemek ve yeni /yeni bir işlem yapmak istersiniz.

    Daha fazla

        
    494
    2018-09-28 08: 43: 59Z
    1. @ SMR, Örneğinizde, hepsi yalnızca geçerli HEAD'e işaret ediyor. HEAD ^ = HEAD ^ 1. Hem de HEAD ^ 1 = HEAD ~ 1. HEAD ~ 2 kullandığınızda, ~ ve ^ sembolleri arasında bir fark vardır. Eğer ~ 2 kullanıyorsanız “ilk ebeveyni ilk ebeveyni” veya “büyük ebeveyn” anlamına gelir.
      2015-12-14 15: 34: 11Z

    Yüklü Git Ekstraları varsa, en son işlemi geri almak için git undo çalıştırabilirsiniz. git undo 3, son 3 taahhüdü geri alır.

        
    466
    2011-12-13 10: 18: 31Z

    Paylaşılan havuzumuzdaki en son 5 taahhüdü geri almak istedim. Geri almak istediğim revizyon kimliğine baktım. Sonra aşağıdakini yazdım.

     
    prompt> git reset --hard 5a7404742c85
    HEAD is now at 5a74047 Added one more page to catalogue
    prompt> git push origin master --force
    Total 0 (delta 0), reused 0 (delta 0)
    remote: bb/acl: neoneye is allowed. accepted payload.
    To git@bitbucket.org:thecompany/prometheus.git
     + 09a6480...5a74047 master -> master (forced update)
    prompt>
    
        
    433
    2012-04-06 13: 58: 52Z
    1. Paylaşılan bir depoda geçmişin yeniden yazılması genellikle çok kötü bir fikirdir. Ne yaptığınızı bildiğinizi varsayıyorum, umarım gelecek okuyucular da yapar.
      2012-12-07 16: 02: 12Z
    2. Evet geri alma tehlikelidir. Basmadan önce çalışma kopyanızın istenen durumda olduğundan emin olun. İtildiğinde, istenmeyen gönderiler kalıcı olarak silinir.
      2012-12-08 14: 14: 43Z
    3. "Tıpkı gerçek dünyada olduğu gibi, tarihi yeniden yazmak istiyorsanız, bir komploya ihtiyacınız var: herkes komploda 'içinde olmak zorunda' (en azından tarih hakkında bilen herkes, yani; şimdiye dek daldan çekildi. " Kaynak: stackoverflow.com/a/2046748/334451
      2013-08-07 10: 10: 25Z

    Bu iş için git rebase -i'u kullanmayı tercih ediyorum, çünkü kurtulmak için gerekenleri seçebileceğim güzel bir liste çıkıyor. Buradaki diğer bazı cevaplar kadar doğrudan olmayabilir, ancak yalnızca doğru hissediyor .

    Kaç tane listelemek istediğinizi seçin, sonra bu şekilde çağırın (son üçü listelemek için)

     
    git rebase -i HEAD~3
    

    Örnek liste

     
    pick aa28ba7 Sanity check for RtmpSrv port
    pick c26c541 RtmpSrv version option
    pick 58d6909 Better URL decoding support
    

    Ardından Git, kaldırdığınız tüm satırların taahhütlerini kaldırır.

        
    412
    2018-12-06 21: 59: 20Z

    Önceki yerel görevin nasıl düzeltileceği

    git commit --amend gerçekleştirmek için git-gui (veya benzeri) kullanın. GUI'den, tek tek dosyaları işleme ekleyebilir veya kaldırabilirsiniz. İleti mesajını da değiştirebilirsiniz.

    Önceki yerel taahhüdü nasıl geri alırsınız

    Şubenizi önceki konumuna sıfırlayın (örneğin, gitk veya git rebase kullanarak). Ardından, değişikliklerinizi kaydedilmiş bir kopyadan tekrar uygulayın. Yerel deponuzdaki çöp toplama işleminden sonra, hiç olmamış istenmeyen bir taahhüt gibi olacak. Bunların hepsini tek bir komutta yapmak için git reset HEAD~1'u kullanın.

    Uyarı kelimesi : git reset'un dikkatsiz kullanımı, çalışma kopyanızı karıştırıcı bir duruma getirmenin iyi bir yoludur. Git acemilerinin eğer yapabilirlerse bundan kaçınmasını öneririm.

    Genel bir taahhüt nasıl geri alınır

    Bir ters kiraz seçimini yapın ( git-revert ) değişiklikleri geri almak için.

    Şubenize henüz başka değişiklikler yapmadıysanız, basitçe yapabilirsiniz ...

     
    git revert --no-edit HEAD
    

    Ardından güncellenmiş şubenizi paylaşılan havuza doğru itin.

    Taahhüt tarihi, her iki taahhüdü de ayrı olarak gösterir .


    Gelişmiş: Genel depodaki özel şubesinin düzeltilmesi

    Bu tehlikeli olabilir - şubenin yerel bir kopyasının elinizde olduğundan emin olun.

    Ayrıca not: Başka biri şube üzerinde çalışıyorsa bunu yapmak istemezsiniz.

     
    git push --delete (branch_name) ## remove public version of branch
    

    Şubenizi yerel olarak temizleyin, sonra yeniden düzenleyin ...

     
    git push origin (branch_name)
    

    Normal durumda, özel şubenizin işleme geçmişinin bozulmamış olması konusunda endişelenmenize gerek yoktur. Bir takip taahhüdünü zorlamanız yeterli (yukarıdaki 'Kamu taahhüdünü geri alma' başlığına bakın) ve daha sonra bir squash-birleştirme yapın geçmişi gizlemek için.

        
    398
    2018-12-07 05: 57: 27Z
    1. gitk --all $(git reflog | cut -c1-7)&, bir '--amend' taahhüdünü geri almak istiyorsanız önceki düzeltmeyi bulmakta yardımcı olabilir.
      2014-10-18 23: 38: 11Z
    2. Paylaşılan bir depoya göndermeden önce gizli bilgileri silmeye çalışıyorsanız, geri dönmenin size yardımcı olmayacağı, çünkü bilgilerin hala devam edemeyeceği belirtilmelidir. önceki taahhütte tarihin içinde olmak. Değişikliğin başkaları tarafından hiçbir zaman görünür olmadığından emin olmak istiyorsanız, git reset kullanmanız gerekir
      2015-09-04 04: 52: 01Z
    3. 2016-04-05 04: 20: 04Z
    4. 'özel' /'genel' in daha 'yerel' /'uzak' olacağını düşünüyorum.
      2018-03-28 14: 59: 27Z
    5. Uzak depodaki özel bir şubeyi düzeltmek de sadece git push origin (branch_name) --force ile yapılabilir.
      2018-09-07 12:09: 38Z

    Önemsiz davrandıysanız ancak itmediyseniz

     
    git reset --soft HEAD~1
    
      

    HEAD ~ 1 , başkanlık öncesi taahhüt için bir kestirme yoludur. Alternatif olarak, sıfırlamak istiyorsanız, karma değerin SHA-1 bölümüne bakabilirsiniz. --soft seçeneği, taahhüdü silecek ancak git durumunun koyacağı şekilde, değiştirilen tüm dosyalarınızı "Taahhüt edilecek değişiklikler" olarak bırakacak.

         

    Çalışma ağacındaki izlenen dosyalarda yapılan değişikliklerden kurtulmak istiyorsanız, işlem yapmadan önce " --hard " komutunu kullanın.

    VEYA

      

    Zaten itti ve birileri çektiğinizde, genellikle benim durumum, git reset kullanamazsınız. Ancak bir git dönüşü ,

    yapabilirsiniz.
     
    git revert HEAD
    
      

    Bu, yanlışlıkla yapılan taahhüdün getirdiği her şeyi tersine çeviren yeni bir taahhüt oluşturacaktır.

        
    319
    2014-09-25 07: 58: 25Z
    1. 2. durumdayım, ancak "git HEAD" yazdığımda "error: Commit [ID] bir birleştirmedir, ancak -m seçeneği yoktu verilen: ölümcül: geri alma başarısız oldu ". Herhangi bir öneriniz var mı?
      2014-11-12 19: 36: 02Z
    2. Muhtemelen, HEAD~1 yerine, git log --stat veya git reflog tarafından görüntülenen şekilde gerçek hash'ı kullanabileceğinizi belirtmelisiniz - birden fazla işlemi geri almanız gerektiğinde kullanışlıdır.
      2014-12-07 00: 38: 49Z

      Kalıcı olarak geri almak istiyorsanız ve bazı havuzları klonladıysanız

      Onay kimliği,

      tarafından görülebilir.  
      git log 
      

      Sonra yapabilirsin -

       
      git reset --hard <commit_id>
      
      git push origin <branch_name> -f
      
          
      316
      2015-06-24 09: 34: 15Z
      1. "< commit_id >" kullanmazsanız ve sadece "git reset --hard" kullanın? Genelde henüz tamamlamadığım ve yaptığım son işleme geri döndüğüm son güncellemelerimden kurtulmak istiyorum ve her zaman "git reset --hard" komutunu kullanıyorum.
        2017-09-27 23: 30: 18Z
      2. @ JaimeMontoya En son değişiklikleri geri almak için git reset --hard kullanabilirsiniz, ancak son "n" ifadesini zorla kaldırmanız gerekiyorsa bir SHA belirtmelisiniz
        2017-09-28 13: 10: 31Z

      SourceTree 'de (GitHub için GUI), taahhüdü sağ tıklayıp bir' Tersine Teslim Al 'yapabilirsiniz. '. Bu, değişikliklerinizi geri almalı.

      Terminalde:

      Alternatif olarak kullanabilirsiniz:

       
      git revert
      

      Veya:

       
      git reset --soft HEAD^ # Use --soft if you want to keep your changes.
      git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.
      
          
      269
      2015-06-24 09: 34: 11Z

      Tek bir komut:

       
      git reset --soft 'HEAD^' 
      

      Son yerel taahhüdü geri almak için harika çalışıyor!

          
      250
      2014-07-21 20: 13: 34Z
      1. Git reset - soft "HEAD ^" 'ı çift tırnaklı yazmam gerekiyordu çünkü Windows komut isteminden yazdım.
        2014-04-23 09: 13: 35Z
      2. Tırnak işaretleri olmadan çalışmalı.
        2016-11-10 19: 19: 44Z

      Yalnızca git kullanarak aşağıdaki komutu kullanarak sıfırlayın:

       
      git reset --soft HEAD~1
      

      Açıkla: git reset’un yaptığı, temelde geri dönmek istediğiniz herhangi bir taahhüt için reset’dur, sonra --soft anahtarla birleştirirseniz geri döner, ancak değişiklikleri dosya (lar) ınız, böylece dosyanın eklendiği aşamaya geri dönersiniz, HEAD şubenin başıdır ve ~1 ile birleştirirseniz (bu durumda HEAD^ da kullanırsınız), yalnızca bir işleme geri döner hangisini istiyorsan ...

      Gerçek durumlarda oluşabilecek tüm adımlar ve kodun işlenmesi dahil, aşağıdaki resimdeki adımları sizin için daha ayrıntılı olarak oluşturuyorum:

       Git'teki son taahhütleri nasıl geri alabilirim?

          
      241
      2017-10-27 12: 46: 34Z

      Son Git taahhüdünü nasıl geri alabilirim?

      Her şeyi, son işlemden önceki haline geri döndürmek için, HEAD'den önceki göreve sıfırlamamız gerekir.

      1. Yaptığınız değişikliklerinizi korumak istemiyorsanız:

         
        git reset --hard HEAD^
        
      2. Değişikliklerinizi korumak istiyorsanız:

         
        git reset --soft HEAD^
        

      Şimdi git günlüğünüzü kontrol edin. Son taahhüdümüzün kaldırıldığını gösterecektir.

          
      223
      2017-03-25 08: 14: 01Z

      Doğru durumu bulmak için reflog kullanın

       
      git reflog
      

      önce reflog SIFIRLA ÖNCELEME

      Doğru reflog'u seçin (benim durumumda f3cb6e2) ve yazın

       
      git reset --hard f3cb6e2
      

      Bundan sonra repo HEAD bu HEADid’e sıfırlanır efekti sıfırla SIFIRLA SONRA GİRİŞ

      Sonunda reflog aşağıdaki resme benziyor

      sonra tekrar REFLOG FINAL

          
      180
      2014-01-06 22: 34: 06Z

      "Çalışma ağacını son işlemeye sıfırla"

       
      git reset --hard HEAD^ 
      

      "Çalışma ağacındaki bilinmeyen dosyaları temizle"

       
      git clean    
      

      bkz. - Git Hızlı Referansı

      NOT: Bu komut önceki taahhüdünüzü siler, bu nedenle dikkatli kullanın! git reset --hard daha güvenlidir -

          
      173
      2017-12-13 22: 04: 48Z

      İlk çalıştırma:

       
      git reflog
      

      Size, deponuzda gerçekleştirdiğiniz tüm olası eylemleri gösterir; örneğin, taahhüt, birleştirme, çekme, vb.

      Öyleyse yapın:

       
      git reset --hard ActionIdFromRefLog
      
          
      156
      2015-06-24 09: 33: 20Z

      Son işlemi geri al:

      git reset --soft HEAD^ veya git reset --soft HEAD~

      Bu son işlemi geri alır.

      Burada --soft, aşamaya sıfırlama anlamına gelir.

      HEAD~ veya HEAD^, HEAD'den önce taahhütte bulunmak demektir.


      Yeni taahhüdün son taahhüdünü değiştirin:

       
      git commit --amend -m "message"
      

      Son taahhüdü yeni taahhütle değiştirecek.

          
      148
      2017-12-13 22: 05: 20Z

      Başka bir yol:

      Geri almak istediğiniz şubeye göz atın, ardından yerel çalışan kopyanızı uzak sunucudaki en yeni olmak istediğinize geri döndürün (her şeysonra güle güle gidecek). Bunu yapmak için SourceTree'de sağ tıklayıp "BRANCHNAME ürününü bu işleme sıfırla" seçeneğini seçtim.

      Ardından havuzunuzun yerel dizinine gidin ve şu komutu çalıştırın:

       
      git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME
      

      Bu, yerel deponuzdaki mevcut olandan sonraki tüm taahhütleri siler ancak yalnızca bu dal için silinir.

          
      143
      2015-06-24 09: 34: 21Z

      git log yazın ve son işlem karma kodunu bulun ve ardından şunu girin:

       
      git reset <the previous co>
      
          
      134
      2015-06-24 09: 34: 18Z

      Benim durumumda yanlışlıkla istemediğim bazı dosyalar işledim. Bu yüzden aşağıdakileri yaptım ve işe yaradı:

       
      git reset --soft HEAD^
      git rm --cached [files you do not need]
      git add [files you need]
      git commit -c ORIG_HEAD
      

      Sonuçları gitk veya git log --stat

      ile doğrulayın.     
      130
      2015-06-24 09: 34: 09Z

      Basit, bunu komut satırınızda çalıştırın:

       
      git reset --soft HEAD~ 
      
          
      121
      2016-01-18 21: 58: 33Z

      Bunu yapmanın birçok yolu vardır:

      Son taahhüt /önceki taahhütleri geri almak için Git komutu:

      Uyarı: Ne yaptığınızı bilmiyorsanız --hard kullanmayın. --hard çok tehlikelidir ve dosyalarınızı silebilir.

      Git'teki taahhüdün geri alınmasına ilişkin temel komut şudur:

       
      $ git reset --hard <COMMIT -ID>
      

      veya

       
      $ git reset --hard HEAD~<n>
      

      COMMIT-ID : Taahhüdün kimliği

      n: , geri almak istediğiniz son işlemin sayısıdır

      Taahhüt kimliğini aşağıda gösterildiği gibi alabilirsiniz:

       
      $ **git log --oneline**
      
      d81d3f1 function to subtract two numbers
      
      be20eb8 function to add two numbers
      
      bedgfgg function to mulitply two numbers
      

      burada d81d3f1 ve be20eb8 işlem kimliğidir.

      Şimdi bazı vakaları görelim:

      Son işlem olan 'd81d3f1'i geri almak istediğinizi varsayalım. İşte iki seçenek:

       
      $ git reset --hard d81d3f1
      

      veya

       
      $ git reset --hard HEAD~1
      

      'be20eb8' taahhüdünü geri almak istediğinizi varsayalım:

       
      $ git reset --hard be20eb8
      

      Daha ayrıntılı bilgi için, kafasını belirtilen bir duruma sıfırlamak için de başka komutları başvurabilir ve deneyebilirsiniz:

       
      $ git reset --help
      
          
      119
      2018-08-19 14: 00: 16Z
      1. git reset --hard HEAD~1 çok tehlikeli ! Bu sadece “son taahhüdü iptal etmeyecek” değil, repoyu bir önceki işleme geri döndürecek. Böylece, son taahhüdde taahhüt edilen tüm değişiklikleri KAYBOLACAKSINIZ!
        2017-03-21 12: 09: 47Z
      2. Haklısınız, bunu geri almak için git push -f <remote> HEAD@{1}:<branch> kullanabilirsiniz
        2017-04-24 13: 07: 03Z
      3. Maalesef --hard kullanıyorum ve dosyalarım silindi! İlk önce yorumu kontrol etmedim, çünkü çöktü. Ne yaptığınızı bilmiyorsanız --hard kullanmayın!
        2018-08-19 13: 53: 17Z

      Yerel bir taahhüt için

       
      git reset --soft HEAD~1
      

      veya hangi taahhüdün tam olarak ne olduğunu hatırlamıyorsanız, kullanabilirsiniz

       
      git rm --cached <file>
      

      İtilmiş bir işlem için

      Dosyaları depo geçmişinden kaldırmanın doğru yolu git filter-branch kullanmaktır. Bu,

       
      git filter-branch --index-filter 'git rm --cached <file>' HEAD
      

      Ama bu komutu dikkatle kullanmanızı tavsiye ederim. Daha fazla bilgi için git-filter-branch (1) Kılavuz Sayfası .

          
      117
      2014-07-21 20: 15: 08Z

      İki ana senaryo var

      Henüz taahhüdü atmadınız

      Sorun, eklediğiniz ek dosyalarsa (ve bunları depoda istemiyorsanız), git rm'u kullanarak ve sonra --amend'u işleyerek bunları kaldırabilirsiniz

       
      git rm <pathToFile>
      

      -r ile tüm dizinleri kaldırabilir veya hatta diğer Bash komutlarıyla birleştirebilirsiniz

       
      git rm -r <pathToDirectory>
      git rm $(find -name '*.class')
      

      Dosyaları kaldırdıktan sonra, --amend seçeneğiyle > işlem yapabilirsiniz.  

      git commit --amend -C HEAD # the -C option is to use the same commit message
      

      Bu, fazladan dosyaların kaldırılmasıyla ilgili son yerel taahhüdünüzü yeniden yazacaktır; bu nedenle, bu dosyalar hiçbir zaman anında gönderilmeyecek ve aynı zamanda yerel .git deponuzdan GC tarafından kaldırılacaktır.

      Taahhüdü zaten zorladınız

      Diğer senaryonun aynı çözümünü uygulayabilir ve ardından git push seçeneğiyle -f seçeneğini uygulayabilirsiniz, ancak uzak tarihin üzerine farklı bir değişiklikle yazdığından (bu işlem, havuzunuzu bozabileceği için önerilmez) ).

      Bunun yerine, işlemi --amend olmadan yapmanız gerekir (-amend` hakkında şunu unutmayın): Bu seçenek, tarihi son işlemin üzerine yazar.)

          
      117
      2016-01-11 23: 50: 47Z

      Önceki revizyona sıfırlamak için, tüm taahhüt edilmemiş değişiklikleri kalıcı olarak silin:

       
      git reset --hard HEAD~1
      
          
      117
      2016-09-16 07: 25: 01Z
      1. Belki de komutunun daha fazla bir şey sormadan ve çalışma dizinindeki değişiklikleri yerine getireceğini belirten bir not /uyarı verebilirsiniz.
        2014-11-24 22: 35: 29Z
      2. 2014-11-24 22: 40: 57Z
      3. Değişikliklerinizi --soft, uncommitted changes olarak tutmak için --hard'u kullanın. Bu tür işlemleri yalnızca henüz yapılmayan değişikliklerde yapmayı unutmayın.
        2015-03-09 09: 11: 06Z
      4. @ Zaz: Haklısın; belki de bunu açıklığa kavuşturmalıydım. Yalnızca dizine eklenmiş (/kademeli) veya kaydedilmiş dosyalar /değişiklikler kurtarılabilir. Taahhüt edilmemiş, etiketlenmemiş değişiklikler , , dediğiniz gibi, git reset --hard'da tamamen atıldı.
        2016-09-13 21: 17: 10Z
      5. Bir yazı tipi olarak: Bir dosyanın her aşamasında her 49410, içeriğini nesne veritabanında saklar. Saklanan içerikler sadece çöp toplama işlemi gerçekleştirildiğinde kaldırılır. Bu nedenle, git yürütülürken şu anda hazırlanmamış bir dosyanın en son aşamalı sürümünü kurtarmak mümkündür (daha fazla bilgi için yukarıda verilen yazılara bakın).
        2016-09-13 21: 22: 52Z
      git reset --hard
    kaynak yerleştirildi İşte