Bir Git deposunda olduğumu söyle. Bir dosyayı silerim ve bu değişikliği taahhüt ederim. Çalışmaya devam ediyorum ve biraz daha taahhütte bulunuyorum. Sonra, bu dosyayı geri yüklemem gerektiğini fark ettim.

Kullanarak bir dosyayı teslim alabileceğimi biliyorum git checkout HEAD^ foo.bar, ancak o dosyanın ne zaman silindiğini bilmiyorum.

1. Belirli bir dosya adını silen taahhüdü bulmanın en hızlı yolu nedir?
2. Bu dosyayı çalışma kopyama geri getirmenin en kolay yolu nedir?

Günlüklerime manuel olarak göz atmam, belirli bir SHA için tüm projeye göz atmam ve daha sonra bu dosyayı el ile orijinal proje ödememe kopyalamam gerekmediğini umuyorum.

Verilen yolu etkileyen son taahhüdü bulun. Dosya HEAD işleminde olmadığından, bu işlemin silinmiş olması gerekir.

git rev-list -n 1 HEAD -- <file_path>

Ardından, caret ( ^) sembolünü kullanarak, daha önce kaydedilen sürüme bakın :

git checkout <deleting_commit>^ -- <file_path>

Veya bir komutta, $filesöz konusu dosya ise.

git checkout $(git rev-list -n 1 HEAD -- "$file")^ -- "$file"

Zsh kullanıyorsanız ve EXTENDED_GLOB seçeneğini etkinleştirdiyseniz, düzeltme işareti simgesi çalışmaz. Bunun ~1yerine kullanabilirsiniz .

git checkout $(git rev-list -n 1 HEAD -- "$file")~1 -- "$file"

1. git log --diff-filter=D --summarySilinen dosyaları ve silinen tüm taahhütleri almak için kullanın ;
2. git checkout $commit~1 path/to/file.extSilinen dosyayı geri yüklemek için kullanın .

$commit1. adımda bulduğunuz taahhüdün değeri nerede , ör.e4cf499627

Silinen tüm dosyaları bir klasöre geri yüklemek için aşağıdaki komutu girin.

git ls-files -d | xargs git checkout --

Bu soruya yeni sildiğim bir dosyayı geri yüklemek için geldim ama değişikliği henüz yapmamıştım. Kendinizi bu durumda bulmanız durumunda, tek yapmanız gereken aşağıdakilerdir:

git checkout HEAD -- path/to/file.ext

Eğer deliysen, kullan git-bisect. İşte yapmanız gerekenler:

git bisect start
git bisect bad
git bisect good <some commit where you know the file existed>

Şimdi otomatik testi yapma zamanı. Shell komutu '[ -e foo.bar ]'varsa 0 foo.bar, aksi takdirde 1 döndürür. "Run" komutu git-bisect, testin başarısız olduğu ilk komutu otomatik olarak bulmak için ikili aramayı kullanır. Verilen aralığın yarısından (iyiden kötüye) başlar ve belirtilen testin sonucuna göre yarıya indirir.

git bisect run '[ -e foo.bar ]'

Şimdi onu silmiş olan işlemdesiniz. Buradan, geleceğe geri dönebilir git-revertve değişikliği geri almak için kullanabilirsiniz ,

git bisect reset
git revert <the offending commit>

veya bir taahhütte bulunup hasarı manuel olarak inceleyebilirsiniz:

git checkout HEAD^
cp foo.bar /tmp
git bisect reset
cp /tmp/foo.bar .

Dayalı Benim yeni favori takma, bonyiii 'ın cevabı (upvoted) ve 'hakkında kendi cevap a Git takma komutuna bir tartışmayı iletin ':

git config alias.restore '!f() { git checkout $(git rev-list -n 1 HEAD -- $1)~1 -- $(git diff --name-status $(git rev-list -n 1 HEAD -- $1)~1 | grep '^D' | cut -f 2); }; f'

Birkaç dosya önce yanlışlıkla silinen bir dosyayı kaybettim?
Hızlı:

git restore my_deleted_file

Kriz önlendi.

Uyarı, Git 2.23 (Q3 2019) ile birlikte (!) Adlı deneysel komut gelir git restore.
Bu takma adı yeniden adlandırın (aşağıda gösterildiği gibi).

Robert Dailey yorumlarda aşağıdaki takma adı önermektedir :

restore-file = !git checkout $(git rev-list -n 1 HEAD -- "$1")^ -- "$1"

Ve jegan ekler yorumlarda :

Diğer adı komut satırından ayarlamak için şu komutu kullandım:

git config --global alias.restore "\!git checkout \$(git rev-list -n 1 HEAD -- \"\$1\")^ -- \"\$1\"" 

Dosya adını biliyorsanız, bu temel komutlarla kolay bir yoldur:

Söz konusu dosya için tüm taahhütleri listeleyin.

git log -- path/to/file

Son işlem (en üstteki) dosyayı silen işlemdir. Bu yüzden son taahhüdü tamamlamak için ikincisini geri yüklemeniz gerekir.

git checkout {second to last commit} -- path/to/file

Silinmiş ve kaydedilmiş bir dosyayı geri yüklemek için:

git reset HEAD some/path
git checkout -- some/path

Git 1.7.5.4 sürümünde test edilmiştir.

Yalnızca değişiklik yaptıysanız ve bir dosyayı sildiyseniz ancak taahhütte bulunmadıysanız ve şimdi değişikliklerinizden ayrıldınız

git checkout -- .

ancak silinen dosyalarınız geri dönmedi, sadece aşağıdaki komutu uygularsınız:

git checkout <file_path>

Ve presto, dosyanız geri döndü.

Bu çözümü buldum .

1. Aşağıdaki yollardan birini kullanarak dosyanın silindiği taahhüdün kimliğini alın.

   • git log --grep=*word*
   • git log -Sword
   • git log | grep --context=5 *word*
   • git log --stat | grep --context=5 *word* # hiçbir şeyi hatırlamıyorsanız önerilir

2. Gibi bir şey almalısınız:

taahhüt bfe68bd117e1091c96d2976c99b3bcc8310bebe7 Yazar: Alexander Orlov Tarih: Per Mayıs 12 23:44:27 2011 +0200

replaced deprecated GWT class
- gwtI18nKeySync.sh, an outdated (?, replaced by a Maven goal) I18n generation script

taahhüt 3ea4e3af253ac6fd1691ff6bb89c964f54802302 Yazar: Alexander Orlov Tarih: Per May 12 22:10:22 2011 +0200

3 . Şimdi bfe68bd117e1091c96d2976c99b3bcc8310bebe7 taahhüt kimliğini kullanarak:

git checkout bfe68bd117e1091c96d2976c99b3bcc8310bebe7^1 yourDeletedFile.java

Taahhüt kimliği, dosyanın zaten silinmiş olduğu komuta referansta bulunduğundan, ekleyerek yapabileceğiniz bfe68b'den hemen önce taahhüdüne başvurmanız gerekir ^1. Bu şu anlama geliyor: bfe68b'den hemen önce taahhütte bulun.

git checkout /path/to/deleted.file

git undelete path/to/file.ext

1. Bunu .bash_profile(veya bir komut kabuğunu açtığınızda yüklenen diğer ilgili dosyaya) koyun :

   git config --global alias.undelete '!sh -c "git checkout $(git rev-list -n 1 HEAD -- $1)^ -- $1" -'
   

2. Sonra kullan:

   git undelete path/to/file.ext
   

Bu takma ad önce bu dosyanın bulunduğu son taahhüdü bulmak için denetler ve sonra bu dosyanın bulunduğu son işlemden bu dosya yolunun Git çıkışını yapar. Kaynak .

Birçok durumda, Git ile birlikte coreutils (grep, sed, vb.) Kullanmak yararlı olabilir . Bu araçları zaten çok iyi tanıyorum, ama Git daha az. Silinmiş bir dosyayı aramak isteseydim, aşağıdakileri yapardım:

git log --raw | grep -B 30 $'D\t.*deleted_file.c'

Revizyon / taahhüt bulduğumda:

git checkout <rev>^ -- path/to/refound/deleted_file.c

Tıpkı diğerlerinin benden önce söylediği gibi.

Dosya artık kaldırılmadan önceki durumuna geri yüklenecektir. Etrafında tutmak istiyorsanız, onu çalışma ağacına yeniden vermeyi unutmayın.

Silinmiş dosyaları bir grup belirli bir taahhütten geri yüklemek zorunda kaldı ve iki komut ile başardı:

git show <rev> --diff-filter=D --summary --name-only --no-commit-id | xargs git checkout <rev>^ -- 
git show <rev> --diff-filter=D --summary --name-only --no-commit-id | xargs git reset HEAD 

(Her komutun sonundaki boşluğa dikkat edin.)

Dosyalar .gitignore dosyasına eklenmiş ve daha sonra ile temizlenmiştir git rm. Dosyaları geri yüklemem gerekiyordu, ama sonra onları etkisiz hale getirdim. Geri yüklemek için yüzlerce dosyam vardı ve diğer örneklerde olduğu gibi her dosya için elle bir şeyler yazmak çok yavaş olacaktı.

Aslında bu soru doğrudan Git ile ilgili, ama benim gibi biri WebStorm VCS gibi GUI araçlarıyla çalışıyor Git CLI komutlarını bilmek dışında .

Silinen dosyayı içeren yolu sağ tıklatıp Git'e gidip Geçmişi Göster'i tıklıyorum .

VCS araçları tüm revizyon trenini gösterir ve her birinin tüm taahhütlerini ve değişikliklerini görebilirim.

Sonra arkadaşımın PostAd.jsdosyayı silmesini taahhüt ederim . şimdi aşağıya bakın:

Ve şimdi, benim arzu silinen dosyayı görebiliyorum. Dosya adını çift tıklıyorum ve kurtarıyor.

Cevabımın Git komutları olmadığını biliyorum, ancak yeni başlayanlar ve profesyonel geliştiriciler için hızlı, güvenilir ve kolay. WebStorm VCS araçları Git ile çalışmak için harika ve mükemmeldir ve başka bir eklenti veya araca ihtiyaç duymaz.

Ben de aynı soruyu sordum. Bilmeden sarkan bir taahhüt yaratmıştım .

Sarkan taahhütleri listele

git fsck --lost-found

Her sarkan taahhüdü inceleyin

git reset --hard <commit id>

Sarkan işime geçtiğimde dosyalarım yeniden belirdi.

git status bu sebepten:

“HEAD detached from <commit id where it detached>”

user@bsd:~/work/git$ rm slides.tex
user@bsd:~/work/git$ git pull 
Already up-to-date.
user@bsd:~/work/git$ ls slides.tex
ls: slides.tex: No such file or directory

Silinen dosyayı geri yükleyin:

user@bsd:~/work/git$ git checkout
D       .slides.tex.swp
D       slides.tex
user@bsd:~/work/git$ git checkout slides.tex 
user@bsd:~/work/git$ ls slides.tex
slides.tex

Dosya (lar) ı silme taahhüdünü biliyorsanız, bu komutu çalıştırın; burada <SHA1_deletion>dosyayı silen komut :

git diff --diff-filter=D --name-only <SHA1_deletion>~1 <SHA1_deletion> | xargs git checkout <SHA1_deletion>~1 --

Borudan önceki kısım, yürütmede silinmiş tüm dosyaları listeler; Bunların hepsi, onları geri yüklemek için önceki taahhüdünden ödeme yapar.

Dosyanızı silen taahhüdü bulun:

git log --diff-filter=D --oneline -- path/to/file | cut -f -d ' '

Örnek çıktı:

4711174

