Bir dosyayı belirli bir düzeltmeye nasıl sıfırlayabilir veya geri döndürebilirim?

Bir dosya grubunun parçası olarak birkaç kez işlenen bir dosyada bazı değişiklikler yaptım, ancak şimdi üzerindeki değişiklikleri önceki bir sürüme sıfırlamak / geri döndürmek istiyorum.

İhtiyacım olan revizyonu bulmak için bir git logile birlikte yaptım git diff, ancak dosyayı geçmişte eski durumuna nasıl geri getireceğimi bilmiyorum.

İstediğiniz taahhüdün karmasını varsayarsak c5f567:

git checkout c5f567 -- file1/to/restore file2/to/restore

Git ödeme adam sayfası daha fazla bilgi verir.

Daha önce taahhüdüne geri dönmek istiyorsanız c5f567, ekleyin ~1(burada 1, geri dönmek istediğiniz taahhütlerin sayısıdır, herhangi bir şey olabilir):

git checkout c5f567~1 -- file1/to/restore file2/to/restore

Bir yan not olarak, bu komuttan her zaman rahatsız oldum çünkü hem sıradan şeyler (dallar arasında değiştirme) hem de olağandışı, yıkıcı şeyler (çalışma dizinindeki değişiklikleri atmak) için kullanılır.

Diff komutunu kullanarak bir dosyada yapılan değişiklikleri hızlı bir şekilde inceleyebilirsiniz:

git diff <commit hash> <filename>

Ardından belirli bir dosyayı bu işleme geri döndürmek için reset komutunu kullanın:

git reset <commit hash> <filename>

--hardYerel değişiklikleriniz varsa seçeneği kullanmanız gerekebilir .

Yol noktalarını yönetmek için iyi bir iş akışı, zaman çizelgenizdeki noktaları temiz bir şekilde işaretlemek için etiketleri kullanmaktır. Son cümlenizi tam olarak anlayamıyorum ama isteyebileceğiniz şey, bir dalı daha önceki bir noktadan saptırmak. Bunu yapmak için kullanışlı ödeme komutunu kullanın:

git checkout <commit hash>
git checkout -b <new branch name>

Daha sonra, bu değişiklikleri birleştirmeye hazır olduğunuzda bunu ana hattınıza yasatabilirsiniz:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

En uygunsa SHA-1 de dahil olmak üzere git komutuna ilişkin herhangi bir referans kullanabilirsiniz. Mesele şu ki, komut şuna benzer:

git checkout [commit-ref] -- [filename]

git checkout -- foo

Bu fooHEAD olarak sıfırlanacaktır . Ayrıca şunları da yapabilirsiniz:

git checkout HEAD^ foo

bir revizyon için, vb.

Ve en sık ihtiyaç duyulan son kararlı sürüme geri dönmek için bu daha basit komutu kullanabilirsiniz.

git checkout HEAD file/to/restore

Şimdi aynı sorunu yaşadım ve bu cevabı anlaması en kolay buldum ( commit-refgeri dönmek istediğiniz günlük değişikliğinin SHA değeri):

git checkout [commit-ref] [filename]

Bu, eski sürümü çalışma dizininize koyar ve oradan isterseniz bunu uygulayabilirsiniz.

Ne kadar taahhütte bulunmanız gerektiğini biliyorsanız, şunları kullanabilirsiniz:

git checkout master~5 image.png

Bu, masterdalda olduğunuzu ve istediğiniz sürümün 5 geri olduğunu varsayar .

Sanırım buldum .... http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Bazen sadece geri dönmek ve belli bir noktadan sonraki her değişikliği unutmak istersiniz çünkü hepsi yanlıştır.

İle başla:

$ git log

son taahhütlerin bir listesini ve bunların SHA1 karmasını gösterir.

Sonra şunu yazın:

$ git reset --hard SHA1_HASH

durumu belirli bir taahhüde geri yüklemek ve tüm yeni taahhütleri kayıttan kalıcı olarak silmek için.

Bu benim için çalıştı:

git checkout <commit hash> file

Ardından değişikliği yapın:

git commit -a

