41 Soru: Git deposunu önceki bir işleme nasıl geri döndürürüm?

tarafından oluşturulan soru Mon, Jun 10, 2019 12:00 AM

Şu andaki durumumdan belirli bir taahhütte yapılan anlık görüntüye nasıl geri dönerim?

git log yaparsam aşağıdaki çıktıyı alırım:

 
$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <me@me.com>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <me@me.com>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <me@me.com>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <me@me.com>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

3 Kasım’daki taahhüt, yani 0d1d7fc’un taahhüdüne nasıl geri dönülür?

    
6891
  1. İlgili Son Git taahhüdünü nasıl geri alabilirim? .
    2014-05-23 17: 57: 12Z
  2. 2015-06-08 19: 41: 52Z
  3. İlgili: Genel bir depoda eski bir Git işlemine geri dönme . Bu sorunun, deponun genel olduğu konusunda bir sınırlama getirdiğini unutmayın.
    2015-10-19 09: 51: 42Z
  4. Git'i seviyorum, ama son derece basit olması gereken bir şeyin 35 yanıtının olması, git ile ilgili çok büyük bir konuyu ortaya koyuyor. Yoksa dokümanlar mı?
    2018-01-03 22: 26: 59Z
  5. Tarihte SVN benzeri bir düğme işlevi ekleyebilirlerdi
    2018-12-13 18: 29: 31Z
  6. 30 Yanıtlar                              30                         

    Bu, "geri döndürme" ile ne demek istediğinizi çok fazla etkiler.

    Geçici olarak farklı bir işleme geçme

    Geçici olarak ona geri dönmek, etrafta dolaşmak, sonra bulunduğun yere geri dönmek istiyorsan, tek yapman gereken, istenen taahhüde göz atmaktır:

     
    # This will detach your HEAD, that is, leave you with no branch checked out:
    git checkout 0d1d7fc32
    

    Veya oradayken taahhütte bulunmak istiyorsanız, devam edin ve oradayken yeni bir şube oluşturun:

     
    git checkout -b old-state 0d1d7fc32
    

    Bulunduğunuz yere geri dönmek için, bulunduğunuz şubeyi tekrar kontrol edin. (Değişiklikler yaptıysanız, şubeleri değiştirirken her zaman olduğu gibi, onlarla uygun şekilde başa çıkmanız gerekir. Onları atmak için sıfırlayabilirsiniz; saklamak, ödeme yapmak, saklamak için yanınıza almak için saklayabilirsiniz; orada bir şube istiyorsanız onları bir dala.)

    Basılmamış yayınları zor silme

    Öte yandan, o zamandan beri yaptığınız her şeyden gerçekten kurtulmak istiyorsanız, iki olasılık var. Birincisi, bu taahhütlerin hiçbirini yayınlamadıysanız, basitçe sıfırlayın:

     
    # This will destroy any local modifications.
    # Don't do it if you have uncommitted work you want to keep.
    git reset --hard 0d1d7fc32
    
    # Alternatively, if there's work to keep:
    git stash
    git reset --hard 0d1d7fc32
    git stash pop
    # This saves the modifications, then reapplies that patch after resetting.
    # You could get merge conflicts, if you've modified things which were
    # changed since the commit you reset to.
    

    Sıkışırsanız, yerel değişikliklerinizi zaten atmışsınızdır, ancak en azından tekrar sıfırlayarak daha önce bulunduğunuz yere geri dönebilirsiniz.

    Yayınlanan geri al işleminin yeni komisyonlarla taahhütleri

    Diğer yandan, çalışmayı yayınladıysanız, büyük olasılıkla geçmişi yeniden yazdığı için muhtemelen şubeyi sıfırlamak istemezsiniz. Bu durumda, gerçekten taahhütleri geri alabilirsin. Git ile geri alma işleminin çok özel bir anlamı vardır: iptal etmek için ters düzeltme eki ile bir taahhüt oluşturun. Bu şekilde hiçbir tarihi yeniden yazmazsınız.

     
    # This will create three separate revert commits:
    git revert a867b4af 25eee4ca 0766c053
    
    # It also takes ranges. This will revert the last two commits:
    git revert HEAD~2..HEAD
    
    #Similarly, you can revert a range of commits using commit hashes:
    git revert a867b4af..0766c053 
    
    # Reverting a merge commit
    git revert -m 1 <merge_commit_sha>
    
    # To get just one, you could use `rebase -i` to squash them afterwards
    # Or, you could do it manually (be sure to do this at top level of the repo)
    # get your index and work tree into the desired state, without changing HEAD:
    git checkout 0d1d7fc32 .
    
    # Then commit. Be sure and write a good message describing what you just did
    git commit
    

    git-revert manpage aslında açıklamasında bunun çoğunu kapsıyor. Diğer bir yararlı bağlantı ise bu git-scm.com bölümünü tartışıyor. -revert .

    Sonuçta geri dönmek istemediğinize karar verirseniz, geri dönme (burada açıklandığı şekilde) geri dönebilir veya geri dönmeden önceki durumuna dönebilirsiniz (önceki bölüme bakın).

    Bu cevabı bu durumda da yararlı bulabilirsiniz:
    HEAD bir önceki konuma nasıl taşınır? (Ayrılmış kafa)

        
    8799
    2018-04-04 17: 54: 07Z
    1. @ Rod adlı kullanıcının yorumu git revert HEAD~3 taahhüdünü geri almanın en iyi yolu, önemli bir kongre olmam.
      2012-08-22 15: 16: 45Z
    2. Sayının tamamını yazabilir misiniz? gibi: 3
      2012-12-04 13: 58: 13Z
    3. @ MathiasMadsenStav Evet, elbette tam SHA1 tarafından taahhüt belirtebilirsiniz. Cevabı daha okunaklı hale getirmek için kısaltılmış karmaları kullandım ve siz yazarken bunları kullanma eğilimindesiniz. Kopyalayıp yapıştırıyorsanız, kesinlikle tam hash değerini kullanın. Bkz. Adamda Düzeltmeler Belirtme git rev- Adlandırma işlemlerinin tam bir açıklaması için ayrıştırın .
      2012-12-04 16: 55: 52Z
    4. Şu anki durumuna geri dönmek için komut 'git checkout master'
      2013-01-18 00: 33: 26Z
    5. git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50'u kullanabilirsiniz ve bundan sonra her geri dönüşü tek bir işlemle git revert --no-commit hash1 hash2 ...'u uygulayın
      2013-09-24 12: 12: 16Z

    Rogue Coder?

    Kendi kendine çalışmak ve sadece çalışmasını mı istiyorsun? Aşağıdaki talimatları izleyin, benim için ve diğerleri için yıllarca güvenilir bir şekilde çalıştılar.

    Başkalarıyla çalışmak? Git karmaşık. Kızarık bir şey yapmadan önce bu cevabın altındaki yorumları okuyun.

    Çalışma Kopyasını En Yeni Taahhüt'e Geri Döndürme

    Önceki bir işleme geri dönmek için, değişiklikleri dikkate almamak:

     git commit -m "Message"

    şu anki şubenizdeki HEAD’in HEAD’in son halini aldığı yer

    Çalışma Kopyasını Eski Bir Sözleşmeye Geri Alma

    En son işlemden daha eski olan bir işleme geri dönmek için:

     
    git reset --hard HEAD
    

    Krediler, benzer bir Yığın Taşması sorusuna gider, Geri Dön Git’te bir SHA karması için taahhütte bulunmak mı? .

        
    1465
    2019-06-13 02: 36: 39Z
    1. Yaptım, ama sonra uzak havuza bağlanamadım ve zorlayamadım. HEAD olmak için belirli bir eski taahhüdüm olsun istiyorum ...
      2012-09-24 18: 17: 28Z
    2. Bu, geri almak istediğiniz taahhütleri zaten zorladığınız anlamına gelir. Kodunuzu inceleyen ve üzerinde çalışan insanlar için birçok sorun yaratabilir. Taahhüdünüzü yerine getiremediklerinden kendilerine aittirler. Böyle bir durumda daha iyi bir geri dönüş yapmak. Repoyu kullanan tek kişi sizseniz. Git push -f yapın (Ama bunu yapmadan önce iki kez düşünün)
      2012-12-05 04: 51: 51Z
    3. Zorunlu Uyarı: Şubenizi eski taahhütlerin kopyaları olan diğer kişilerle paylaşıyorsanız, zor kullanmayın Bunun gibi bir sert sıfırlama, çalışmalarını yeni sıfırlama dalıyla tekrar senkronize etmeye zorlar. Yazılım sıfırlama işlemi, bu yanıtı içerisindeki son çözümlerin yanı sıra güvenlidir.
      2014-06-28 20: 06: 00Z
    4. Ayrıca, yalnızca ilk önce bir karışık sıfırlama yapmak yerine en son sert bir sıfırlama işlemi yapmak yerine, aslında zor bir işlemi yapabileceğinizi belirtmek istiyorum. önce şu şekilde sıfırlayın:
      # Resets index to former commit; replace '56e05fced' with your commit code
      git reset 56e05fced 
      
      # Moves pointer back to previous HEAD
      git reset --soft HEAD@{1}
      
      git commit -m "Revert to 56e05fced"
      
      # Updates working copy to reflect the new commit
      git reset --hard
      
      .
      2014-06-29 00: 20: 29Z
    5. @ nuton linus, kendisini yaratan, git'in yaratıcısı olan Pauling, onu çok karmaşık olduğu için eleştirdi. Gittiğinde "şok olduğunu" söyledi ve karmaşıklığı göz önüne alındığında çok popüler oldu
      2015-05-18 23: 56: 00Z

    Burada çok sayıda karmaşık ve tehlikeli cevap var, ancak aslında çok kolay:

     git reset --hard 56e05fc; git reset --soft HEAD@{1}; git commit

    Bu, HEAD'den her şeyi geri dönüş karmaşasına geri döndürecek, yani o zamandan beri yürüdüğü her bir taahhütte çalışma ağacındaki o devleti yeniden yaratacak. Daha sonra mevcut ağacı kabul edersiniz ve esasen “geri döndüğünüze” bağlı olarak eşdeğer yeni bir taahhüt oluşturur.

    (

    git revert --no-commit 0766c053..HEAD
    git commit
    
    bayrağı gitmeye tüm taahhütleri bir kerede geri almasına izin verir - aksi halde aralıktaki her bir işlem için bir mesaj göndermeniz istenir, böylece tarihinizi gereksiz yeni taahhütler ile karıştırırsınız.)

    Bu, önceki durumuna geri dönmenin güvenli ve kolay bir yolu . Hiçbir tarih yok edilmedi, bu yüzden zaten halka açıklanmış olan komisyonlar için kullanılabilir.

        
    1458
    2014-06-28 20: 12: 34Z
    1. Gerçekten bireysel taahhütler almak istiyorsanız (her şeyi büyük bir taahhütle geri almak yerine), --no-commit yerine --no-edit'u geçebilirsiniz, böylece Her reversiyon için bir taahhüt mesajı düzenlemek zorundasınız.
      2014-06-28 20: 11: 40Z
    2. 0766c053..HEAD arasındaki işlemlerden biri bir birleştirme ise, açılan bir hata oluşacaktır (no -m belirtilmemişse yapılacak). Bu durumla karşı karşıya kalanlara yardımcı olabilir: stackoverflow.com/questions/5970889/…
      2014-11-21 11: 55: 43Z
    3. İşlem yapmadan önce farkları görmek için --no-commit kullanın.
      2015-11-06 18: 35: 20Z
    4. git diff --cached, $ git revert --no-commit 53742ae..HEAD değerini döndürdü
      2016-08-01 20: 30: 18Z
    5. @ AlexG, çünkü geri dönmek istediğinizden önce bir tane karma kodunu girmeniz gerekir. Benim durumumda, hasheler gibiydi: fatal: empty commit set passed (81bcc9e HEAD{0}; e475924 HEAD{1}, ...'dan) ve git reflog'da yaptığım şeyi geri almak istedim, sonra 81bcc9e yapmak zorunda kaldım
      2017-04-16 14: 22: 51Z

    Benim ve büyük olasılıkla diğerleri için en iyi seçenek Git sıfırlama seçeneğidir:

     git revert e475924..HEAD

    Bu benim için en iyi seçenek oldu! Basit, hızlı ve etkili!


    Not: Şubenizi, eski taahhütlerin kopyaları olan diğer kişilerle paylaşıyorsanız, bunu yapmayın

    Ayrıca yorumlardan, daha az 'ballzy' yöntemini kullanmak istersen kullanabilirsin

    git reset --hard <commidId> && git clean -f
    
        
    184
    2015-07-16 15: 31: 10Z
    1. Zorunlu Uyarı: Şubenizi eski taahhütlerin kopyaları olan diğer kişilerle paylaşıyorsanız, çünkü kullanma Bunun gibi bir sert sıfırlama, çalışmalarını yeni sıfırlama dalıyla tekrar senkronize etmeye zorlar. Sert sıfırlama ile çalışmalarını kaybetmeden işleri nasıl güvenli bir şekilde geri alabileceğinizi ayrıntılı bir şekilde açıklayan bir çözüm için bu cevaba bakın .
      2014-06-28 20: 03: 54Z
    2. Ikinci @ Cupcake'nin uyarısı ... sonuçların farkında olun. Bununla birlikte, ihtiyacınız gerçekten söz konusu taahhütleri geçmişe göre ortadan kaldırmaksa, bu sıfırlama + temizleme yönteminin bunu yapacağını ve zorla için değiştirilmiş dallarınızı herhangi bir yere geri itmeniz gerektiğini unutmayın. tüm uzaktan kumandalar.
      2014-10-29 14: 46: 25Z
    3. git clean -f TEHLİKE TEHLİKE
      2015-07-16 14: 59: 20Z
    4. Bu, yerel kopyamın kafasını istenen işleme ayarlıyor. Ama o zaman hiçbir değişikliği zorlayamam çünkü uzaktan kumanda arkasında. Ve eğer uzaktan kumandadan çekersem, uzaktaki şubedeki en son işlem yapıldığı yere geri dönüyor. Hem yerel basımda basılan birkaç taahhüdü (her yerden) nasıl tamamen yok edebilirim?
      2017-10-22 11: 47: 32Z
    5. @ Ade .. git clean -i bayrağını kullanabilirsiniz .. Ama dikkatli olun, uzaktan kumandayı geçersiz kılar .. Ne yapmak istediğinizi bildiğinizden emin olun ...
      2017-10-23 09: 02: 57Z

    Cevap vermeden önce, bu git push -f’un ne olduğunu açıklayan bir miktar arka plan ekleyelim.

    HEAD

    First of all what is HEAD?, yalnızca geçerli daldaki geçerli işleme (en son) referanstır. Herhangi bir zamanda yalnızca HEAD tane olabilir (HEAD hariç).

    git worktree’un içeriği HEAD’da depolanır ve geçerli taahhüdün 40 bayt SHA-1’ini içerir.


    .git/HEAD

    En son sözde değilseniz - detached HEAD’un tarihteki önceki bir taahhüdü işaret ettiği anlamına gelir, buna HEAD denir.

     Buraya resim açıklaması girin

    Komut satırında şöyle görünür - detached HEAD, geçerli dalın ucuna işaret etmediğinden dal adı yerine SHA-1:

     Buraya resim açıklaması girin


    Ayrılmış bir HEAD'den nasıl kurtarılacağına ilişkin birkaç seçenek:


    HEAD

     git checkout

    Bu, istenen taahhüde işaret eden yeni şubeyi teslim alır. Bu komut verilen bir işlemi teslim alacaktır.

    Bu noktada bir şube oluşturabilir ve bu noktadan itibaren çalışmaya başlayabilirsiniz:

     
    git checkout <commit_id>
    git checkout -b <new branch> <commit_id>
    git checkout HEAD~X // x is the number of commits t go back
    

    # Checkout a given commit.
    # Doing so will result in a `detached HEAD` which mean that the `HEAD`
    # is not pointing to the latest so you will need to checkout branch
    # in order to be able to update the code.
    git checkout <commit-id>
    
    # Create a new branch forked to the given commit
    git checkout -b <branch name>
    

    git reflog'u her zaman da kullanabilirsiniz. reflog, git reflog’u güncelleyen herhangi bir değişikliği gösterecek ve istenen reflog girişini kontrol etmek, HEAD’u bu işleme geri döndürecektir.

    HEAD her değiştirildiğinde, HEAD’da yeni bir giriş olacaktır

     reflog

    Bu sizi istediğiniz taahhüdünüze geri döndürür

     Buraya resim açıklaması girin


    git reflog
    git checkout HEAD@{...}
    

    Kafanı tekrar istediğin işine geri götür.

     git reset HEAD --hard <commit_id>
    • Not: ( Git 2.7’den beri )
      # This will destroy any local modifications.
      # Don't do it if you have uncommitted work you want to keep.
      git reset --hard 0d1d7fc32
      
      # Alternatively, if there's work to keep:
      git stash
      git reset --hard 0d1d7fc32
      git stash pop
      # This saves the modifications, then reapplies that patch after resetting.
      # You could get merge conflicts, if you've modified things which were
      # changed since the commit you reset to.
      
      ’u da kullanabilirsiniz.

    Bu şema hangi komutun ne yaptığını gösterir. Gördüğünüz gibi git rebase --no-autostash, reset && checkout’u değiştirin.

     Buraya resim açıklaması girin

        
    143
    2018-07-04 19: 25: 17Z
    1. HEAD için mükemmel ipucu, tam olarak ihtiyacım olan şey bu
      2016-03-13 21: 25: 01Z
    2. Ouch! Bunların hepsi çok karmaşık görünüyor ... süreçte bir adım geri götüren basit bir komut yok mu? Projenizdeki 1.1 sürümünden sürüm 1.0'a geri dönmek gibi mi? Gibi bir şey bekliyorum: git stepback_one_commit ya da başka bir şey ....
      2016-03-20 14: 35: 15Z
    3. orada: git reflog --hard`
      2016-03-20 14: 38: 43Z
    4. @ Kokodoko Evet, korkunç derecede karmaşıktır ... ve uzmanların yeni başlayanlar için ne kadar az dikkate aldıklarının mükemmel bir örneği. Lütfen buradaki cevabımı ve ayrıca önerdiğim kitaba bakın. Git, sezgisel olarak alabileceğiniz bir şey DEĞİLDİR. Ve kesinlikle CodeWizard'ın yapmadığından emin olabilirim.
      2016-08-29 17: 17: 51Z

    "İzin vermemek" istiyorsanız, son işlem mesajını silin ve değiştirilen dosyaları yeniden yerleştirmeye koyun, şu komutu kullanırsınız:

     git reset HEAD^
    •  
      git reset --soft HEAD~1
      
      , kaydedilmemiş dosyaların --soft'a zıt olarak çalışan dosyalar olarak saklanması gerektiğini belirtir.
    •  --hard son işlemdir. Geri alma işlemini 3 taahhüt etmek istiyorsanız HEAD~1 kullanabilirsiniz. Belirli bir revizyon numarasına geri dönmek istiyorsanız, bunu SHA özetini kullanarak da yapabilirsiniz.

    Bu, yanlış şeyi yaptığınız ve son sözünü geri almak istediğiniz durumlarda oldukça yararlı bir komuttur.

    Kaynak: http://nakkaya.com/2009/09/24/git- silme-son-taahhüt /

        
    125
    2014-03-04 17: 25: 52Z
    1. Bu yumuşak ve naziktir: Çalışmanızı zorlamadıysanız riski yoktur
      2017-01-18 10: 04: 18Z

    Git'teki yerel değişiklikleri geri almak için pek çok yol denedim ve en son taahhüt durumuna geri dönmek istiyorsanız bu en iyi şekilde çalışıyor gibi görünüyor.

     HEAD~3

    Kısa açıklama:

    • git add . && git checkout master -f
      
      ’un yaptığı gibi herhangi bir taahhüt oluşturmaz.
    • git revert’un yaptığı gibi HEAD’inizi çıkarmaz.
    • Tüm yerel değişikliklerinizi geçersiz kılar ve daldaki son işlemden bu yana eklenen tüm dosyaları SİLECEKTİR.
    • Yalnızca dal adları ile çalışır, bu nedenle yalnızca bu daldaki en son işleme geri dönebilirsiniz.

    Yukarıdaki sonuçları elde etmenin çok daha kolay ve basit bir yolunu buldum:

     git checkout <commithashcode>

    HEAD'in en son çalıştığınıza işaret ettiği yer şu anki şubenize bağlıdır.

    Boulder_ruby'nin önerdiği kod koduyla aynı, ancak

    git add . && git reset --hard HEAD
    
    'dan önce git add .'u ekledim, ancak son işlemden bu yana oluşturulan tüm yeni dosyaları silmek için git reset --hard HEAD'u daha önce ekledim.     
    105
    2014-06-24 20: 08: 20Z

    Bunu aşağıdaki iki komutla yapabilirsiniz:

     
    git reset --hard [previous Commit SHA id here]
    git push origin [branch Name] -f
    

    Önceki Git taahhüdünüzü kaldıracaktır.

    Değişikliklerinizi korumak istiyorsanız, şunları da kullanabilirsiniz:

     
    git reset --soft [previous Commit SHA id here]
    

    Sonra değişikliklerinizi kaydeder.

        
    99
    2016-07-03 06: 30: 27Z
    1. Bu yazıda bu mesaja kadar 1/2 bir düzine cevap denedim ... diğerlerinin tümü, git config denemeye çalışırken bana hata vererek devam etti it. Bu cevap işe yaradı. Teşekkürler!
      2016-09-16 19: 47: 15Z
    2. Benim için bir detay, farklılıkları kaybettim .. ki bu işe yaramadı. Bu yüzden bir dahaki sefere bu sıfırlama komutunu vermeden önce sadece bu verileri kaydederdim
      2016-09-16 19: 49: 36Z
    3. Kötü bir birleşmeyi geri almamın tek yolu buydu, geri döndürme bu durumda işe yaramadı. Teşekkürler!
      2017-01-19 20: 07: 19Z

    Tamam, git önceki işine geri dönmek oldukça kolaydır ...

    Değişiklikleri sürdürmeden geri dönün:

     
    git reset --hard <commit>
    

    Değişiklikleri koruyarak geri dönün:

     
    git reset --soft <commit>
    

    Açıkla: git reset'i kullanarak, belirli bir duruma sıfırlayabilirsiniz, yukarıda gördüğünüz gibi kesin bir karmaşayla kullanılması yaygındır.

    Ancak farkı gördüğünüz gibi --soft ve --hard iki bayrağı, varsayılan olarak git reset bayrağı kullanarak --soft'u kullanıyor, ancak her zaman bayrağı kullanarak iyi bir uygulama, her bayrağı açıklıyorum:


    - Yumuşak

    Açıklandığı gibi varsayılan bayrak, onu sağlamanız gerekmez, çalışma ağacını değiştirmez, ancak tüm değişiklikleri dosyaları çalışmaya hazır ekler, böylece dosyalarda yapılan değişikliklerin etiketlenmemiş olduğu işlem durumuna geri dönersiniz.


    - Sabit

    Bu bayrakla dikkatli olun, çalışma ağacını ve izlenen dosyalarda yapılan tüm değişiklikleri sıfırlar ve tümü kaybolur!


    Ayrıca git ile çalışan gerçek hayatta gerçekleşebilecek aşağıdaki resmi de oluşturdum:

     git bir göreve sıfırla

        
    65
    2019-02-05 13: 24: 37Z

    Buradaki birleşimden başka hiçbir şey burada işe yaramadı:

     
    git reset --hard <commit_hash>
    git push origin <branch_name> --force
    

    Buradaki anahtar zorlamayı zorluyor, fazladan taahhüt /mesaj yok vb.

        
    59
    2018-04-23 01: 47: 59Z
    1. Bu benim için işe yaradı, ancak donanım sıfırlamasından sonraki tüm işlem geçmişi kaybolduğu ve bu işlem geri alınamadığı için dikkatli olmanız gerekiyor. Ne yaptığınızdan emin olmanız gerekir.
      2018-04-19 19: 34: 15Z

    ~/commits-to-revert.txt adlı bir metin dosyasında aşağıdaki taahhütlerin bulunduğunu söyleyin (bunları almak için git log --pretty=oneline kullandım)

     
    fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
    0c27ecfdab3cbb08a448659aa61764ad80533a1b
    f85007f35a23a7f29fa14b3b47c8b2ef3803d542
    e9ec660ba9c06317888f901e3a5ad833d4963283
    6a80768d44ccc2107ce410c4e28c7147b382cd8f
    9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
    fff2336bf8690fbfb2b4890a96549dc58bf548a5
    1f7082f3f52880cb49bc37c40531fc478823b4f5
    e9b317d36a9d1db88bd34831a32de327244df36a
    f6ea0e7208cf22fba17952fb162a01afb26de806
    137a681351037a2204f088a8d8f0db6e1f9179ca
    

    Her birini geri almak için bir Bash kabuk betiği oluşturun:

     
    #!/bin/bash
    cd /path/to/working/copy
    for i in `cat ~/commits-to-revert.txt`
    do
        git revert $i --no-commit
    done
    

    Bu, dosya ve dizin oluşturma ve silme işlemleri de dahil olmak üzere her şeyi önceki durumuna döndürür, şubenize teslim eder ve geçmişi korursunuz, ancak aynı dosya yapısına geri döndürürsünüz. Git'in neden git revert --to <hash>'u alamadığı benden.

        
    57
    2014-06-29 00: 13: 03Z
    1. Son 3 komisyonu kaldırmak için git revert HEAD~3 yapabilirsin
      2012-02-19 18: 59: 22Z
    2. @ Rod - Hayır, doğru değil. Bu komut, HEAD'in üçüncü büyük dedesi olan (son üç komisyon değil) taahhüdünü geri döndürecektir.
      2012-09-11 22: 13: 05Z
    3. @ kflorence Bilgi için teşekkürler. git revert -n master~3..master~1 çalışır mı? ( kernel.org/pub/software/adresinden görüldüğü gibi) scm /git /docs /git-revert.html )
      2012-09-12 01: 59: 58Z
    4. @ Rod - Kulağa doğru geliyor, kesinlikle çirkin bir sözdizimi olsa da değil mi? Her zaman "geri almak" istediğim taahhüdü kontrol ettikten sonra bunu daha sezgisel hale getirdiğimi öğrendim.
      2012-10-01 01: 12: 03Z
    5. Bunu şimdi yapmanın çok daha kolay bir yolu, bunun gibi bir komut dosyasından çok, daha fazla git revert --no-commit <start>..<end> kullanın çünkü git revert yeni bir işlem aralığı kabul etti (veya tümü?) Git sürümleri. Aralığın başlangıcının geri dönüme dahil edilmediğini unutmayın.
      2014-06-28 20: 02: 39Z

    Jefromi'nin Çözümlerine Ekstra Alternatifler

    Jefromi'nin çözümleri kesinlikle en iyileridir ve kesinlikle kullanmalısınız. Bununla birlikte, bütünlük uğruna, aynı zamanda bir taahhüdün geri alınmasında kullanılabilecek diğer alternatif çözümleri de göstermek istedim ( önceki taahhütte değişiklikleri geri alan yeni bir taahhüt oluşturmuş olmanız anlamında), Tıpkı git revert’un yaptığı gibi).

    Açıkçası, bu alternatifler işleri geri almanın en iyi yolu değildir , Jefromi'nin çözümleri , ancak yalnızca git revert'la aynı şeyi elde etmek için bu diğer yöntemleri de kullanabileceğinizi belirtmek istiyorum.

    Alternatif 1: Sert ve Yumuşak Sıfırlamalar

    Bu, Charles Bailey'nin çözümünün Git’te bir SHA karması sözüne geri dönülsün mü? :

     
    # Reset the index to the desired commit
    git reset --hard <commit>
    
    # Move the branch pointer back to the previous HEAD
    git reset --soft HEAD@{1}
    
    # Commit the changes
    git commit -m "Revert to <commit>"
    

    Bu, temel olarak yumuşak sıfırlamaların, daha sonra yapabileceğiniz endeks /aşamalama alanında önceki işlemin durumunu bırakacağı gerçeğini kullanarak çalışır.

    Alternatif 2: Geçerli Ağacı Sil ve Yenisiyle Değiştir

    Bu çözüm svick'in çözümünden Eski bir ödeme yapın ve yeni bir işlem yapın :

     
    git rm -r .
    git checkout <commit> .
    git commit
    

    Alternatif # 1'e benzer şekilde, bu geçerli çalışma kopyasındaki <commit> durumunu yeniden üretir. Önce git rm yapılması gerekir, çünkü git checkout, <commit>’dan bu yana eklenen dosyaları kaldırmaz.

        

    56
    2017-05-23 11: 47: 32Z
    1. Alternatif 1 hakkında, hızlı bir soru: Bunu yaparak komisyonlar arasında kaybedilmeyiz değil mi?
      2014-12-02 10: 14: 33Z
    2. Alternatif 2'de, noktalar bu komutlarda ne anlama geliyor?
      2014-12-02 10: 21: 40Z
    3. @ Bogac - noktalar bir dosya yolunu gösterir, bu durumda geçerli dizin, bu nedenle çalışma kopyanızın kökünden çalıştırdığınız varsayılır.
      2014-12-02 19: 06: 38Z
    4. Uyarı yanıtta birkaç kez tekrarlandı, ancak birisi neden bunların en iyi yol değil olduğunu ekleyebilir mi? - @ Cascabel'in (@ Jefromi's) bağlantılı çözümünden elde edilen git revert HEAD~2..HEAD gibi bir şeyle karşılaştırıldı. Sorunu göremiyorum.
      2018-12-28 02: 16: 08Z

    Ana ve söz konusu dalda konuştuğunuzu varsayalım (bu, ilgilendiğiniz herhangi bir çalışma dalı olabilir):

     
    # Reset local master branch to November 3rd commit ID
    git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
    
    # Reset remote master branch to November 3rd commit ID
    git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master
    

    Bir blog postasındaki cevabı buldum (artık mevcut değil)

    Bunun uzaktan kumandadaki Değişikliği Sıfırlama ve Zorlama olduğuna dikkat edin, böylece ekibinizdeki diğer kişiler zaten giderse, onlar için sorunlara yol açacaksınız. Değişim geçmişini yok ediyorsunuz, bu da insanların gitmeyi ilk etapta kullanmasının önemli bir nedeni.

    Geri döndürme kullanmak (diğer cevaplara bakın) sıfırlamaktan daha iyidir. Tek kişilik bir takımsanız, o zaman önemli değil.

        
    56
    2019-04-28 19: 59: 43Z
    1. Bu cevabın diğerlerinden sayısız olandan farkı nedir?
      2016-05-10 17: 46: 51Z
    2. Bağlantı koptu.
      2016-07-03 10: 59: 27Z
    3. Bu talihsiz bir durum. Blogcuya e-posta gönderdim - umarım hala ondadır!
      2016-07-04 19: 29: 37Z
    4. @ Peter #brokenlink web.archive.org/web/20150411085146/http://lrotherfield.com/blog/…
      2016-09-01 17: 51: 49Z
    5. Push sözdizimi, bunun nasıl düzeltileceği konusunda diğer birçok öneride eksik. Harika çalıştı.
      2017-03-24 16: 20: 56Z

    İşte önceki bir işinize geri dönmenin (ve istediğiniz şekilde yapmadan, kararsız bir durumda olmasını sağlamanın) çok daha basit bir yolu:

     
    git reset HEAD~1
    

    Öyleyse, iddaa vb. işlemeye gerek yok :)

        
    51
    2016-07-03 10: 56: 38Z
    1. işe yaramadı, bu verimden sonra gitmeye başladı: error: Aşağıdaki dosyalara yaptığınız yerel değişikliklerin birleştirme işlemi üzerine yazılacağı:
      2016-11-05 00: 21: 33Z
    2. @ malhal Bu, istenmeyen değişikliklerin olmasından kaynaklanıyor. Onları sakla /sıfırla sonra bu hata olmadan çalışacaktır.
      2017-01-22 13: 37: 38Z

    Tüm değişikliklerden sonra, bu komutların tümüne bastığınızda, şunları kullanmanız gerekebilir:

     
    git push -f ...
    

    Ve yalnızca git push değil.

        
    34
    2013-09-28 19: 07: 07Z
    1. Zorunlu Uyarı: Şubenizi eski taahhütlerin kopyaları olan diğer kişilerle paylaşıyorsanız, çünkü kullanma Bunun gibi bir zorlama, çalışmalarını yeniden senkronize etmeye zorlar. Zorla ivedilikle çalışmalarını kaybetmeden işleri nasıl güvenli bir şekilde geri alacağınızı ayrıntılı olarak açıklayan bir çözüm için bu cevaba bakın .
      2014-06-28 20: 00: 19Z
    2. Bazen istediğiniz budur. Örnek: birkaç dalın taahhüdünü kabul etti ve yanlış şubeye itti (şube A). B dalına kiraz topladıktan sonra, bu komisyonların A dalından kaldırılmasını istiyorum. Geri dönmek istemiyorum, çünkü daha sonra dal A ve B birleştirildiğinde birleştirilir. Sıfırlama yapmak - hard < commitId > A dalında bir zorla itme işleminin ardından, bu dalları, B dalında korurken bu dallardan kaldırır, bununla kaçabilirim, çünkü A dalında başka kimsenin gelişmediğini biliyorum.
      2014-10-22 20: 44: 19Z
    3. Teşekkürler! Uzak şubenin yerel şubemle eşleşmesini nasıl sağlayabileceğimi bulamadım, Zorla zorlama yapmanız gerekiyordu.
      2017-02-06 12: 49: 58Z

    Bir komut var (Git'in çekirdeğinin bir parçası değil ama özellikle git-extras paketinde) eski taahhütleri geri almak ve düzenlemek için:

     
    git back
    

    man sayfası uyarınca, bu şekilde de kullanılabilir:

     
    # Remove the latest three commits
    git back 3
    
        
    34
    2014-06-28 20: 19: 45Z

    Tüm bu başlangıç ​​adımlarını kendiniz tamamlayabilir ve gitepo.

    1. Deponuzun en son sürümünü Bitbucket’ten Bitbucket’ten çekin.  git pull --all komutu.

    2. Git log komutunu -n 4 ile terminalden çalıştırın. -N'den sonraki sayı, yerel geçmişinizdeki en son işlemden başlayarak günlükteki komisyon sayısını belirler.

      $ git log -n 4

    3. Depo tarihçesinin başını git reset --hard HEAD~N'u kullanarak sıfırlayın; burada N, başa geri almak istediğiniz taahhütlerin sayısıdır. Aşağıdaki örnekte, kafa bir tane geri getirildi taahhüt, son tarihte depo tarihinde işleme:

    4. İtmeye zorlamak için git push --force kullanarak değişikliği git repo'ya itin değişiklik.

    Önceki bir işleve git deposu gitmek istiyorsanız,

     
    git pull --all
    git reset --hard HEAD~1
    git push --force
    
        
    29
    2018-07-05 20: 56: 59Z

    en son konumuna geri dönün, tüm yerel değişiklikleri kabul edip yok sayın:

     
    git reset --hard HEAD
    
        
    27
    2018-07-04 19: 28: 44Z

    Gerekli taahhüdünüzü seçin ve kontrol edin

     
    git show HEAD
    git show HEAD~1
    git show HEAD~2 
    

    gerekli taahhüdü alana kadar. HEAD'in bunu göstermesi için,

    yapın  
    git reset --hard HEAD~1
    

    veya git reset --hard HEAD~2 veya her neyse.

        
    26
    2014-06-28 19: 51: 32Z
    1. Zorunlu Uyarı: Şubenizi eski taahhütlerin kopyaları olan diğer kişilerle paylaşıyorsanız, çünkü kullanma Bunun gibi bir sert sıfırlama, çalışmalarını yeni sıfırlama dalıyla tekrar senkronize etmeye zorlar. Sert sıfırlama ile çalışmalarını kaybetmeden işleri nasıl güvenli bir şekilde geri alabileceğinizi ayrıntılı bir şekilde açıklayan bir çözüm için bu cevaba bakın .
      2014-06-28 19: 57: 00Z
    2. Ayrıca, açık olmak gerekirse, git show HEAD, yalnızca git log HEAD -1 kullanmaya eşdeğerdir.
      2014-06-28 19: 58: 54Z

    Bir önceki taahhütten HEAD’e yapılan değişiklikleri korumak ve bir önceki göreve geçmek için, şunları yapın:

     
    git reset <SHA>
    

    HEAD’e yapılan önceki taahhüdün değiştirilmesi gerekmiyorsa ve tüm değişiklikleri atmanız gerekirse, şunları yapın:

     
    git reset --hard <SHA>
    
        
    20
    2016-07-03 10: 21: 53Z

    Bir kod çözücünün dizinini bazı yanlışlıkla yapılan değişikliklerden tamamen temizlemek için kullandık:

     
    git add -A .
    git reset --hard HEAD
    

    Yalnızca git reset --hard HEAD değişikliklerden kurtulur, ancak "yeni" dosyalardan kurtulmaz. Bu durumda yanlışlıkla rastgele bir yere önemli bir klasörü sürüklemişlerdi ve tüm bu dosyalar Git tarafından yeni olarak değerlendiriliyordu, bu yüzden reset --hard onu düzeltmedi. git add -A .’u önceden çalıştırarak sıfırlama ile silinmek üzere açık bir şekilde hepsini git ile izler.

        
    20
    2016-07-03 10: 55: 25Z

    Bu, yakın zamanda yapılan bir işleme doğrudan sıfırlamanın bir yoludur

     
    git stash
    git stash clear
    

    Son işlemden bu yana yaptığınız tüm değişiklikleri doğrudan temizler.

    PS: Küçük bir problemi var; ayrıca son zamanlarda sakladığınız stash değişikliklerini siler. Sanırım çoğu durumda önemli olmamalı.

        
    20
    2016-07-03 10: 57: 18Z
    1. NOT: Dizine eklenmeyen yeni dosyalar saklanmaz. Siz de onları veya kılavuzu ekledinizly onları silin.
      2016-12-08 14: 08: 46Z
    2. Neden oh neden stash temizleniyor? Çözüm dışı olmanın yanı sıra, bu aslında zararlıdır. Sorunun ilk cümlesini okumak derhal stash çözümünü geçersiz kılar (SADECE LAST'ın taahhüdüne sıfırlamak için yararlı olabilir).
      2019-03-07 07: 35: 51Z

    Bazı insanların ustalarında yaptıkları değişikliklerin nasıl geri alınacağını bilmek isteyen bu soruya gelebileceklerine inanıyorum - yani her şeyi bir kenara atıp kökeni /ustaya geri dönün, bu durumda, şunu yapın:

     
    git reset --hard origin/master
    

    https://superuser.com/questions/273172/how-to -Sıfırlamak-master-kökenli-ana

        
    19
    2017-03-20 10: 18: 20Z

    Geri alma, taahhütleri geri alma komutudur.

     
    git revert <commit1> <commit2> 
    

    Örnek:

    git revert 2h3h23233

    Aşağıdaki gibi HEAD'den menzil alabilir. Burada 1 "son işlemi geri al" diyor.

    git revert HEAD~1..HEAD

    ve sonra git push yapın

        
    16
    2016-05-27 06: 05: 57Z

    En Yeni Taahhütleri Geri Al:

     
    git reset --hard HEAD
    

    HEAD, yalnızca geçerli daldaki geçerli işleme (en son) referanstır. Herhangi bir zamanda yalnızca HEAD olabilir.

    Eski Bir Taahhüt'e Geri Dön: Eski bir sürümü geri yüklemenin en hızlı yolu reset komutunu kullanmaktır:

     
    # Resets index to former commit
    git reset 56e05fced 
    
    # Moves pointer back to previous HEAD
    git reset --soft HEAD@{1}
    
    # Updates working copy to reflect the new commit
    git reset --hard
    

    Bu, HEAD şubenizi belirtilen sürüme geri saracaktır. Bu sürümden sonra gelen tüm taahhütler etkili bir şekilde geri alınmaktadır; projeniz tam olarak o sırada olduğu gibi.

    Sıfırlama komutu, birkaç seçenekle gelir, en ilginçlerinden biri --soft bayrağıdır. --hard yerine kullanırsanız Git, bu "geri alınmış" durumundaki tüm değişiklikleri yerel değişiklikler olarak saklar.

    Yeni Yerel Şubede Bir Düzeltmeyi Geri Yükleme

    Söylediği gibi, HEAD şubenizdeki reset komutunu kullanmak oldukça zor bir eylemdir: belirtilen revizyondan sonra gelen tüm taahhütleri (bu daldaki) kaldıracaktır. İstediğinin bu olduğundan eminsen, her şey yolunda.

    Ancak, mevcut HEAD şubenizi dokunmadan bırakmayı tercih etmeniz durumunda daha güvenli bir yöntem de vardır. Git'te "şubeler" çok ucuz ve kolay olduğu için, eski revizyondan başlayarak kolayca yeni bir şube oluşturabiliriz:

     
    git checkout -b old-project-state 0ad5a7a6
    

    Normalde, ödeme komutu sadece dalları değiştirmek için kullanılır. Bununla birlikte, -b parametresini sağlayarak yeni bir dal oluşturmasına izin verebilirsiniz (bu örnekte eski-proje durumu ). Mevcut HEAD revizyonunda başlamasını istemiyorsanız, aynı zamanda kesin bir işlem yapmalısınız - eski proje revizyonunu geri yüklemek istiyoruz.

    Artık projenizin eski sürümünü yansıtan old-project-state adlı yeni bir şubeniz var - başka bir komisyon veya şubeye dokunmadan veya hatta kaldırmadan.

        
    16
    2018-08-31 11: 08: 13Z

    Durum acil bir durumsa ve projenizin dizin altında olduğunu varsayarak, sorgunun hızlı ve kirli bir şekilde ne istediğini yapmak istiyorsanız " proje ":

    1. Tüm dizini kopyalayın ve "projem - kopyala"

    2. gibi başka bir şey arayın
    3. yapın:

       
      git reset --hard [first-4-letters&numbers-of-commit's-SHA]
      

    Sisteminizde iki sürüm var ... önceki dosyaları izleyerek ilgilendiğiniz dosyaları inceleyebilir veya kopyalayabilir veya değiştirebilirsiniz. Yeni çalışmanın hiçbir yere gitmediğine karar vermişseniz, "projem - kopyala" altındaki dosyaları tamamen atabilirsiniz ...

    O zamandan beri çalışmayı gerçekten reddetmeden, projenin durumuna devam etmek istiyorsanız açık bir şeyBu alınan taahhüt, dizininizi yeniden adlandırmaktır: Alınan taahhüdü içeren projeyi silin (veya geçici bir isim verin) ve "projem - kopyala" dizininizi "projem" olarak yeniden adlandırın. O zaman büyük olasılıkla yakında başka bir taahhüt daha yapın.

    Git mükemmel bir yaratım ama sadece "anında yakalayamazsınız": çok sık açıklamaya çalışan insanlar "diğer VCS [Sürüm Kontrol Sistemleri] hakkında önceden bilgi sahibi olduklarını varsayıyorlar ] ve çok kısa bir süre içinde çok derinlere dalın ve "kontrol etmek" için değiştirilebilir terimler kullanmak gibi - bazen yeni başlayanları şaşırtmak için neredeyse hesaplanmış görünen şekillerde başka suçlar işleyin.

    Kendinizi çok strese sokmak için Git ile ilgili bir kitap okumak zorundasınız - " Git ile Sürüm Kontrolü ". Ve "mecbur" derken bana (veya izlerime) güvenebilirseniz, NOW de yapabileceğinizi söylersiniz. Git'in karmaşıklığının çoğu dallanma ve sonra yeniden birleşmeden geliyor. Ancak sorunuza göre insanların sizi bilimle körleştirmesi için bir neden yoktur .

    Özellikle, örneğin, bu çaresiz bir durumsa ve Git'te yeni doğmuşsanız!

    PS: Başka bir düşünce: Git deposunu ("repo") çalışan dosyalardan farklı bir dizinde tutmak oldukça basit. Bu, yukarıdaki hızlı & kullanarak tüm Git havuzunu kopyalamanız gerekmeyeceği anlamına gelir. Kirli çözelti. Fryer'ın cevabına bakın --separate-git-dir Uyarı alın , ancak: Kopyalamadığınız "ayrı bir dizin" deponuz varsa ve donanımdan sıfırlama işlemi yaparsanız, sıfırlama işleminden sonra gelen tüm sürümler sonsuza dek kaybolur Mutlaka gerektiği gibi, havuzunuzu düzenli olarak, tercihen buluta yedeklediniz (ör. Google Drive ) ) diğer yerlerin arasında.

        
    13
    2017-05-23 11: 55: 13Z

    İstediğiniz işleme sıfırlamayı deneyin -

    git reset <COMMIT_ID>

    (COMMIT_ID git log kullanıp kullanmadığını kontrol etmek için)

    Bu, değiştirilen tüm dosyaları eklenmemiş durumuna sıfırlayacaktır.

    Artık, eklenmemiş tüm dosyaları checkout

    git checkout .

    Değişikliklerinizi doğrulamak için git log’u kontrol edin.

    GÜNCELLEME

    Repo'nuzda bir ve yalnızca taahhüt varsa, deneyin

    git update-ref -d HEAD

        
    13
    2018-04-17 10: 02: 40Z

    Komisyonlarınız uzaktan ittiği için, onları kaldırmanız gerekir. Şubenizin geliştiğini ve kökene itildiğini varsayalım.

    Öncelikle geliştirmeyi kökünden kaldırmanız gerekir:

     
    git push origin :develop (note the colon)
    

    Öyleyse istediğiniz statüde geliştirmeye ihtiyacınız var, kararın EFGHIJK olduğunu varsayalım:

     
    git reset --hard EFGHIJK
    

    Son olarak, geliştirmeye tekrar basın:

     
    git push origin develop
    
        
    11
    2017-04-19 07: 18: 34Z
      

    Dikkat! Bu komut, kullanıcı yanlış bir şekilde yanlış işleme koyarsa, taahhüt tarihi kaybına neden olabilir. Her zaman git bazı ek yedek   Başka bir yerde, hata yaparsanız, biraz daha güvende olursunuz.   :)

    Benzer bir sorun yaşadım ve önceki Taahhüt'e geri dönmek istedim. Benim durumumda daha yeni bir taahhütte bulunma konusunda kararlı değildim, bu yüzden Hard kullandım.

    Bu şekilde yaptım:

     
    git reset --hard CommitId && git clean -f
    

    Bu, yerel depoya geri döner, burada git push -f kullanıldıktan sonra uzak depoyu günceller.

     
    git push -f
    
        
    11
    2018-02-02 13: 51: 57Z

    Son işlemdeki bir hatayı düzeltmek istiyorsanız, git kullanarak iyi bir alternatif kullanıncommit --amend komutu. Son taahhüt herhangi bir referansla işaret edilmezse, bu son hileyle aynı veli ile bir taahhüt yarattığı için hile yapar. Son taahhüdün referansı yoksa, sadece atılacak ve bu taahhüt son taahhüt olacak. Bu, komisyonları geri almadan komisyonları düzeltmenin iyi bir yoludur. Ancak, kendi sınırlamaları vardır.

        
    10
    2015-07-01 11: 35: 54Z
kaynak yerleştirildi İşte