Git 2.23 itibariyle aslında bir restorekomut var. Öyle hala deneysel sonra yazabilirsiniz ama (bu durumda 4711174) Bir çıkarıldı şey işlemek geri yüklemek için:

git restore --source=4711174^ path/to/file

Daha önce taahhütten bir şey geri yüklemek istediğimiz için taahhüt kimliğinden sonraki ^ notuna dikkat edinDosyayı .

--sourceArgüman anlatır restorenereye geri dosyası (ler) aramak için komut ve herhangi işlemek ve hatta dizin olabilir.

Bakınız: git 2.23.0 için git-restore doc

Bizim durumumuzda yanlışlıkla bir taahhütte dosyaları sildik ve bazıları daha sonra hatamızı gerçekleştirdik ve silinen tüm dosyaları geri almak istedik, ancak değiştirilenleri geri almak istedik.

Charles Bailey'nin mükemmel cevabına dayanarak, benim tek astarım:

git co $(git rev-list -n 1 HEAD -- <file_path>)~1 -- $(git diff --name-status $(git rev-list -n 1 HEAD -- <file_path>)~1 head | grep '^D' | cut -f 2)

Basit ve hassas

Her şeyden önce, bu dosyayı sahip olduğunuz en son kararlı kararlılığı alın -

git log 

Diyelim ki $ taahhütlü 1234567 buldunuz ...

git checkout <$commitid> $fileName

Bu işlem, söz konusu işlemdeki dosya sürümünü geri yükler.

Bunu yapmanın en iyi yolu için deneyin.

İlk olarak, dosyanızı silmiş olan kesinliğin kimliğini bulun. Silinen dosyaları taahhütlerin bir özetini verecektir.

git log --diff-filter = D - özet

git ödeme 84sdhfddbdddf ~ 1

Not: 84sdhfddbddd senincommit id

Bu sayede silinen tüm dosyaları kolayca kurtarabilirsiniz.

Her zaman git revertdosyayı silen taahhüdünüzü yapabilirsiniz . ( Bu, silme işleminin taahhütteki tek değişiklik olduğunu varsayar. )

> git log
commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3
Author: Dave <dave@domain.com>
Date:   Thu May 9 11:11:06 2019 -0700

    deleted readme.md

Ve çalışmaya devam ettiyseniz ve daha sonra bu silme taahhüdünü vermek istemediğinizi fark ederseniz, şunu kullanarak geri alabilirsiniz:

> git revert 2994bd

Şimdi git loggösteriyor:

> git log
Author: Dave <dave@domain.com>
Date:   Thu May 9 11:17:41 2019 -0700

    Revert "deleted readme"

    This reverts commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3.

Ve readme.mddepoya geri yüklendi.

Ayrıca yerel bir dizine önceki bir dosyayı almak için aşağıdaki kodu kullanarak bu sorun var:

git checkout <file path with name>

Aşağıdaki örnek benim için çalışıyor:

git checkout resources/views/usaSchools.blade.php

$ git log --diff-filter=D --summary  | grep "delete" | sort

Silme işlemi tamamlanmadıysa, aşağıdaki komut silinen dosyayı çalışma ağacında geri yükler.

$ git checkout -- <file>

Aşağıdaki komutu kullanarak çalışma ağacındaki tüm silinen dosyaların bir listesini alabilirsiniz.

$ git ls-files --deleted

Silme işlemi tamamlandıysa, bulunduğu yeri bulun, sonra dosyayı bu işlemden kurtarın.

$ git rev-list -n 1 HEAD -- <file>
$ git checkout <commit>^ -- <file>

Kurtarılacak dosyanın yolunu arıyorsanız, aşağıdaki komut silinen tüm dosyaların bir özetini görüntüler.

$ git log --diff-filter=D --summary

Git ile silinen tüm dosyaları geri yüklemek için şunları da yapabilirsiniz:

git checkout $(git ls-files --deleted)

Burada git ls-files --deleted, silinen tüm dosyaları listeler ve git checkout $(git command)bir parametredeki dosya listesini geri yükler.