"Geri alma" derken dikkatli olmalısınız. $ A işleminde bir dosyanın bir sürümüne sahipseniz ve daha sonra iki ayrı işlemde $ B ve $ C'de iki değişiklik yaptıysanız (gördüğünüz şey dosyanın üçüncü yinelemesidir) ve " İlkine geri dönmek istiyorum ", gerçekten mi demek istiyorsun?

Hem ikinci hem de üçüncü yinelemedeki değişikliklerden kurtulmak istiyorsanız, çok basittir:

$ git checkout $A file

ve sonra sonucu taahhüt edersiniz. Komut "Dosya $ A tarafından kaydedilen durumdan dosyayı kontrol etmek istiyorum" sorusunu sorar.

Öte yandan, kastettiğiniz şey ikinci yinelemenin getirdiği değişiklikten (yani B $ taahhüt) kurtulmaktır, C $ 'ın dosyaya yaptığı taahhüdü korurken B $' a geri dönmek istersiniz

$ git revert $B

B $ taahhüdünü kim oluşturduysa, çok disiplinli olmayabilir ve aynı taahhütte tamamen alakasız bir değişiklik yapmış olabilir ve bu geri dönüş, rahatsız edici değişiklikler gördüğünüz dosya dışındaki dosyalara dokunabilir , bu yüzden yaptıktan sonra sonucu dikkatlice kontrol etmek isteyebilirsiniz yani.

git checkout fooÇalışma kopyası adlı bir dizinde ise eğlenceli bir şekilde çalışmaz foo; Ancak hem git checkout HEAD foove git checkout ./fooyapacaktır:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

Nasıl rebaseçalışır:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Varsayalım

---o----o----o----o  master
    \---A----B       <my branch>

İlk iki komut ... taahhüt git git checkout git rebase master

... şubeye uygulamak istediğiniz değişikliklerin dalına göz masteratın. rebaseKomut gelen kaydedilmesini alır <my branch>(bulunmayan masterbaşkanına) ve yeniden uygular onları master. Başka bir deyişle, ilk taahhüdün ebeveyni <my branch>artık mastertarihte önceki bir taahhüt değil, şu anki başkanıdır master. İki komut aynıdır:

git rebase master <my branch>

Hem "temel" hem de "değiştir" dalları açık olduğundan bu komutu hatırlamak daha kolay olabilir.

. Nihai geçmiş sonucu:

---o----o----o----o   master
                   \----A'----B'  <my branch>

Son iki komut ...

git checkout master
git merge <my branch>

... tüm <my branch>değişiklikleri uygulamak için hızlı ileri bir birleştirme yapın master. Bu adım olmadan, rebase taahhüdü eklenmez master. Nihai sonuç:

---o----o----o----o----A'----B'  master, <my branch>

masterve <my branch>her ikisi de referans B'. Ayrıca, bu noktadan sonra <my branch>referansı silmek güvenlidir .

git branch -d <my branch>

Git v2.23.0'dan itibaren sorumlu olanın bir kısmını kabul etmesi gereken yeni bir git geri yükleme yöntemi vardır git checkout(kabul edilen cevap bile git checkoutoldukça kafa karıştırıcıdır). Github blogundaki değişikliklerin önemli noktalarını görün .

Bu komutun varsayılan davranışı, sourceparametreden gelen içerikle çalışan bir ağacın durumunu geri yüklemektir (bu durumda bir sağlama karması olacaktır).

Yani Greg Hewgill'in cevabına dayanarak (taahhüt karmasının olduğu varsayılarak c5f567) komut şöyle görünecektir:

git restore --source=c5f567 file1/to/restore file2/to/restore

Veya c5f567'den önce bir taahhüdün içeriğine geri yüklemek isterseniz:

git restore --source=c5f567~1 file1/to/restore file2/to/restore

Hedef Dosya için İlk Sıfırlama Başlığı

git reset HEAD path_to_file

Bu Dosyadan İkinci Ödeme

git checkout -- path_to_file

git-takma adlar, awk ve kabuk fonksiyonları kurtarmaya!

git prevision <N> <filename>

