it-swarm-tr.com

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

Yanlışlıkla yanlış dosyaları Git 'e işledim, ancak henüz sunucuyu işleme koymadım.

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

19077
Hamza Yerlikaya

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. Geri almak istediğin şey bu.
  2. Bu, çalışma ağacınızı (diskteki dosyalarınızın durumu) değişmeden bırakır ancak taahhüdünü geri alır ve taahhütlenmemiş yaptığınız değişiklikleri bırakır (bu nedenle git status'da "İşleme yönelik olarak belirtilen değişiklikler" olarak görünecekler, bu nedenle eklemeniz gerekir. taahhüt etmeden önce onları tekrar). Yalnızca, ekle önceki iadesinde daha fazla değişiklik yapmak veya ihale mesajını değiştirmek istiyorsanız1Bunun yerine, git reset --soft HEAD~ 'u kullanabilirsiniz, ki bu, git reset HEAD~ (buradaki HEAD~, HEAD~1 ile aynıdır) gibidir 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; commit, -c ORIG_HEAD ile, başlangıçta eski taahhüdün 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, dizine herhangi bir yeni değişiklik eklediyseniz, commit --amend öğesini kullanmak, onları önceki işleminize ekleyecektir.

Kod zaten sunucunuza gönderildiyse ve tarihin üzerine yazma izniniz (yeniden oluşturma) öyleyse:

git Push Origin master --force

Ayrıca bu cevaba da bakabilirsiniz: 

HEAD önceki bir yere nasıl taşınır? (Müstakil kafa)

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


1 Bununla birlikte, kabul mesajı'nızda bir hata yaptıysanız, önceki bir işleme geri dönmeniz gerekmediğini unutmayın. En kolay seçenek, git reset (o zamandan beri yaptığınız değişiklikleri büyütmek için) ve ardından git commit --amend 'dır; bu, son işlem mesajı ile önceden doldurulmuş varsayılan işlem mesajı editörünüzü açacaktır. 

20714
Esko Luontola

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

Diyelim ki, C sizin HEAD ve (F) sizin dosyalarınızın durumudur.

   (F)
A-B-C
    ↑
  master

nuke C'ye karar verir ve bir daha asla göremezsiniz . Bunu yap:

git reset --hard HEAD~1

Sonuç:

 (F)
A-B
  ↑
master

Şimdi B baş. --hard kullandığınız için, dosyalarınız B taahhüdündeki durumuna sıfırlanır.

Ah, ama farz edelim ki C bir felaket değildi, ama sadece biraz kapalı. Daha iyi bir taahhütte bulunmadan önce bir düzenlemeyi yapmak için taahhüdünüzü geri almak ancak değişikliklerinizi devam ettirmek istiyorsunuz. Buradan başlayarak, başınız olarak C ile:

   (F)
A-B-C
    ↑
  master

Bunu, --hard öğesinden ayrılarak yapabilirsiniz:

git reset HEAD~1

Bu durumda sonuç:

   (F)
A-B-C
  ↑
master

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

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

git reset --soft HEAD~1

Bu sadece dosyalarınızı yalnız bırakmaz, hatta indeksinizi tek başına 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 yapabilir ve az önce yaptığınız taahhütleri tekrar edersiniz.

Bir şey daha var: İlk örnekte olduğu gibi bir taahhüdü yok ettiğini varsayalım, , ancak daha sonra ihtiyaç duyduğunuzu keşfedin ? Zor şans, değil mi?

Hayır, hala hala geri almanın bir yolu var. git reflog yazın ve etrafta dolaştığınız (kısmi) taahhüt shas (yani, karma değerlerin) bir listesini görürsünüz. İmha ettiğiniz taahhüdü bulun ve şunu yapın:

git checkout -b someNewBranchName shaYouDestroyed

Şimdi bu taahhüdü tekrar 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.

10367
Ryan Lundy

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

Son taahhüdünüzü "geri almanın" iki yolu vardır; bu, taahhüdünüzü herkese açık yapıp yapmamaya bağlı olarak (uzak havuzunuza itti)

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 öğesini HEAD öğesinden önceki işleme geri yüklememiz gerekir:

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 işlemimizin kaldırıldığını gösterecek.

Bir kamu taahhüdünü geri alma

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

git revert HEAD

Değişiklikleriniz şimdi geri alınacak ve taahhüt etmeniz için hazır olacaktır:

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 Temelleri - Şeyleri Geri Alma

1909
Andrew

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

git rm classdir
git add sourcedir

Ardından taahhüdü değiştirin:

git commit --amend

Daha önceki hatalı sonuç, yeni endeks durumunu yansıtacak şekilde düzenlenir - başka bir deyişle, ilk başta hatayı hiç yapmamış gibi olacaksınız.

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

1669
bdonlan
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 dosyalarındaki (ve diğer dosyalardaki) değişiklikleri kalıcı olarak kaldıracak.

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

933
Lennart Koopmann

Son taahhüdü değiştirmek için

Dizindeki dosyaları değiştirin:

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

O zaman özel bir şube ise, amend taahhüdünü yapın:

git commit --amend

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

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


(önceki bir taahhüdü değiştirmek için, awesome interaktif rebase )


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


Taahhüdü geri almak

Bir taahhüdün değiştirilmesi, son taahhüdünüzü değiştirmeniz gerekirse ideal çözümdür, ancak daha genel bir çözüm reset.

Git ile herhangi bir taahhüde sıfırlayabilirsiniz:

git reset @~N

N, HEAD öncesindeki işlemlerin sayısıdır ve @~ önceki işlemeye sıfırlanır.

Dolayısıyla, taahhüdü değiştirmek yerine, şunları 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 bölümlerini inceleyin.

Reflog

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

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


712
Zaz

git revert <commit-id> kullanın

Taahhüt kimliğini almak için, sadece git log kullanın.

594
Jaco Pretorius

Eğer yerel bir taahhüdün tamamını geri almayı planlıyorsanız, taahhüdünüzü ne değiştirirseniz yapın, 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 gelecektir ve değişiklikleriniz yerel çalışma ağacınızdan tamamen kaybolacaktır). 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 işlediğiniz 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 yüzden ne değiştirirseniz düzenleyin, ekleyip yeni ve yeni bir işlem yapmak istiyorsunuz.

