it-swarm-tr.com

Git deposunu önceki bir işleme geri alma

Mevcut durumumdan belirli bir taahhüde göre yapılmış bir anlık görüntüye nasıl dönebilirim?

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

$ git log
commit a867b4af366350be2e7c21b8de9cc6504678a61b`
Author: Me <[email protected]>
Date:   Thu Nov 4 18:59:41 2010 -0400

blah blah blah...

commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
Author: Me <[email protected]>
Date:   Thu Nov 4 05:13:39 2010 -0400

more blah blah blah...

commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
Author: Me <[email protected]>
Date:   Thu Nov 4 00:55:06 2010 -0400

And yet more blah blah...

commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
Author: Me <[email protected]>
Date:   Wed Nov 3 23:56:08 2010 -0400

Yep, more blah blah.

3 Kasım’daki taahhüdüme nasıl geri dönersiniz, yani 0d1d7fc?

6795
Crazy Serb

Bu, "geri döndürme" ile ne demek istediğine çok bağlıdır.

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

Geçici olarak ona geri dönmek, etrafta dolaşmak, sonra bulunduğunuz yere geri dönmek istiyorsanız, tek yapmanız gereken, istenen taahhüdü kontrol etmek:

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

Ya da oradayken taahhütte bulunmak istiyorsanız, devam edin ve oradayken yeni bir şube açın:

git checkout -b old-state 0d1d7fc32

Bulunduğunuz yere geri dönmek için, bulunduğunuz şubeye bir göz atın. (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 dal istiyorsanız onları bir dala.)

Yayınlanmayan taahhütleri sert silme

Öte yandan, o zamandan beri yaptığınız her şeyden gerçekten kurtulmak istiyorsanız, iki olasılık var. Biri, bu taahhütlerin hiçbirini yayınlamadıysanız, sadece 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 taahhütleri geri al ile yeni taahhütler

Öte 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. Bir başka faydalı link ise bu git-scm.com bölümü git-revert .

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

Bu durumda bu cevabı da yararlı bulabilirsiniz:
HEAD önceki bir yere nasıl taşınır? (Müstakil kafa)

8690
Cascabel

Çalışan Kopyayı En Son Taahhüdüne Geri Dönme

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

git reset --hard HEAD

HEAD şu anki şubenizdeki son işlemdir

Çalışma Kopyasını Eski Taahhüdüne Geri Alma

En son taahhütten daha eski olan bir taahhüde geri dönmek için:

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft [email protected]{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

Krediler benzer bir Yığın Taşması sorusuna gider,Git'teki SHA karma işlemine geri dönülsün mü?.

1451
boulder_ruby

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

git revert --no-commit 0766c053..HEAD
git commit

Bu, HEAD öğesinden geri dönüş karmaşasına geri olan her şeyi geri döndürecek, yani çalışma ağacında bu işleme durumunu sanki geri yürüdüğü her bir işleme yeniden oluşturacak. 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.

(--no-commit bayrağı git, tüm taahhütleri bir kerede geri almasına izin verir - aksi halde aralıktaki her bir işlem için bir mesaj girmeniz istenir, böylece geçmişinizi gereksiz yeni taahhütler ile karıştırırsınız.)

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

1433
Yarin

Benim ve muhtemelen diğerleri için en iyi seçenek Git sıfırlama seçeneğidir:

git reset --hard <commidId> && git clean -f

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, yorumlarda belirtildiği gibi bunu yapmayın

Ayrıca yorumlarda, daha az 'ballzy' yöntemi kullanmak isterseniz kullanabilirsiniz.

git clean -i

182
Pogrindis

Cevaplamadan önce, bu HEAD öğesinin ne olduğunu açıklayan bazı arka plan ekleyelim.

First of all what is HEAD?

HEAD, yalnızca geçerli daldaki geçerli işleme (en son) bir başvuru kaynağıdır. Herhangi bir zamanda yalnızca bir HEAD olabilir (git worktree hariç).

HEAD içeriği, .git/HEAD içinde saklanır ve mevcut görevin 40 bayt SHA-1'ini içerir.


detached HEAD

En son sözde değilseniz - HEAD, tarihteki bir önceki işleme işaret ediyor demektir, buna detached HEAD denir.

 Enter image description here

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

 Enter image description here


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


git checkout

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

Bu, istenen şubeye işaret eden yeni şubeyi teslim alacaktır. Bu komut belirli bir taahhütte bulunacaktır.

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

# 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

reflog dosyasını her zaman kullanabilirsiniz. git reflog, HEAD dosyasını güncelleyen herhangi bir değişikliği görüntüler ve istenen reflog girişini kontrol etmek HEAD değerini bu işleme geri döndürür.

HEAD her değiştirildiğinde, reflog içinde yeni bir giriş olacaktır.

git reflog
git checkout [email protected]{...}

Bu sizi istenen taahhüdünüze geri döndürür

 Enter image description here


git reset HEAD --hard <commit_id>

Başınızı tekrar istenen göreve getirin.

# 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.
  • Not: ( Git 2.7 ) sürümünden de git rebase --no-autostash 'ı da kullanabilirsiniz.

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

 Enter image description here

143
CodeWizard

Eğer "uncommit" yapmak, son işlem mesajını silmek ve değiştirilen dosyaları tekrar yerleştirmeye koymak istiyorsanız, şu komutu kullanırsınız:

git reset --soft HEAD~1
  • --soft, teslim edilmeyen dosyaların, onları atacak olan --hard öğesinin aksine çalışan dosyalar olarak saklanması gerektiğini belirtir.
  • HEAD~1, son işlemdir. Eğer 3'ü geri almak istiyorsaniz HEAD~3 kullanabilirsiniz. Belirli bir revizyon numarasına geri dönmek istiyorsanız, bunu SHA karma kullanarak da yapabilirsiniz.

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

Kaynak: http://nakkaya.com/2009/09/24/git-delete-last-commit/

124

Git'teki yerel değişiklikleri geri almanın birçok yolunu denedim ve en son taahhüt durumuna geri dönmek istiyorsanız, bunun en iyi şekilde çalıştığını gösteriyor.

git add . && git checkout master -f

Kısa Açıklama:

  • git revert işlevinde olduğu gibi herhangi bir taahhüt yaratmaz.
  • HEAD ile git checkout <commithashcode> yaptığı gibi ayrılmayacak.
  • Tüm yerel değişikliklerinizi geçersiz kılar ve daldaki son işlemden bu yana eklenen tüm dosyaları SİLECEKTİR.
  • Sadece şubelerin isimleriyle çalışır, böylece şubedeki en son işlere geri dönebilirsiniz.

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

git add . && git reset --hard HEAD

HEAD şu anki şubenizdeki en son taahhüdü işaret eder.

Bu, boulder_Ruby'nin önerdiği kod koduyla aynı, ancak son koddan önce oluşturulan tüm yeni dosyaları silmek için git add .'dan önce git reset --hard HEAD 'u ekledim, çünkü çoğu kişinin en son işleme geri döndüğüne inandığımdan beri beklediğim bu.

105
Roman Minenok

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ıracak.

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

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

O zaman değişikliklerinizi kurtaracak.

94
kiran boghra

Tamam, git önceki işine geri dönmek oldukça kolay ...

geriye dönmeden değişiklikleri değiştirmeden geri dön:

git reset --hard <commit>

geri tutarak değişiklikleri koruyarak:

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.

Ama farkı gördüğünüz gibi, --soft ve --hard iki bayraklarını kullanıyorsanız, varsayılan olarak git reset flag'ı kullanarak --soft kullanın, ancak her zaman bayrak kullanan iyi bir uygulamadır.


--yumuşak

Açıklanması gerektiği gibi, varsayılan bayrak, çalışma ağacını değiştirmez, ancak işlem yapmaya hazır tüm değişiklik dosyalarını ekler, böylece dosyalarda yapılan değişikliklerin etiketlenmemiş olduğu işlem durumuna geri dönersiniz.


--zor

Bu bayrağa dikkat edin, çalışan ağacı sıfırlar ve izlenen dosyalarda yapılan tüm değişiklikler sıfırlanır.


Ayrıca git ile çalışan gerçek bir yaşamda olabilecek aşağıdaki imajı yarattım:

 git reset to a commit

63
Alireza

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

git reset --hard <commit_hash>
git Push Origin <branch_name> --force

Buradaki anahtar, Push'u zorlamak, fazladan taahhüt/mesaj iletmek vb.

59
serdarsenay

Diyelim ki, aşağıdaki kodları ~/commits-to-revert.txt adlı bir metin dosyasında bulunduruyorsunuz (onları 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 Shell 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ürdünüz. Git'in neden git revert --to <hash> yok, benden öte.

57
Lance Caraccioli

Jefromi'nin Çözümlerine Ekstra Alternatifler

Jefromi'nin çözümleri kesinlikle en iyileridir ve kesinlikle onları kullanmalısınız. Bununla birlikte, bütünlük uğruna, bir taahhüdün geri alınmasında da kullanılabilecek diğer alternatif çözümleri de göstermek istedim (sizinki anlamda önceki taahhüdündeki değişiklikleri geri alan yeni bir taahhüt oluşturgit revert yok).

Açıkçası, bu alternatifler taahhütleri geri almanın en iyi yolu değil), Jefromi'nin çözümleri , fakat sadece elde etmek için bu diğer yöntemleri de kullanabileceğinizi belirtmek isterim. git revert ile aynı şey.

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

Bu, Charles Bailey'in çözümünün çok az değiştirilmiş bir sürümüdür/ Git'teki bir SHA karma işlemine geri dönülmesi? :

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft [email protected]{1}

# Commit the changes
git commit -m "Revert to <commit>"

Bu, temel olarak, yumuşak sıfırlamaların, daha sonra yapabileceğiniz indeks/evreleme alanında önceki işlenme 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 Checkout eski taahhüdüne ve yeni bir taahhütte bulunmasına :

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

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

56
user456814

Efendi ve o ilgili şube hakkında 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

Cevabını bir blog gönderisinde buldum (artık yok)

Bunun, uzaktan kumandadaki Değişikliği Sıfırlama ve Zorlama olduğunu unutmayın; böylece takımınızdaki diğer kişiler zaten giderse, onlar için sorunlara yol açacaksınız. Değişim tarihini mahvediyorsunuz, 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 iyidir. Tek kişilik bir takımsanız, o zaman önemli değil.

55
markreyes

İşte bir çok daha basit önceki bir göreve geri dönmenin yolu (ve ne istersen yap, onunla beklenmedik bir durumda ol).

git reset HEAD~1

Yani, iddaa iddaa gerek yok ve benzeri :)

51
Paul Walczewski

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

git Push -f ...

Ve sadece git Push değil.

34
sivi

Özellikle eski taahhütleri geri almak ve yerleştirmek için bir emir var (Git'in çekirdeğinin bir parçası değil, fakat git-extras package içinde):

git back

man sayfası başına, aşağıdaki gibi de kullanılabilir:

# Remove the latest three commits
git back 3
33
Shadow Man

Tüm bu başlangıç ​​adımlarını kendiniz tamamlayabilirsiniz ve Git deposuna geri dönün.

  1. git pull --all komutunu kullanarak havuzunuzun en son sürümünü Bitbucket'ten çekin.

  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 geçmişinin başını git reset --hard HEAD~N kullanarak sıfırlayın; burada N, geri almak istediğiniz işlem sayısıdır. Aşağıdaki örnekte, baş, havuz tarihindeki en son işleme bağlı olarak bir taahhütte geri çekilir:

  4. Zorla zorlamak için git Push --force kullanarak değişikliğe git repo'ya basın. Değişikliği zorlayın.

Git deposunu önceki bir taahhüte eklemek istiyorsanız

git pull --all
git reset --hard HEAD~1
git Push --force
29
Nanhe Kumar

Geri dön en son tüm yerel değişiklikleri kabul et ve yok say:

git reset --hard HEAD

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 işaretini yapmak için,

git reset --hard HEAD~1

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

26
tonythomas01

Bu, yeni yapılan bir taahhüde doğrudan sıfırlamanın bir başka yolu

git stash
git stash clear

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

Not: 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
Point Networks

Önceki taahhütten yapılan değişiklikleri HEAD olarak tutmak ve önceki göreve geçmek için aşağıdakileri yapın:

git reset <SHA>

Önceki taahhüdde değişiklik yapılması gerekmiyorsa, HEAD seçeneğine gidin ve tüm değişiklikleri kaldırın.

git reset --hard <SHA>
20
Vishnu Atrai

Kodlayıcının dizinini yanlışlıkla yapılan bazı değişikliklerden tamamen temizlemek için, şunları kullandık:

git add -A .
git reset --hard HEAD

Sadece 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 bir reset --hard sorunu çözmedi. git add -A . 'u önceden çalıştırarak, sıfırlama ile silinmek üzere açıkça hepsini git ile izler.

20
Chris Moschini

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

git reset --hard Origin/master

https://superuser.com/questions/273172/how-to-reset-master-to-Origin-master

19
nevster

Geri alma, taahhütleri geri alma komutudur.

git revert <commit1> <commit2> 

Numune:

git revert 2h3h23233

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

git revert HEAD~1..HEAD

ve sonra git Push yapın

16
Sireesh Yarlagadda

En Son Taahhütleri Geri Al:

git reset --hard HEAD

HEAD, yalnızca geçerli daldaki geçerli işleme (en son) bir başvuru kaynağıdır. Herhangi bir zamanda yalnızca tek bir 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 [email protected]{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 zamandaki noktadaydı.

Reset komutu birkaç seçenek ile birlikte gelir; en ilginç olanlarından biri --soft bayrağıdır. --hard yerine kullanırsanız Git, bu "geri alınmayan" işlerdeki tüm değişiklikleri yerel değişiklikler olarak saklar.

Bir Yeni Yerel Şube'deki Bir Revizyonun Geri Yüklenmesi

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

Ancak, şu anki HEAD şubenizi dokunmadan bırakmayı tercih etmeniz durumunda daha güvenli bir yolu da vardır. Git'te "şubeler" çok ucuz ve kolay olduğu için, eski revizyondan itibaren 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 old-project-state ). Eğer şu anki HEAD revizyonunda başlamasını istemiyorsanız, eski bir proje revizyonunu - geri yüklemek istediğimiz bir kesin işlem sağlamanız gerekir.

Artık old-project-state adında yeni bir şubeniz var - projenizin eski versiyonunu yansıtıyor - başka hiçbir taahhüt veya şubeye dokunmadan veya hatta çıkarmadan.

16
Lyes CHIOUKH

Durum bir acil olanlardan biriyse ve sorgunun çabuk ve kirli olmasını istediğiniz şeyi yapmak istiyorsanız şekilde, projenizin "projem" dizini altında olduğunu varsayalım:

  1. Tüm dizini kopyalayın ve "projem - kopyalayın" gibi bir şey daha arayın

  2. Yap:

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

Daha sonra sisteminizde iki sürüm bulunur ... ö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 silebilirsiniz.

Bu alınan taahhüt nedeniyle çalışmayı fiilen atmadan projenin durumunu devam ettirmek istiyorsanız bariz olan şey, dizininizi yeniden adlandırmaktır: Alınan taahhüdü içeren projeyi silin (veya geçici bir ad verin) ve " projem - "dizini" projem "e geri kopyala. O zaman muhtemelen kısa sürede başka bir taahhütte bulunun.

Git mükemmel bir eserdir, ancak sadece "anında al": - bunu açıklamaya çalışan insanlar da çok sık varsayıyorlar Diğer VCS [Sürüm Kontrol Sistemleri] bilgisi ve çok yakında çok derine dalmak ve bazen yeni başlayanları şaşırtmak için neredeyse hesaplanmış görünen şekillerde "kontrol etmek" için değiştirilebilir terimler kullanmak gibi başka suçlar işlemek.

Stresten kurtulmak için Git ile ilgili bir kitap okumak zorundasınız - Tavsiye ederim "Git ile Sürüm Kontrolü" . Ve "mecbur" derken bana (ya da daha fazla yaralarıma) güvenebilirseniz, o zaman bunu da yapabilirsiniz ŞIMDI. Git'in karmaşıklığının çoğu dallanma ve sonra yeniden birleşmeden geliyor. Ancak sorunuzdan insanların sizi bilimle körleştirmesi için bir neden yok .

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

Not: Başka bir düşünce: Git deposunu ("repo") çalışan dosyalardan farklı bir dizinde tutmak oldukça basit. Bu, yukarıdaki hızlı ve kirli çözümü kullanarak Git havuzunun tamamını kopyalamak zorunda kalmayacağınız anlamına gelir. Fryer'ın cevabına bakınız --separate-git-dir here . Ancak, uyarılmalıdır : Kopyalamadığınız bir "ayrı dizin" deponuz varsa ve daha sonra tüm sürümleri zorla sıfırladıysanız sıfırlama taahhüdüne göre, kesinlikle yapmanız gerektiği gibi, havuzunuzu düzenli olarak, diğer yerlerin yanı sıra Bulut'a (ör. Google Drive ) yedeklememişseniz, sonsuza dek kaybedilir.

Bu "Buluta yedekleme" konusu üzerinde, bir sonraki adım GitHub veya (benim görüşüme göre daha iyi) GitLab ile bir hesap açmak (elbette ücretsiz). Cloud repo'nuzu "düzgün" bir şekilde yedeklemek için düzenli olarak git Push komutunu kullanabilirsiniz. Fakat yine de, bunun hakkında konuşmak çok yakında olabilir.

15
mike rodent

İ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 tüm eklenmemiş dosyaları checkout ile yapabilirsiniz

git checkout .

Değişikliklerinizi doğrulamak için git log öğesini kontrol edin.

G&UUML;NCELLEME

Deponuzda bir ve yalnızca taahhüdünüz varsa, deneyin

git update-ref -d HEAD

13
optimistanoop

Dikkat! Bu komut, kullanıcı yanlış bir şekilde yanlış bir işlem yaptıysa, kesin işlem geçmişini kaybetmesine neden olabilir. Hata yaparsanız, biraz daha güvende olduğunuza göre, bazı durumlarda gitmenizin bir kısmını yedekleyin. :)

Benzer bir sorun yaşadım ve daha önceki bir taahhütte bulunmak istiyorum. Benim durumumda daha yeni bir taahhütte bulunma konusunda kararlı değildim, bu yüzden Hard kullandım.

Ben böyle yaptım:

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

Bu, yerel depoya geri dönecek, burada git Push -f kullandıktan sonra uzak depoyu güncelleyecektir.

git Push -f

Taahhütleriniz uzaktan itildiğinden, onları çıkarmanız gerekir. Şubenizin geliştiğini ve kökene itildiğini varsayalım.

İlk olarak geliştirmeyi Origin'den kaldırmanız gerekir:

git Push Origin :develop (note the colon)

O zaman istediğin statüde gelişmen gerekiyor, kararın EFGHIJK olduğunu varsayalım:

git reset --hard EFGHIJK

Son olarak, Push tekrar gelişir:

git Push Origin develop
11
George Ninan

GitKraken'de bunu yapabilirsiniz:

  1. Sıfırlamak istediğiniz taahhüte sağ tıklayın, seçin: Bu işleme/Sabit'e sıfırla:

 enter image description here

  1. İşleme tekrar sağ tıklayın, seçin: Mevcut dal adı/Push:

 enter image description here

  1. Zorla Zorla üzerine tıklayın:

 enter image description here

Gözlem : Sert sıfırlamadan sonraki tüm işlem geçmişi kaybolduğu ve bu işlem geri alınamaz olduğu için dikkatli olmalısınız. Ne yaptığından emin olmalısın.

10
Ângelo Polotto

Eğer son bir hatada bazı hataları düzeltmek istiyorsanız, iyi bir alternatif git commit --amend komutunu kullanmak olacaktır. 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
Upul Doluweera

İlk önce, belirli bir tarihte kesinleşmeyi tanımlayan dizeyi alın:

git rev-list -n 1 --before="2009-07-27 13:37" Origin/master

taahhüt kimliğini yazdırır, dizeyi alır (örneğin XXXX) ve şunu yapar:

git checkout XXXX
9
Luca C.

Geri alma işlemi için (veya geri dönmek için):

  1. git revert --no-commit "taahhüt kodunu sil" HEAD (ör. git revert - no-commit d57a39d HEAD)
  2. git taahhüt
  3. git Push

İki adımın üstünü deneyin ve eğer bu ne istersen onu bul git git.

Yanlış bir şey bulursanız:

git geri döndür - abort

9
Jagraj Singh

SourceTree ile çok daha kolay yapılabilir. Sadece sağ tıklayın ve aradığınız menüden 'Checkout' seçeneğini seçin.

 enter image description here

8
Marcin Szymczak

Yine bir başka basit çözüm; bunu yapmak için şubeyi değiştirmeniz gerekir, ancak daha sonra koşabilirsiniz:

git branch -f <<branchname>> 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
8
Aif

Madeni manuel olarak geri getiremedim, bir sebepten dolayı işte böyle yaptım.

  1. İstediğim şubeyi kontrol ettim, kopyaladım.
  2. En son şubeyi kontrol ettim.
  3. Daldan içeriği kopyaladım Değişikliklerin üzerine yazarak ve bunu taahhüt ederek en son şubenin dizinine istedim.
7
Demodave
git reflog

Geri dönüp yapmak istediğiniz git reflog'nun BAŞ BAŞKAN (lar) ının sayısını seçin (bu örnek için 12'yi seçtim):

git reset [email protected]{12} --hard
7
Sérgio

Bir dalı, bulduğum tarihi değiştiremediğiniz belirli bir taahhütlere geri döndürmenin en karmaşık yolu:

  1. geri alma isteğinizi yerine getirin veya dallanın.
  2. .Git/HEAD’i düzenleyin ve geri döndüğünüz şubeye referansı değiştirin.

Gibi:

echo 'ref: refs/heads/example' > .git/HEAD

Git durumunu yaparsanız, bulunduğunuz şube ile geri dönmek istediğiniz şube arasındaki tüm değişiklikleri görmelisiniz.

Her şey iyi görünüyorsa, taahhüt edebilirsiniz. Aynı olduğundan emin olmak için git diff revert..example öğesini de kullanabilirsiniz.

6
jgmjgm

Geçici olarak değişiklikleri geri almak istiyorsanız, çünkü

  • birisi üzerinde çalıştığınız veya yapıştıran işlevselliği bozan bir kod işledi

Son günlüğe kaydetme işini git günlüğünü kullanarak arayabilir ve daha sonra çalıştırabilirsiniz.

git rebase --onto <commitId>

Uzak şube tekrar çalışırken,

git pull --rebase

Bu yöntem, geçici değişiklikler için git check-out'tan daha iyidir, çünkü bağımsız bir durumda değilsiniz.

5
joseph

Aşamalı Değişiklikleri ve Taahhütleri Sıfırlama

git reset komutu, çalışma ağacınızı depoya yönlendiren en son işlemi yapan HEAD'ı değiştirmenizi sağlar. Evreleme alanını veya evreleme alanını ve çalışma ağacını değiştirir. Git'in istediğiniz gibi iş yapma yeteneği, bazen git add ile düzenlediğiniz değişikliklerde yapılan değişiklikleri geri almanız gerektiği anlamına gelir. Bunu git reset HEAD <file to change>'yi arayarak yapabilirsiniz. Değişikliklerden tamamen kurtulmak için iki seçeneğiniz var. git checkout HEAD <file(s) or path(s)>, hazırlama alanınızdaki ve çalışan ağacınızdaki değişiklikleri geri almanın hızlı bir yoludur. Ancak bu komuta dikkat edin, çünkü çalışma ağacınızdaki tüm değişiklikleri kaldırır. Git, hiç bir zaman taahhüt edilmediğinden bu değişiklikleri bilmiyor. Bu komutu çalıştırdıktan sonra bu değişiklikleri geri almanın bir yolu yoktur. Emrinde başka bir komut git reset --hard. Çalışma ağacınıza eşit derecede zarar verir - herhangi bir tamamlanmamış değişiklik veya ayarlanan değişiklikler çalıştırıldıktan sonra kaybolur. git reset -hard_ HEAD çalıştırmak, git check-out ile aynı şeyi yapar HEAD. sadece çalışması için bir dosya veya yol gerektirmez. Git sıfırlamasıyla --soft kullanabilirsiniz. Depoyu belirttiğiniz işleme geri döndürür ve tüm bu değişiklikleri aşamalı olarak yapar. Önceden düzenlediğiniz değişiklikler etkilenmez, çalışma ağacınızdaki değişiklikler de etkilenmez. Son olarak, çalışma ağacını hiçbir değişiklik yapmadan sıfırlamak için --mixed komutunu kullanabilirsiniz. Bu, yapılan değişiklikleri de reddeder.

Geri Dönen Taahhütler

Bazen hata yaparız. Paylaşılmaması gereken bir taahhüt, halka açık bir depoya gönderilir, bir taahhüdün düzeltilemeyen ve geri alınması gereken bir hata vardır veya belki de artık bu koda ihtiyacınız yoktur. git revert için çağrı yapın git revert komutu tam olarak beklediğiniz şeyi yapar. Geçmişe tersine bir taahhüt uygulayarak tek bir taahhüdü geri alır. Bazen, bir değişikliği tamamen geri almak için birkaç taahhüdü geri almanız gerekir. -no-commit öğesini kullanabilir veya Git'e geri alma işlemini gerçekleştirmesini ancak değişiklik yapmayı bırakmayı bırakmasını söylemek için -n öğesini kullanabilirsiniz. Bu, tüm geri dönüş taahhütlerini tek bir taahhütte birleştirmenize olanak tanır; bu, birkaç taahhüt içeren bir özelliği geri almanız gerektiğinde kullanışlıdır. Taahhütleri tersine çevirdiğinizden emin olun - ilk önce en yeni işleme. Aksi takdirde, henüz mevcut olmayan kodu geri almaya çalışarak Git'i karıştırabilirsiniz.

2
SAIguru011