burada <N>dosyanın geri alınacak revizyon sayısı <filename>.
Örneğin, tek bir dosyanın hemen önceki revizyonunu kontrol etmek için şunu x/y/z.cçalıştırın:

git prevision -1 x/y/z.c

Git prevision nasıl çalışır?

Aşağıdakileri gitconfig

[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

Komut temel olarak

• git logbelirtilen dosyada a gerçekleştirir ve
• dosyanın geçmişindeki uygun komut kimliğini seçer ve
• git checkoutbelirtilen dosya için command- id'de a yürütür .

Esasen, bu durumda manuel olarak yapacağınız her şey,
güzel, verimli bir git-alias'a sarıldı - git-prevision

Ben fiş zorunda EasyGit tecrübeli kullanıcılara kafa karıştırıcı olmadan acemiler için git daha cana yapmak için bir sarıcı olan burada. Yaptığı şeylerden biri daha fazla anlam vermekgit revert . Bu durumda, sadece şunu söylerdiniz:

eg revert foo/bar foo/baz

Bir dosyayı önceki bir işleme geri döndürmek istediğinizde (ve zaten geri almak istediğiniz dosyayı) kullanmak için

git checkout HEAD^1 path/to/file

veya

git checkout HEAD~1 path/to/file

Sonra sadece sahne ve "yeni" sürümünü taahhüt.

Bir taahhüdün bir birleşme durumunda iki ebeveyne sahip olabileceği bilgisiyle donanmış olarak, HEAD ^ 1'in ilk ebeveyn olduğunu ve HEAD ~ 1'in ikinci ebeveyn olduğunu bilmelisiniz.

Ağaçta yalnızca bir ebeveyn varsa her ikisi de çalışır.

Burada birçok öneri, en çizgileri boyunca git checkout $revision -- $file. Birkaç belirsiz alternatif:

git show $revision:$file > $file

Ayrıca, sadece belirli bir sürümü geçici olarak görmek için bunu çok kullanıyorum:

git show $revision:$file

veya

git show $revision:$file | vim -R -

(OBS: çalışmak için göreceli bir yol ise $fileöneki olmalıdır )./git show $revision:$file

Ve daha da garip:

git archive $revision $file | tar -x0 > $file

Ancak, Not git checkout ./foove git checkout HEAD ./foo olmayan tam olarak aynı şey; konuşma konusu olan mesele:

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

(İkincisi adddosyayı dizindeki aşamalar, ancak işlem yapılmaz .)

Git checkout ./fooyolundan Geri döndürme araçları ./foogelen indeksi ; eklemeHEAD Git'e HEADbunu yapmadan önce dizindeki bu yolu revizyonuna döndürmesini söyler .

Benim için cevabın hiçbiri gerçekten net görünmüyordu ve bu yüzden çok kolay görünen benimkini eklemek istiyorum.

Bir taahhüdüm var abc1ve bundan sonra bir dosyada birkaç (veya bir değişiklik) yaptımfile.txt .

Şimdi dosyada bir şeyleri karıştırdığımı file.txtve önceki bir işleme geri dönmek istediğimi söyleyin abc1.

1.git checkout file.txt .: Bu, ihtiyacınız yoksa yerel değişiklikleri kaldıracak

2 git checkout abc1 file.txt.: bu, dosyanızı istediğiniz yere getirecektir sürüme

3 git commit -m "Restored file.txt to version abc1".: bu geri dönüşünüzü gerçekleştirecektir.

4. git push : Bu, uzak depodaki her şeyi zorlar

Adım 2 ve 3 arasında git statusneler olduğunu anlamak için elbette yapabilirsiniz . Genellikle file.txtzaten eklenmiş olanları görmelisiniz ve bu yüzden a'ya gerek yoktur git add.

1. Git dosyayı belirli bir işleme geri döndürür

git checkout Last_Stable_commit_Number -- fileName

2. dosyayı belirli bir şubeye geri döndürün

git checkout branchName_Which_Has_stable_Commit fileName

Dosyanın önceki bir tamamlama sürümüne gitmek için, taahhüt numarasını alın, diyelim ki eb917a1

git checkout eb917a1 YourFileName

Sadece son taahhüt edilen sürüme geri dönmeniz gerekiyorsa

git reset HEAD YourFileName
git checkout YourFileName

Bu sizi dosyanın son taahhütlü durumuna götürecektir.

git checkout ref | commitHash - filePath

Örneğin

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

Burada birçok cevap kullanıldığını iddia ediyor git reset ... <file>ya da git checkout ... <file>bunu yaparak, <file>geri almak istediğiniz taahhütten sonra yapılan tüm değişiklikleri kaybedeceksiniz.

Tek tek dosya üzerinde taahhüt sizi geri dönme eğilimi değişiklikleri isterseniz sadece, tıpkı git revertyapmak ama sadece bir dosya (veya bir alt kümesi dosyalarını işlemek demek), ben her ikisini de kullanmak öneririm git diffve git applyile (böyle <sha>bir karma = geri almak istediğinizi taahhüt edin):

git diff <sha>^ <sha> path/to/file.ext | git apply -R

Temel olarak, önce geri döndürmek istediğiniz değişikliklere karşılık gelen bir yama oluşturur ve ardından bu değişiklikleri bırakmak için yamayı tersine uygular.

Elbette, geri döndürülen hatlar <sha1>ve HEAD(çatışma) arasında herhangi bir taahhütle değiştirilmişse işe yaramayacaktır .

kullanım git log sonra belirli sürümü ve kullanım için karma anahtarı elde etmekgit checkout <hashkey>

Not: Sonuncundan önce karmayı yazmayı unutmayın. Son karma geçerli konumunuzu (HEAD) gösterir ve hiçbir şeyi değiştirmez.

Açıkçası birinin ya git üzerine anlaşılır bir kitap yazması ya da git belgelerinde daha iyi açıklanması gerekir. Aynı sorunla karşı karşıya olduğumu tahmin ettim

cd <working copy>
git revert master

Görünen son taahhüdü geri alacaktı.

Ian

4 adımda yapabilirsiniz:

1. özel olarak geri döndürmek istediğiniz dosyayla tüm taahhüdü geri döndürün - dalınızda yeni bir taahhüt oluşturur
2. kesin sıfırlama - kesinleştirmeyi kaldırır ve değişiklikleri çalışma alanına taşır
3. geri almak ve işlemek için dosyaları seçin
4. çalışma alanınızdaki diğer tüm dosyaları bırakın

Terminalinize yazmanız gerekenler :

1. git revert <commit_hash>
2. git reset HEAD~1
3. git add <file_i_want_to_revert> && git commit -m 'reverting file'
4. git checkout .

iyi şanslar

Bu çok basit bir adım. Ödeme dosyasını istediğimiz taahhüt kimliğine, burada daha önce bir taahhüt kimliğine, ve sonra sadece git taahhüt değişiklik ve biz bitti.

# git checkout <previous commit_id> <file_name>
# git commit --amend

Bu çok kullanışlı. Herhangi bir dosyayı taahhüt üstündeki herhangi bir önceki taahhüt kimliğine getirmek istiyorsak, kolayca yapabiliriz.

git revert <hash>

Belirli bir taahhüdü geri alır. Sadece git reverten son taahhüdü etkilediğini düşündüğünüz anlaşılıyor.

Belirli bir dosyadaki bir değişikliği geri almak istiyorsanız ve bu işlem o dosyadan daha fazla değiştiğinde, bu sorununuzu çözmez.

son işlemlerinizde yanlış bir dosya yaparsanız, talimatları izleyin:

1. açık kaynak ağacı, bu taahhüde geçiş

2. satırları değiştirin ve hatalı dosyanın kesin olarak gönderildiği taahhüdünüzü bulun

3. bu taahhütte değişikliklerinizin listesini görebilirsiniz
4. seçin ve ardından ... düğmelerini sağ taraftaki tıklayın ... ters dosyayı tıklayın
5. sol alt taraftaki dosya durumu sekmesinde görebilirsiniz, sonra da sabiti tıklayın:

6. visual studio kodunuzu açın ve kaldırılan dosyalarınızı taahhüt ederek geri dönün
7. sonuçta, kaynak ağacında son taahhüdünüzdeki sonuçları görebilirsiniz