Daha

477
Madhan Ayyasamy

Eğer Git Ekstraları yüklüyse, en son işlemi geri almak için git undo komutunu çalıştırabilirsiniz. git undo 3, son 3 taahhüdü geri alır.

456
nickf

Paylaşılan havuzumuzdaki en son 5 komisyonu geri almak istedim. Geri almak istediğim revizyon kimliğine baktım. Sonra aşağıdakileri 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 [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>
424
neoneye

Bu iş için git rebase -i kullanmayı tercih ediyorum, çünkü kurtulmak için karar verebileceğim güzel bir liste çıkıyor. Buradaki diğer cevaplar kadar doğrudan olmayabilir, fakat sadece doğru hisseder .

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.

401
Steven Penny

Önceki yerel taahhüt nasıl düzeltilir?

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

Önceki yerel taahhüt nasıl geri alınır

Sadece şubenizi önceki konuma 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 kullanın.

Uyarı kelimesi: Dikkatsiz bir git reset kullanımı, çalışma kopyanızı kafa karıştırıcı bir duruma getirmenin iyi bir yoludur. Git acemilerinin ellerinden geldiğince bundan kaçınmasını öneririm.

Bir kamu taahhüdünü geri alma

Değişiklikleri geri almak için bir ters kiraz toplama ( git-geri alma ) yapın.

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

git revert --no-edit HEAD

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

Teslim geçmişi her iki görevi ayrı ayrı gösterecektir.


Gelişmiş: Halka açık depodaki private şubesinin düzeltilmesi

Bu tehlikeli olabilir - repush için şubenin yerel bir kopyasına sahip olduğunuzdan emin olun.

Ayrıca not: Şube üzerinde başkası ç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, muhtemelen özel şube taahhüt geçmişinizin bozulmamış olduğu konusunda endişelenmenize gerek yoktur. Sadece bir takip taahhüdüne basın (yukarıdaki 'Kamu taahhüdünü nasıl geri alırsınız' bölümüne bakın) ve daha sonra merge / tarihi gizlemek için.

386
nobar

Eğer önemsiz işlediniz, fakat zorlamadıysanız,

git reset --soft HEAD~1

HEAD ~ 1 kafadan önce işlemek için bir kısa yoldur. Alternatif olarak, sıfırlamak istiyorsanız, karma değerinin SHA-1 kısmına bakabilirsiniz. --soft seçeneği, taahhüdü siler ancak git durumu koyduğu gibi değiştirilen tüm dosyalarınızı "İşlenecek değişiklikler" olarak bırakır.

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

OR

Zaten itti ve birisi benim durumumda çekti, git reset kullanamazsınız. Ancak git geri ile 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.

310
santos_mgr

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

Taahhüt kimliği tarafından görülebilir 

git log 

O zaman yapabilirsin -

git reset --hard <commit_id>

git Push Origin <branch_name> -f
306
poorva

SourceTree (GitHub için GUI) üzerinde, işlemi sağ tıklayıp bir 'Tersine Teslim Etme' işlemi 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.
258
Varun Parakh

Tek bir komut:

git reset --soft 'HEAD^' 

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

242

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

git reset --soft HEAD~1

Açıkla:git reset ne yapar, geri dönmek istediğiniz herhangi bir taahhüdün temelde reset, o zaman --soft anahtarıyla birleştirirseniz geri döner, ancak değişiklikleri dosyalarınızda tutar, böylece dosyanın eklendiği aşamaya geri dönersiniz, HEAD dalın başıdır ve ~1 ile birleştirirseniz (bu durumda HEAD^ da kullanırsınız), hangisini istediğinizi taahhüt eder. .

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

 How to undo the last commits in Git?

229
Alireza

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

Her şeyi en son işlemden önceki haline geri döndürmek için, HEAD'den önceki işe geri dönmemiz gerekir.

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

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

    git reset --soft HEAD^
    

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

216

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

git reflog

reflog before SIFIRLA ÖNCE REFLOG

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

git reset --hard f3cb6e2

Bundan sonra repo HEAD bu HEADid .__ 'ya sıfırlanacaktır.reset effect SIFIRLA SONRA GİRİŞ

Sonunda reflog aşağıdaki resme benziyor

reflog after SOĞUTMA NİHAİ

174

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

git reset --hard HEAD^ 

"Çalışan ağaçtaki bilinmeyen dosyaları temizle"

git clean    

see - Git Hızlı Başvuru

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

169
Ravi_Parmar

İ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.

O zaman yapın:

git reset --hard ActionIdFromRefLog
152
U. Ali

Son işlemi geri al:

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

Bu son taahhüdü geri alacak.

Burada --soft, evrelemeye sıfırlama anlamına gelir.

HEAD~ veya HEAD^, HEAD'den önce işlem yapmak üzere hareket etmek 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.

143
akshay_rahar

Diğer yol:

Geri almak istediğiniz şubeye göz atın, ardından yerel çalışma kopyanızı uzaktaki sunucuda en yenisi olmak istediğinize geri döndürün (güle güle gidene kadar her şey). Bunu yapmak için SourceTree'de sağ tıklayıp "BRANCHNAME ürününü bu göreve sıfırla" seçeneğini seçtim.

Ardından havuzunuzun yerel dizinine gidin ve bu 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 olanları siler.

138
CommaToast

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

git reset <the previous co>
129
user853293

Benim durumumda yanlışlıkla istemediğim bazı dosyalar işledim. Ben de 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

125
egridasov

Kararlarınızı ve ağacınızı görmek için SourceTree (Git için grafiksel araç) kullanın. Doğrudan sağ tıklatarak el ile sıfırlayabilirsiniz.

114
iOS Coder

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

git reset --soft HEAD~ 
114
kyo

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

git reset --hard HEAD~1
113
thestar

İki ana senaryo var

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

Sorun, eklediğiniz ek dosyalarsa (ve bunları depoda istemiyorsanız), onları git rm kullanarak ve ardından --amend ile çalışarak kaldırabilirsiniz.

git rm <pathToFile>

Ayrıca tüm dizinleri -r ile silebilir, hatta diğer Bash komutları ile 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, son yerel atama işleminizi fazladan dosyaları kaldırarak yeniden yazacaktır; bu nedenle, bu dosyalar hiçbir zaman Push'ta gönderilmeyecek ve aynı zamanda yerel .git deponuzdan GC tarafından silinecektir.

Sen zaten taahhüdü bastın

Diğer senaryonun aynı çözümünü uygulayabilir ve daha sonra git Push seçeneğiyle -f işlevini uygulayabilirsiniz, ancak uzak tarihin üzerine farklı bir değişiklikle yazdığından ({sizin deponuzu bozabilir) önerilmez olur.

Bunun yerine işlemi --amend olmadan yapmanız gerekir (-amend` ile ilgili şunu unutmayın): Bu seçenek, son işlemin tarihçesini yeniden yazar.

113
dseminara

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

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

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

Git'teki işlemi geri döndürmek için temel komut:

$ git reset --hard <COMMIT -ID>

veya

$ git reset --hard HEAD~<n>

COMMIT-ID: taahhüt için kimlik

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:

'D81d3f1' son işlemine geri dönmek 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, başlığı belirtilen duruma sıfırlamak için başka komutları da başvurabilir ve deneyebilirsiniz:

$ git reset --help
113
Upen

Yerel bir taahhüt için

git reset --soft HEAD~1

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

git rm --cached <file>

İtilmiş bir taahhüt için

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

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

Ama bu komutu dikkatle kullanmanızı tavsiye ederim. Daha fazlası için bkz. git-filter-branch (1) Manual Page.

112
geoom

KULLANIM ŞEKLİ, reset --soft veya reset --hard?

@ Kyralessa'nın cevabı için iki sent ekliyorum:

Ne kullanılacağından emin değilseniz --soft için gidin (bunu hatırlamak için bu kuralı kullandım - s oft.).

Niye ya ?

Yanlışlıkla --hard seçersenizdeğişikliklerinizi daha önce olmadığı gibi kaybedersiniz. • Yanlışlıkla --soft seçerseniz, ek komutları uygulayarak --hard ile aynı sonuçları elde edebilirsiniz.

git reset HEAD file.html
git checkout -- file.html

Tam örnek

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

Krediler @Kyralessa'ya gidiyor.

91
amd

Kullanabilirsiniz:

git reset [email protected]{1}

Bu komut, Git işlem günlüğü olmadan hatalı işleminizi silecektir.

62
Jade Han

Sanırım code.txt dosyamız var . Üzerinde bazı değişiklikler yapıyoruz ve işleme koyuyoruz .Bu işlemi üç şekilde geri alabiliriz, ama önce yapmanız gereken Aşamalı dosyanın ne olduğunu biliyorum .... __ Aşamalı bir dosya, işlenmeye hazır bir dosyadır ve git status çalıştırırsanız, bu dosya yeşil renkle gösterilir ve işlenmesi için hazırlanmış değilse kırmızı renkle gösterilir:

 enter image description here

Bu, değişikliğinize karar verirseniz, bu dosyadaki değişikliklerin kaydedilmediği anlamına gelir. .. Bu dosyayı git add code.txt ile sahnenize ekleyebilir ve ardından değişikliğinizi kabul edebilirsiniz:

 enter image description here

Son işlemi geri al:

  1. Şimdi, herhangi bir değişiklik yapmadan sadece taahhütte bulunmak istiyorsak, kullanabiliriz.

    git reset --soft HEAD^ 

     enter image description here

  2. Taahhüdümüzü ve değişikliklerini geri almak istiyorsak (BU IS TEHLİKE, çünkü yaptığınız değişiklik kaybedecek) kullanabiliriz

    git reset --hard HEAD^

     enter image description here

  3. Ve eğer taahhütleri geri almak ve değişiklikleri sahneden kaldırmak istiyorsak, kullanabiliriz.

    git reset --mixed HEAD^ veya kısa haliyle git reset HEAD^

     enter image description here

60
Ali Motameni

Genellikle, geri al bir taahhüd yapmak istersiniz, çünkü bir hata yaptınız ve düzeltmek istiyorsunuz - aslında OP soruyu sorduğunda ne yaptığını. Öyleyse gerçekten, aslında yinelemek için bir taahhütte bulunmak istiyorsun.

Buradaki cevapların çoğu komut satırına odaklanır. Komut satırı Git'i rahat kullandığınızda kullanmanın en iyi yolu olsa da, muhtemelen diğer sürüm kontrol sistemlerinden Git'e gelenlere biraz yabancı. 

İşte bir GUI kullanarak nasıl yapılacağı. Git'i yüklediyseniz, bu talimatları izlemeniz için gereken her şeye zaten sahipsiniz.

NOT: Burada, onaylamadan önce taahhüdün yanlış olduğunu anladığınızı varsayacağım. Eğer itmenin ne olduğunu bilmiyorsanız, muhtemelen itmediniz, bu yüzden talimatlara devam edin. Hatalı taahhüdü zorladıysanız, en az riskli yol sadece hatalı bir şekilde işleri düzeltmek için yeni bir taahhütle takip etmektir. 

Bununla birlikte, bir GUI kullanarak en son yapılan hatanın nasıl düzeltileceğini açıkladı:

  1. Komut satırındaki havuzunuza gidin ve gui'yi git gui ile başlatın.
  2. "Son taahhüdü değiştir" i seçin. Son işlem mesajınızı, düzenlediğiniz dosyaları ve yapmadığınız dosyaları göreceksiniz.
  3. Şimdi, şeyleri nasıl görünmelerini istediğinize göre değiştirin ve Tamam'ı tıklayın. 
57
Carl

SourceTree ile çalışıyorsanız, bu size yardımcı olacaktır.

Taahhüt üzerine sağ tıklayın sonra " Sıfırlama (geçerli dal)/bu amaca göre usta "ve son " Yumuşak "sıfırlama .

Enter image description here

57
Alexandr

Sadece son taahhüdünü geri al: 

git reset --soft HEAD~

Veya son işlemden önceki zamanı geri al: 

git reset --soft HEAD~2

Veya önceki herhangi bir taahhüdünüzü geri alın: 

git reset --soft <commitID>

(git reflog komutunu kullanarak commitID bilgisini alabilirsiniz)

Önceki bir taahhüdü geri aldığınızda, çalışma alanını temizlemeyi unutmayın.

git clean

Daha fazla ayrıntı şu belgelerde bulunabilir: git-reset

53
steven

Son İşlemi Geri Al

Kodunuzdaki son taahhüdü gerçekten geri almak istediğiniz tonlarca durum vardır. Örneğin. çünkü kapsamlı bir şekilde yeniden yapılandırmak istiyorsunuz - ya da tamamen ortadan kaldırmak istiyorsunuz!

Bu durumlarda, "reset" komutu en iyi arkadaşınızdır:

$ git reset --soft HEAD~1

Yukarıdaki komut (reset) mevcut HEAD şubenizi belirtilen revizyona geri saracaktır. Yukarıdaki örneğimizde, son revizyonumuzu etkin bir şekilde yerine getirmek için mevcut revizyondan önceki haline dönmek istiyoruz.

--soft bayrağını not edin: Bu, geri alınmış revizyonlardaki değişikliklerin korunmasını sağlar. Komutu çalıştırdıktan sonra, değişiklikleri çalışma kopyanızda kabul edilmemiş yerel değişiklikler olarak bulacaksınız.

Bu değişiklikleri yapmak istemiyorsanız, sadece --hard bayrağını kullanın. Bunu yalnızca bu değişikliklere ihtiyacınız olmadığından eminseniz yaptığınızdan emin olun.

$ git reset --hard HEAD~1

 Enter image description here

51
Mohit

Yerel taahhüdünüzü geri almak için git reset <commit> kullanın. Ayrıca bu öğretici size nasıl çalıştığını göstermek için çok yararlıdır.

Alternatif olarak, git revert <commit>: geri alma komutunu kullanabilirsiniz, değişiklikleri geri alan başka bir işlem eklemek istediğinizde (ancak bunları proje geçmişinde tutar) kullanın.

47
mfathy00

Tipik bir Git Döngüsü

Önceki cevaplardaki Git ile ilgili komutlardan bahsederken, tipik Git çevrimlerimi yararlı olabilecek tüm okuyucularla paylaşmak istiyorum. Git ile nasıl çalışıyorum

  1. Uzak sunucudan ilk kez klonlama

    git clone $project

  2. Uzaktan kumandadan çekerek (Bekleyen yerel bir Push'a itmediğimde)

    git pull

  3. $ To_be_committed_list içine yeni bir yerel dosya1 eklemek (sadece $ to_be_committed_list öğesinin staged alanı anlamına geldiğini düşünün)

    git add $file1

  4. Yanlışlıkla eklenen dosya2'yi $ to_be_committed_list'ten kaldırma (dosya2'nin istemediğim 3. adım gibi eklendiğini varsayalım)

    git reset $file2

  5. $ To_be_committed_list dosyasındaki dosya1'in işlenmesi

    git commit -m "commit message description"

  6. Yerel işleme, bastırmadan önce uzak havuzla senkronize etme

    git pull --rebase

  7. Çatışma gerçekleştiğinde çözme önkoşul yapılandır mergetool

    git mergetool #resolve merging here, also can manually merge

  8. Çatışma çözümlü dosyalar ekleyerek, file1:

    git add $file1

  9. Önceki rebase komutuma devam

    git rebase --continue

  10. Hazırla ve zaten senkronize edilmiş son yerel işlemi zorla

    git Push Origin head:refs/for/$branch # branch = master, dev, etc.

41

Benim durumumda yanlış bir şubeye karar verdim ve zorladım, bu yüzden istediğim tüm değişikliklerimi geri almaktı, böylece onları yeni bir doğru şubeye atabilecektim, bu yüzden bunu yaptım:

Yaptığınız ve ittiğiniz aynı dalda "git status" yazarsanız, yeni bir şey görmezsiniz, çünkü ittirir ve ittirirsiniz, şimdi yazın:

git reset --soft HEAD~1

Bu işlem, tüm değişikliklerinizi (dosyalarınızı) tekrar sahne alanına alır, şimdi bunları çalışma dizinine geri döndürmek için yazmanız yeterlidir:

git reset FILE

Burada "Dosya", tekrar işlemek istediğiniz dosyadır. Şimdi bu DOSYA yaptığınız tüm değişikliklerle birlikte çalışma dizininde (etiketlenmemiş) olmalıdır. Artık istediğiniz dalı değiştirebilir ve o daldaki değişiklikleri kabul edebilirsiniz. Umarım bu aynı hatayı yapan diğer insanlara yardımcı olur. Elbette, taahhüt ettiğiniz ilk şube hala tüm değişikliklerle var, ancak benim durumumda, sizin için uygun değilse, o branştaki bu taahhüdün geri alınmasının yollarını arayabilirsiniz.

39
FraK

GÖRSEL STÜDYO KULLANICILARI (2015 vb.)

Visual Studio'da "geliştirme" gibi bir şubeye basmanıza izin verilmediğinden daha önce denediğim kadar senkronize edemiyorsanız, Visual Studio'daGERI ALMANORRESET &OUML;ĞESININ YANINDA(sert veya yumuşak) işe yarar.

Ton oy ile cevap başına:

Bunu, itilmeye çalışacak bir şeyi nuke etmek için projenizin kök istemi komutunda kullanın:

git reset --hard HEAD~1

İşinizi kaybetmek istemezseniz dosyalarınızı yedekleyin veya sıkıştırın ...

38
Tom Stickel

Taahhüt kimliğini bitbucket adresinden aldım ve sonra şunları yaptım:

git checkout commitID .

Örnek:

git checkout 7991072 .

Ve bu taahhüdün çalışma kopyasına geri döndü.

35
ioopl

Yerel olarak yanlış bir işlem yaptığınızı ve uzak bir havuza ittiğinizi varsayalım. Bu iki komutla karışıklığı geri alabilirsiniz:

Öncelikle, yerel depomuzu arzu ettiğimiz taahhüdümüze geri dönerek düzeltmemiz gerekiyor:

git reset --hard <previous good commit id where you want the local repository  to go>

Şimdi bu komutu kullanarak uzaktan depoda bu iyi taahhüdü zorla zorlarız:

git Push --force-with-lease

Kuvvet seçeneğinin "kiraya verilmeyen" versiyonu, bilmediğiniz yeni taahhütlerin yanlışlıkla silinmesini önleyecektir (yani, son çekiminizden bu yana başka bir kaynaktan geliyor).

34
KawaiKx

Son işlemi geri al:

git reset --soft HEAD^ or git reset --soft HEAD~

Bu son taahhüdü geri alacak.

Burada --soft, evrelemeye sıfırlama anlamına gelir.

HEAD~ or HEAD^ HEAD'den önce işlem yapmak 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.

32
Ankit Patidar

Kolay ve hızlı yapmanız gerekir

    git commit --amend

özel bir şube ise veya

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

paylaşılan veya halka açık bir şube ise.

32
Yahs Hef

Son taahhüdünüzü geri almak için birkaç seçeneğiniz var. İşte seçeneklerinden bazıları kod parçacıklarıyla tek bir cevapta özetleniyor

Öncelikle, atmak istediğiniz "yanlış" işlemlerin hangisi olduğunu bulmanız gerekir. Bulmak için git reflog kullanacağız.


git reflog

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

HEAD her değiştirildiğinde reflog içinde yeni bir giriş olacaktır.
reflog, unix history komutuna benzer ve makinenizde yerel olarak tutulur.

git reflog
git checkout [email protected]{...}
# or
git checkout <sha-1>

Ödeme işlemini kullanarak istediğiniz herhangi bir işleme geri dönebilir ve şube veya git ödeme işleminin yapmanıza izin vereceği diğer seçenekleri oluşturabilirsiniz.

 enter image description here


git reset HEAD --hard <commit_id>

"Hareket ettirin, kafanızı istediğiniz işe geri alma.
Git sıfırlama, seçtiğiniz alan içeriğini çalışma alanınıza ve/veya çalışma dizininize seçmeyi seçeceğiniz --hard/--soft/--mixed değerine göre kontrol edecektir. --hard, hem sahne alanını hem de çalışma dizinini verilen içerikle günceller ve bu noktanın ötesindeki diğer işleri yerel şubenizden "ayırır". 

Bu taahhütler başka bir şubenin parçası değilse, "sersem" olacaklar.
"dangle" içeriği, yerel deponuzda başka bir şubenin parçası olmayan ve gc tarafından kaldırılabilecek veya kaldırılabilecek bir erişilemez içerik olduğu anlamına gelir.

# 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.

Bu şema hangi komutun ne yaptığını göstermektedir.
Gördüğünüz gibi reset && checkoutHEAD öğesini değiştirin.

 enter image description here

28
CodeWizard

Bu komutu kullanın:

git checkout -b old-state number_commit
27
Fadid

Bu komutu kullan

git checkout -b old-state 0d1d7fc32
27

Zaten Github'a itilmiş yanlış bir taahhüdü kaldırın

git Push Origin +(previous good commit id):(branch name)

Lütfen Github'da sıfırlamak istediğiniz son iyi işleme kimliğini belirtin.

Örneğin. En son işlem kimliği yanlışsa, yukarıdaki git komutunda önceki işlem kimliğini şube adıyla belirtin. 

git log kullanarak önceki işlem kimliğini alabilirsiniz

25
V V

Son taahhüddeki (bütün değişikliklerden) kurtulmak için, son 2 taahhüt ve son n taahhüt:

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

Ve belirli bir taahhütten sonra bir şeyden kurtulmak için:

git reset --hard <commit sha>

Örneğin., 

git reset --hard 0d12345

Not:
1- Dikkatli olun, "zor" seçeneğinden dolayı yerel değişiklikleri siler. Sizin deponuzda da belirtilen taahhütlere geri döner. Sen Bunu son vermelisiniz, son işleminizde sorunlu olduğunuzdan eminseniz. ve zamanda geri gitmek istiyorum. 

2- Genellikle "harf sha" nın 7 harfi yeterlidir, ancak daha büyüktür. Projelerin benzersiz olmasını sağlamak için 12 harfe kadar ihtiyacınız olabilir. Sen Ayrıca tüm 40 harf sha söyleyebilirsiniz.

3- Yukarıdaki komutlar, Windows için Github'da da çalışır.

24
Alisa

Her zaman önceki sürümde bir git checkout <SHA code> yapabilirsiniz ve daha sonra yeni kodla tekrar işlem yapabilirsiniz.

24
shreshta bm

Git taahhütlerinizi iki şekilde geri alabilirsiniz: İlk önce, işlem geçmişinizi korumak istiyorsanız, git revert kullanabilirsiniz.

git revert HEAD~3
git revert <hashcode of commit>

İkincisi, tüm işlem geçmişinizi silecek ve istediğiniz yere karar vermeniz için başınızı getirecek olan git reset öğesini kullanabilirsiniz.

git reset <hashcode of commit>
git reset HEAD~3

Herhangi biri başka şekilde davranmaya başlarsa, --hard anahtar sözcüğünü de kullanabilirsiniz. Ancak, sadece son derece gerekli olana kadar tavsiye ederim.

20
Shwetank

Referans: Git'teki son taahhüdü nasıl geri alabilirim?

Eğer Git Eklentileri yüklüyse, herhangi bir işlemi kolayca geri alabilir/geri alabilirsiniz (git eklentilerini here sayfasından indirebilirsiniz).

Git Extensions'ı açın, geri almak istediğiniz göreve sağ tıklayın ve ardından "Geri çevirmeyi seç" seçeneğini seçin. 

 Git Extensions screen shot

Bir açılır pencere açılacaktır (aşağıdaki ekran görüntüsüne bakın)

 Revert commit popup

Geri alınan değişiklikleri doğrudan yapmak istiyorsanız veya geri alınan değişiklikleri el ile yapmak istiyorsanız "Seçili işlemi otomatik olarak oluştur" seçeneğini işaretleyin ve kutunun seçili kalmamasını sağlayın ve "Bu işlemi geri al" düğmesini tıklayın.

18
Ranadheer Reddy

Yaptığınız değişiklikleri sıfırlamak ve yeni bir taahhüt vermek için git reset --hard <last good SHA> komutunu kullanın. Ayrıca git checkout -- <bad filename> kullanabilirsiniz.

16
hubot

Depoda işlediğiniz şeylerin nasıl geri alınacağını açıklayan this sitesini buldum.

Bazı komutlar:

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit
16
Eugen Konkov

İşte site: Oh shit, git! .

Git'teki şeyleri nasıl geri alacağınızla ilgili birçok tarif. Bazıları:

Kahretsin, son sözümdeki mesajı değiştirmem gerekiyor!

git commit --amend
# follow prompts to change the commit message

Kahretsin, yanlışlıkla yepyeni bir dalda olması gereken bir şeyi ustalıkla yerine getirdim!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)
15
Eugen Konkov

Taahhütlerinizi yerel depodan geri alabilirsiniz. Lütfen aşağıdaki senaryoyu takip edin.

Aşağıdaki resimde, yerel olarak 'test' dalını (Git komutunu git checkout -b test kullanarak) ve yerel dalın durumunu kontrol etmek için (Git komutunu git status kullanarak) kontrol edeceğim bir şey yok.

 Enter image description here

Bir sonraki resim görüntüsünde, burada görebileceğiniz Filter1.txt içinde birkaç değişiklik yaptım ve bu dosyayı hazırlama alanına ekledim ve ardından değişikliklerimi bir mesajla (Git komutunu git commit -m "Doing commit to test revert back" kullanarak) yaptım.

"-m taahhüt mesajı içindir"

 Enter image description here

Bir sonraki resimde, yaptığınız her şeyi taahhütler günlüğünüzde görebilirsiniz (Git komutunu git log kullanarak).

 Enter image description here

Bu yüzden yukarıdaki resimde, her bir taahhütle ve her bir taahhütle birlikte taahhüt mesajını görüyorsunuz, şimdi taahhütnameyi geri almak veya geri almak ya da bu sayılan kopyayı geri almak ve Git komutunun altındaki harfleri geri almak, git revert {"paste your commit id"}. Örnek:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

 Enter image description here

Son taahhüdümü geri aldım. Şimdi Git durumunuzu kontrol ederseniz, değiştirilmiş dosyayı Filter1.txt olan ve henüz işleme koymak için görebilirsiniz.

 Enter image description here

14
Raj S. Rusia

Son taahhüdü geri almanın en basit yolu

git reset HEAD^

Bu, siz taahhütte bulunmadan önce proje durumunu getirecektir.

14
Arun Karnawat

IntelliJ IDEA içinde Git tuşuna basarak günlüğü açabilirsiniz. Alt+9, farenin sağ tuşu, listeden bir etikete tıklayın ve şu seçimi yapın: "Geçerli Şube Buraya Sıfırla ...".

13

HEAD:

Sıfırlama işleminden önce HEAD hakkında bilmemiz gerekir ... HEAD, çalışma dizininizdeki şu anki durumunuzdan başka bir şey değildir. Bir taahhüt numarası ile temsil edilir.

Git taahhüdü:

Her değişiklik, benzersiz bir etiketle temsil edilen bir taahhüt altında tayin edilir. Taahhütler silinemez. Dolayısıyla, son taahhüdünüzü istiyorsanız, basitçe git reset kullanarak dalabilirsiniz.

İki yöntem kullanarak son işleme girebilirsiniz:

Yöntem 1: (taahhüt numarasını bilmiyorsanız, ancak ilkine geçmek istiyorsanız)

git reset HEAD~1  # It will move your head to last commit

Yöntem 2: (bildiğiniz taahhüdü biliyorsanız, yalnızca bilinen göreve sıfırlayın)

git reset 0xab3 # İşlem numarası

Not: Yeni bir işlem yapmayı bilmek istiyorsanız git log -p -1 'u deneyin

İşte grafik gösterimi:

 Enter image description here

13

Git reset --mixed, --soft ve --hard arasındaki fark

Önkoşul: 'Da mevcut bir dosyada değişiklik yapıldığında. depo yapıldı, bu değişiklik başlangıçta dengesiz olarak kabul edilir . Değişikliklerin yerine getirilmesi için aşamalı hale getirilmesi gerekiyor. git add kullanarak dizine ekleyin. Bir işlem sırasında, Hazırlanan dosyalar bir dizine eklenir.

Bir örnek alalım: 

- A - B - C (master)

HEAD, C 'a işaret eder ve dizin C ile eşleşir.

--yumuşak

  • git reset --soft B işlevini yerine getirdiğimizde, yerine getirme hedefini kaldırma C ve master/HEAD işaretini B ile göster. 
  • Master/HEAD şimdi B'ye işaret edecektir, ancak index hala C 'den değişmiştir. 
  • git status komutunu çalıştırırken, commit C dizininde dizine alınmış dosyaları göreceksiniz: staged
  • Bu noktada bir git commit yürütülmesi, C ile aynı değişikliklerle yeni bir işlem oluşturur

--karışık

  • git reset --mixed B dosyasını yürütün. 
  • Yürütme sırasında, master/HEAD B'ye işaret edecek ve index de kullanılan karışık bayrak nedeniyle B ile eşleşecek şekilde değiştirilmiş. 
  • Eğer bu noktada git tesadüfat yaparsak, index'in HEAD ile eşleştiğinden hiçbir şey olmayacak.
  • Çalışma dizininde hala değişiklikler var, ancak dizinde olmadıklarından, git durumu onları etiketlenmemiş olarak gösteriyor
  • Onları işlemek için git add ve sonra her zamanki gibi yaparsınız.

--zor

  • git reset --hard B dosyasını yürütün
  • Yürütme sırasında, ana/HEAD B 'ye işaret eder ve çalışma dizini değiştirir
  • C içine eklenen değişiklikler ve tüm kabul edilmemiş değişiklikler, kaldırılacak olacaktır.
  • Çalışma kopyasındaki dosyalar, B taahhüdüyle eşleşecek, bu, C sözleşmesinde yapılan tüm değişikliklerin kalıcı olarak kaybedilmesiyle sonuçlanacaktır.

Umarım git reset komutu ile kullanılabilen bayrakların karşılaştırılması, birinin bunları akıllıca kullanmasına yardımcı olur. Daha fazla ayrıntı için bunlara bakın link1 & link2

12

Geçmişi temiz tutmak istediğinizde, yeniden düzenleme ve bırakma taahhütleri en iyisidir.

En üstteki taahhüdünüzü bırakmanız gerekiyorsa, aşağıdaki tek astar yardımcı olur

git rebase --onto HEAD~1 HEAD

Ama bir çok taahhütten birini bırakmak istersen,

a -> b -> c -> d -> ana

ve sen 'c' taahhüdünü bırakmak istiyorsun

git rebase --onto b c

Bu, 'b'yi' c 'yi ortadan kaldırarak' d 'nin yeni üssü yapacaktır.

12
Khem

Son işlenen karışma kodunu günlüğünü görerek bulun:

git log

Sonra

git reset <the previous co>
12
Praveen Singh

Tamamlanma uğruna, önceki cevaplarda göz ardı edilen göze çarpmayan açık bir yöntemi vereceğim.

Taahhüt itti olmadığından, uzaktan kumanda değişmedi, yani:

  1. Yerel depoyu silin.
  2. Uzak depoyu klonla.

Fantezi Git müşteriniz güle güle giderse, bu bazen gereklidir. (örn. non-fast-forward hataları)

Son Push'tan bu yana kaydedilmiş değişikliklerinizi tekrar yapmayı unutmayın.

11
Dominic Cerisano

 enter image description here

Visual Studio'da çalıştığınızı varsayalım, şube tarihinize girip tüm taahhütlerinize bakarsanız, geri almak istediğiniz taahhütten önce etkinliği seçin, sağ tıklayın ve Revert öğesini seçin. Bu kadar kolay.

11
Uchiha Itachi

Yanlış dosyaları silmek istiyorsanız yapmanız gerekenler 

git reset --soft <your_last_good_commit_hash_here>Here, eğer git status yaparsanız, hazırlama alanındaki dosyaları göreceksiniz. Yanlış dosyaları seçebilir ve bunları hazırlama alanından indirebilirsiniz.

Aşağıdaki gibi.

git reset wrongFile1 wrongFile2 wrongFile3

Artık yalnızca İttirmeniz gereken dosyaları ekleyebilirsiniz.

git add goodFile1 goodFile2

onları taahhüt etmek 

git commit -v veya git commit -am "Message"

ve İt

git Push Origin master

Ancak, değiştirilen dosyaları umursamıyorsanız, önceki iyi taahhütlere sıfırlamak zor olabilir ve her şeyi sunucuya itebilirsiniz.

tarafından 

git reset --hard <your_last_good_commit_hash_here>

git Push Origin master

Yanlış dosyalarınızı zaten sunucuya yayınladıysanız, sunucuya Push ve geçmişi düzenlemek için --force bayrağını kullanabilirsiniz.

git Push --force Origin master

8
nPcomp

Bunu deneyin, bu dosyaların eklenmemiş olduğu önceki göreve sıfırlamayı zorlayın, ardından:

git reset --hard <commit_hash>

Sert sıfırlama nedeniyle değişikliklerin yedeğini aldığınızdan emin olun, bu da kaybolacağı anlamına gelir (daha önce kalmadıysanız)

7
serdarsenay
git reset --soft HEAD~1

Sıfırla, geçerli HEAD dalını belirtilen revizyona geri saracaktır. Not - - flag: Bu, geri alınmış revizyonlardaki değişikliklerin korunmasını sağlar. Komutu çalıştırdıktan sonra, değişiklikleri çalışma kopyanızda kabul edilmemiş yerel değişiklikler olarak bulacaksınız.

Bu değişiklikleri yapmak istemiyorsanız, sadece - hard bayrağını kullanın. Bunu yalnızca bu değişikliklere ihtiyacınız olmadığından eminseniz yaptığınızdan emin olun.

 git reset --hard HEAD~1

Birden Çok Komisyonun Geri Alması

git reset --hard 0ad5a7a6

ancak, reset komutunun kullanılmasının geri döndüğünüzden sonra gelen tüm taahhütleri geri aldığını unutmayın: enter image description here

6
Abu Bakr

Her seferinde yaptığım bir taahhüt/taahhütten vazgeçmem gereken şeyler:

  1. git reset HEAD~<n> // geri almam gereken son işlemin sayısı
  2. git status // isteğe bağlı. Tüm dosyalar şimdi kırmızı (etiketsiz).

  3. Şimdi sadece ihtiyacım olan dosyaları ekleyebilir ve taahhüt edebilirim:

    • git add <file names> & git commit -m "message" -m "details"
  4. İsteğe bağlı: Gerekirse geri kalan dosyaların değişikliklerini önceki durumlarına geri alabilirim: check out:
    • git checkout <filename>
  5. eğer daha önce Origin’e göndermiş olsaydım, daha önce:
    • git Push Origin <branch name> -f //, Push'u zorlamak için -f öğesini kullanın.
6
Theo Itzaris

Geri almayı istiyorsanız, reponuzdaki ilk işlemi yapın

Bu sorunla karşılaşırsınız:

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

Hata, eğer son işlem, havuzun ilk işlemi (veya ebeveynleri olmadan) ise, HEAD ~ yok demektir.

Çözüm

Eğer "ana" daldaki tek işlemi sıfırlamak istiyorsanız,

$ git update-ref -d HEAD
$ git rm --cached -r .
5
Nicholas

Aşağıdaki adımları takip edin. Size yardımcı olabilir.

Basamak: 1

git log tuşuna basın

Günlük listesinden, son karma karma kodunu bulun ve ardından şunu girin:

Aşama: 2

git reset <hash code>
4
Paras Korat

Bu komutu kullanarak son işlem kimliğini alın (en üstteki logdaki en son log)

git log

Taahhüt kimliğini (GUID) alın ve şu komutu çalıştırın:

git revert <commit_id>
3

Edit daha erken bir taahhüt nasıl yapılır

Genel olarak, bir grup taahhüdü geri almak istemiyorum, ama daha önce nasıl bir şey yaptığımı yerine getirmek için önceki bir taahhüdümüzü düzenlemek yerine.

Kendimi sık sık bir geçmişe sadık kalırken, bunun için bir senaryo yazdığımı tespit ettim.

İşte iş akışı:

  1. git commit-edit <commit-hash>
    

    Bu sizi düzenlemek istediğiniz taahhütte bırakacaktır.

    Taahhüdün değişiklikleri un staged, ilk defa olmasını istediğiniz şekilde sahnelenmeye hazır olacak.

  2. İlk etapta olmasını istediğiniz gibi taahhüdünüzü düzeltin ve uygulayın.

    (İşlemediğiniz tüm dosyaları susturmak için git stash save --keep-index kullanmak isteyebilirsiniz)

  3. --amend ile işlemi yineleyin, örneğin:

    git commit --amend
    
  4. Rebase tamamlayın:

    git rebase --continue
    

Bunu aşağıdaki git-commit-edit olarak adlandırın ve $PATH içine yerleştirin:

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "[email protected]"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo
2
Tom Hale

Tüm yerel değişikliklerinizi/taahhütlerinizi çöpe atmak ve yerel şubenizi başladığınız Origin şubesine benzetmek istiyorsanız ...

git reset --hard Origin/branch-name

1
JeremyWeir

Aynı yaşlarda kendim de aynı sorunları yaşadıktan sonra yazdım:

https://ao.gl/how-to-delete-revert-a-git-commit/

Temelde yapmanız gereken sadece:

git log, SHA'nın ilk yedi karakterini alın ve ardından bir git revert <sha> ve ardından git Push --force yapın.

Bunu, Git geri alma komutunu aşağıdaki şekilde kullanarak da geri alabilirsiniz: git revert <sha> -m -1 ve sonra git Push.

1
Andrew Odendaal
git revert commit

Bu, geri dönmek istediğiniz taahhüdün zıddı değişiklikleri üretecek ve ardından sadece bu değişiklikleri taahhüt edecek. Bence bu en basit yol.

https://git-scm.com/docs/git-revert

1
Gjorgi Gjorgiev

git revert <commit-id> kullanabilirsiniz.

Ve taahhüt kimliğini almak için, sadece git log kullanın.

1
Videsh

sunucu sürümündeki değişiklikleriniz de dahil olmak üzere yerel sürümünüzü değiştirin, bu iki kod satırı git'i yerel çekmeye ve üzerine yazmaya zorlar. Aç komut istemi ve git proje kök dizinine gidin. VS kullanıyorsanız, Team, Synch ve aşağıdaki "Komut İstemini Aç" (resme bakın) tıklayın. 

 Visual Studio

Cmd İstemi'ne girdikten sonra aşağıdaki iki talimatla devam edin. 

git fetch --all

o zaman yaparsın

git reset --hard Origin/master

bu, mevcut yerel sürümün üzerine git sunucusundaki sürümün üzerine yazacaktır.

0
shiraz
git Push --delete (branch_name) //this will be removing the public version of your branch

git Push Origin (branch_name) //This will add the previous version back
0
Omkaar.K