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?
$ 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)
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~1ile aynıdır) gibidir ancak mevcut değişikliklerinizi aşamalı olarak bırakır.
git addyeni taahhüdünüze eklemek istediğiniz herhangi bir şey.
reseteski kafayı
.git/ORIG_HEAD;
commit,
-c ORIG_HEADile, 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,
-Cseç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:
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.
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.
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)
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.
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
İş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.
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.
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.
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.
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
git revert <commit-id> kullanın
Taahhüt kimliğini almak için, sadece
git log kullanın.
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.
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.
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>
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.
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.
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.
Ş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.
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.
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.
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
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.
Tek bir komut:
git reset --soft 'HEAD^'
Son yerel taahhüdü geri almak için harika çalışıyor!
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:
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.
Yaptığınız değişiklikleri korumak istemiyorsanız:
git reset --hard HEAD^
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.
Doğru durumu bulmak için reflog kullanın
git reflog
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. SIFIRLA SONRA GİRİŞ
Sonunda reflog aşağıdaki resme benziyor
SOĞUTMA NİHAİ
"Ç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 -
İ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
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.
git commit --amend -m "message"
Son taahhüdü yeni taahhütle değiştirecek.
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.
git log yazın ve son işlem karma kodunu bulun ve ardından girin:
git reset <the previous co>
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
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.
Basit, bunu komut satırında çalıştırın:
git reset --soft HEAD~
Önceki revizyona sıfırlamak için, tüm taahhüt edilmemiş değişikliklerin kalıcı olarak silinmesi:
git reset --hard HEAD~1
İ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.
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
git reset --soft HEAD~1
veya hangi taahhüdün tam olarak olduğunu hatırlamıyorsanız, kullanabilirsiniz
git rm --cached <file>
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.
reset --softveya
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.).
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
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.
Kullanabilirsiniz:
git reset [email protected]{1}
Bu komut, Git işlem günlüğü olmadan hatalı işleminizi silecektir.
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:
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:
Son işlemi geri al:
Şimdi, herhangi bir değişiklik yapmadan sadece taahhütte bulunmak istiyorsak, kullanabiliriz.
git reset --soft HEAD^
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^
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^
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ı:
git guiile başlatın.
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 .
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
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
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.
Önceki cevaplardaki Git ile ilgili komutlardan bahsederken, tipik Git çevrimlerimi yararlı olabilecek tüm okuyucularla paylaşmak istiyorum. Git ile nasıl çalışıyorum
Uzak sunucudan ilk kez klonlama
git clone $project
Uzaktan kumandadan çekerek (Bekleyen yerel bir Push'a itmediğimde)
git pull
$ 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
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
$ To_be_committed_list dosyasındaki dosya1'in işlenmesi
git commit -m "commit message description"
Yerel işleme, bastırmadan önce uzak havuzla senkronize etme
git pull --rebase
Çatışma gerçekleştiğinde çözme önkoşul yapılandır mergetool
git mergetool #resolve merging here, also can manually merge
Çatışma çözümlü dosyalar ekleyerek,
file1:
git add $file1
Önceki rebase komutuma devam
git rebase --continue
Hazırla ve zaten senkronize edilmiş son yerel işlemi zorla
git Push Origin head:refs/for/$branch # branch = master, dev, etc.
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.
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 ...
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ü.
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).
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.
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.
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.
Her zaman
reflog de kullanabilirsiniz.
git reflog
HEAD '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.
"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 && checkout
HEAD öğesini değiştirin.
Bu komutu kullanın:
git checkout -b old-state number_commit
Bu komutu kullan
git checkout -b old-state 0d1d7fc32
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
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.
Her zaman önceki sürümde bir
git checkout <SHA code> yapabilirsiniz ve daha sonra yeni kodla tekrar işlem yapabilirsiniz.
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.
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.
Bir açılır pencere açılacaktır (aşağıdaki ekran görüntüsüne bakın)
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.
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.
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
İş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 :)
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.
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"
Bir sonraki resimde, yaptığınız her şeyi taahhütler günlüğünüzde görebilirsiniz (Git komutunu
git log kullanarak).
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
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.
Son taahhüdü geri almanın en basit yolu
git reset HEAD^
Bu, siz taahhütte bulunmadan önce proje durumunu getirecektir.
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 ...".
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:
Ö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 addkullanarak 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.
git reset --soft Bişlevini yerine getirdiğimizde, yerine getirme hedefini kaldırma C ve master/HEAD işaretini B ile göster.
git statuskomutunu çalıştırırken, commit C dizininde dizine alınmış dosyaları göreceksiniz: staged.
git commityürütülmesi, C ile aynı değişikliklerle yeni bir işlem oluşturur
git reset --mixed Bdosyasını yürütün.
git addve sonra her zamanki gibi yaparsınız.
git reset --hard Bdosyasını yürütün
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.
Son işlenen karışma kodunu günlüğünü görerek bulun:
git log
Sonra
git reset <the previous co>
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:
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.
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
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)
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
Her seferinde yaptığım bir taahhüt/taahhütten vazgeçmem gereken şeyler:
git reset HEAD~<n>// geri almam gereken son işlemin sayısı
git status // isteğe bağlı. Tüm dosyalar şimdi kırmızı (etiketsiz).
Şimdi sadece ihtiyacım olan dosyaları ekleyebilir ve taahhüt edebilirim:
git add <file names> & git commit -m "message" -m "details"
git checkout <filename>
git Push Origin <branch name> -f//, Push'u zorlamak için -f öğesini kullanı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.
Eğer "ana" daldaki tek işlemi sıfırlamak istiyorsanız,
$ git update-ref -d HEAD $ git rm --cached -r .
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>
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>
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ışı:
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.
İ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)
--amend ile işlemi yineleyin, örneğin:
git commit --amend
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
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
Aynı yaşlarda kendim de aynı sorunları yaşadıktan sonra yazdım:
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.
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.
git revert <commit-id> kullanabilirsiniz.
Ve taahhüt kimliğini almak için, sadece
git log kullanın.
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.
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.
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