Jak Mogę zresetować lub przywrócić plik do określonej wersji?

Możesz szybko przejrzeć zmiany wprowadzone w pliku za pomocą polecenia diff:

git diff <commit hash> <filename>

Następnie, aby przywrócić określony plik do tego commita, użyj polecenia reset:

git reset <commit hash> <filename>

Może być konieczne użycie opcji --hard, Jeśli masz lokalne modyfikacje.

Dobrym przepływem pracy do zarządzania waypointami jest używanie znaczników do czystego oznaczania punktów na osi czasu. Nie do końca rozumiem twoje ostatnie zdanie, ale możesz chcieć oddzielić gałąź od poprzedniego punktu w czasie. Aby to zrobić, użyj przydatne polecenie checkout:

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

Możesz następnie zmienić nazwę linii głównej, gdy będziesz gotowy do scalenia tych zmian:

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

Możesz użyć dowolnego odniesienia do zatwierdzania Git, włączając w to SHA-1, jeśli jest to najwygodniejsze. Chodzi o to, że komenda wygląda tak:

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

git checkout -- foo

To zresetuje foo do głowy. Możesz także:

git checkout HEAD^ foo

Dla jednej rewizji wstecz, itp.

I aby powrócić do ostatniej zatwierdzonej wersji, która jest najczęściej potrzebna, możesz użyć tego prostszego polecenia.

git checkout HEAD file/to/restore

Właśnie miałem ten sam problem i znalazłem odpowiedź najłatwiejszą do zrozumienia (commit-ref jest wartością SHA zmiany w dzienniku, do którego chcesz wrócić):

git checkout [commit-ref] [filename]

Spowoduje to umieszczenie tej starej wersji w katalogu roboczym i stamtąd możesz ją zatwierdzić, jeśli chcesz.

Jeśli wiesz ile commitów musisz cofnąć, możesz użyć:

git checkout master~5 image.png

Zakłada to, że jesteś w gałęzi master, a żądana wersja to 5 commitów z powrotem.

Chyba go znalazłem....od http://www-cs-students.stanford.edu / ~blynn/gitmagic/ch02.html

Czasami po prostu chcesz wrócić i zapomnieć o każdej zmianie po pewnym punkcie, ponieważ wszystkie są w błędzie.

Zacznij od:

$ git log

Który pokazuje listę ostatnich commitów oraz ich skróty SHA1.

Następny, typ:

$ git reset --hard SHA1_HASH

Aby przywrócić stan do danego commita i usunąć wszystkie nowsze commity z rekordu na stałe.

To mi pomogło:

git checkout <commit hash> file

Następnie zatwierdź zmianę:

git commit -a

Musisz być ostrożny, kiedy mówisz "wycofaj się". Jeśli używałeś jednej wersji pliku w commicie $a, a później wprowadziłeś dwie zmiany w dwóch osobnych commitach $B i $C (więc widzisz trzecią iterację pliku), i jeśli mówisz "Chcę wrócić do pierwszej", to czy naprawdę masz to na myśli?

Jeśli chcesz pozbyć się zmian zarówno drugiej, jak i trzeciej iteracji, jest to bardzo proste:

$ git checkout $A file

A następnie zatwierdzasz wynik. Komenda pyta "Chcę sprawdzić plik ze stanu zarejestrowanego przez commit $A".

Z drugiej strony, miałeś na myśli pozbycie się zmiany wprowadzonej przez drugą iterację (np. commit $B), zachowując to, co commit $C zrobił w pliku, chciałbyś przywrócić $B

$ git revert $B

Zauważ, że ktokolwiek stworzył commit $B, mógł nie być zbyt zdyscyplinowany i mógł popełnić całkowicie niepowiązane zmiany w tym samym commicie, a to przywrócenie może dotykać plików innych niż plik widzisz obrażanie zmian, więc możesz chcieć dokładnie sprawdzić wynik po zrobieniu tego.

Od wersji git v2. 23. 0 istnieje nowa metoda Git restore , która ma zakładać część tego, za co git checkout była odpowiedzialna (nawet przyjęta odpowiedź mówi, że git checkout jest dość myląca). Zobacz najważniejsze zmiany na github blog .

Domyślnym zachowaniem tego polecenia jest przywrócenie stanu drzewa roboczego z zawartością pochodzącą z parametru source (który w Twoim przypadku będzie skrótem zatwierdzania).

Więc na podstawie odpowiedzi Grega Hewgilla (zakładając, że commit hash to c5f567) Komenda wyglądałaby tak:

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

Lub jeśli chcesz przywrócić zawartość jednego commita przed c5f567:

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

, git checkout foo nie zadziała, jeśli kopia robocza znajduje się w katalogu o nazwie foo; jednak zarówno git checkout HEAD foo, jak i git checkout ./foo będą:

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

Oto jak rebase działa:

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

Załóżmy, że masz

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

Pierwsze dwa polecenia ... commit Git checkout Git rebase master

... sprawdź gałąź zmian, którą chcesz zastosować do gałęzi master. Polecenie rebase pobiera commity z <my branch> (które nie znajdują się w master) i przywraca je do głowicy master. Innymi słowy, rodzic pierwszego commita w <my branch> nie jest już poprzednim commitem w master historia, ale obecny szef master. Dwa polecenia są takie same jak:

git rebase master <my branch>

Może być łatwiej zapamiętać to polecenie, ponieważ zarówno gałęzie" base", jak i "modify" są jawne.

. Ostateczny wynik historii to:

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

Ostatnie dwa polecenia ...

git checkout master
git merge <my branch>

... wykonaj szybkie scalanie, aby zastosować wszystkie zmiany <my branch> na master. Bez tego kroku commit rebase nie zostanie dodany do master. Wynik końcowy jest:

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

master i <my branch> oba odniesienia B'. Ponadto, od tego momentu można bezpiecznie usunąć odniesienie <my branch>.

git branch -d <my branch>

Pierwsza Głowica Resetująca Dla Pliku Docelowego

git reset HEAD path_to_file

Second Checkout That File

git checkout -- path_to_file

1. Git revert file to a specific commit

git checkout Last_Stable_commit_Number -- fileName

2.Git revert file to a specific branch

git checkout branchName_Which_Has_stable_Commit fileName

Git-aliasy, awk i Shell-funkcje na ratunek!

git prevision <N> <filename>

Gdzie <N> jest liczbą wersji pliku do wycofania dla pliku <filename>.
Na przykład, aby pobrać natychmiastową poprzednią wersję pojedynczego pliku x/y/z.c, Uruchom

git prevision -1 x/y/z.c

Jak działa git prevision?

Dodaj do swojego gitconfig

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

Komenda

• wykonuje git log na podanym pliku i
• wybiera odpowiedni commit-id w historii pliku i
• wykonuje git checkout do commit-id dla podanego pliku.

zasadniczo, wszystko, co można zrobić ręcznie w tej sytuacji,
zawinięte w jeden piękny, skuteczny Git-alias - git-prevision

Wiele sugestii tutaj, większość wzdłuż linii git checkout $revision -- $file. Kilka niejasnych alternatyw:

git show $revision:$file > $file

A także, używam tego często tylko, aby zobaczyć konkretną wersję tymczasowo:

git show $revision:$file

Lub

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

(OBS: $file musi być poprzedzony prefiksem ./, jeśli jest to ścieżka względna do działania git show $revision:$file)

I jeszcze bardziej dziwne:

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

Muszę podłączyć EasyGit tutaj, który jest opakowaniem, aby git był bardziej przystępny dla nowicjuszy bez mylenia doświadczonych użytkowników. Jedną z rzeczy, które robi to nadaje więcej znaczeń git revert. W tym przypadku można po prostu powiedzieć:

eg revert foo/bar foo/baz

W przypadku, gdy chcesz przywrócić plik do poprzedniego commita (i plik, który chcesz przywrócić już zatwierdzony), możesz użyć

git checkout HEAD^1 path/to/file

Lub

git checkout HEAD~1 path/to/file

Następnie ustaw i zatwierdź "nową" wersję.

Mając świadomość, że commit może mieć dwóch rodziców w przypadku połączenia, powinieneś wiedzieć, że HEAD^1 jest pierwszym rodzicem, a HEAD~1 jest drugim rodzicem.

Albo zadziała, jeśli w drzewie jest tylko jeden rodzic.

Należy jednak pamiętać, że git checkout ./foo i git checkout HEAD ./foo nie są dokładnie to samo; przypadek w punkcie:

$ 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

(drugi add umieszcza plik w indeksie, ale nie otrzymuje zaangażowana.)

Git checkout ./foo oznacza odwrócenie ścieżki ./foo z indeksu ; dodanie HEAD instruuje Git do przywrócenia tej ścieżki w indeksie do jej HEAD przegląd przed zrobieniem tego.

Dla mnie żadna z odpowiedzi nie wydawała się naprawdę jasna i dlatego chciałbym dodać moją, która wydaje się super łatwa.

Mam commit abc1 i po nim zrobiłem kilka (lub jedną modyfikację) do pliku file.txt.

Teraz powiedz, że coś namieszałem w pliku file.txt i chcę wrócić do poprzedniego commita abc1.

1.git checkout file.txt: spowoduje to usunięcie lokalnych zmian, jeśli ich nie potrzebujesz

2.git checkout abc1 file.txt : to przyniesie twoje akta do twojego wanted version

3.git commit -m "Restored file.txt to version abc1" : to spowoduje Twoją rewersję.

1. git push : to wypchnie wszystko na zdalnym repozytorium

Pomiędzy krokiem 2 i 3 Oczywiście możesz zrobić git status, aby zrozumieć, co się dzieje. Zazwyczaj powinieneś zobaczyć file.txt już dodane i dlatego nie ma potrzeby stosowania git add.

Aby przejść do poprzedniej wersji zatwierdzenia pliku, pobierz Numer zatwierdzenia, powiedzmy eb917a1 then

git checkout eb917a1 YourFileName

Jeśli chcesz wrócić do ostatniej wersji

git reset HEAD YourFileName
git checkout YourFileName

To po prostu przeniesie Cię do ostatniego zatwierdzonego stanu pliku

Wiele odpowiedzi twierdzi, że używa git reset ... <file> lub git checkout ... <file>, ale w ten sposób stracisz wszystkie modyfikacje <file> popełnione po zatwierdzeniu, które chcesz przywrócić.

Jeśli chcesz przywrócić zmiany z jednego commita tylko na jednym pliku, tak jak zrobiłby to git revert, ale tylko dla jednego pliku (lub powiedzmy podzbiór plików commitów), sugeruję użycie zarówno git diff jak i git apply w ten sposób (z <sha> = hash commita, który chcesz przywrócić):

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

Zasadniczo, najpierw wygeneruje patch odpowiadając zmianom, które chcesz przywrócić, a następnie odwrócić-zastosuj łatkę, aby usunąć te zmiany.

Oczywiście, nie będzie działać, jeśli rewertowane linie zostały zmodyfikowane przez commit pomiędzy <sha1> i HEAD (konflikt).

Git checkout ref / commitHash -- filePath

Np.

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

To bardzo prosty krok. Checkout plik do commit ID chcemy, tutaj jeden commit id przed, a następnie po prostu git commit amend i jesteśmy gotowe.

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

Użyj git log, aby uzyskać klucz hash dla konkretnej wersji, a następnie użyj git checkout <hashkey>

Uwaga: nie zapomnij wpisać hasha przed ostatnim. Ostatni hash wskazuje Twoją aktualną pozycję (HEAD) i nic nie zmienia.

Oczywiście ktoś musi albo napisać zrozumiałą książkę o git, albo git musi być lepiej wyjaśniony w dokumentacji. W obliczu tego samego problemu domyśliłem się, że

cd <working copy>
git revert master

Cofnie ostatni commit, który wydaje się robić.

Ian

Możesz to zrobić w 4 krokach:

1. przywróci cały commit za pomocą pliku, który chcesz przywrócić - utworzy on nowy commit w Twojej gałęzi
2. soft reset that commit-usuwa commit i przenosi zmiany do obszaru roboczego
3. zaznacz ręcznie pliki, aby je przywrócić i zatwierdzić
4. upuść wszystkie inne pliki w obszarze roboczym

Co trzeba wpisać w swoim terminal :

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 .

Powodzenia

git revert <hash>

Przywróci dany commit. Wygląda na to, że myślisz, że git revert dotyczy tylko ostatniego commita.

To nie rozwiąże Twojego problemu, jeśli chcesz przywrócić zmianę w określonym pliku, a ten commit zmienił się bardziej niż ten plik.

Jeśli zatwierdzisz niewłaściwy plik w ostatnim zatwierdzeniu postępuj zgodnie z instrukcją:

1. open source tree, zmień na ten commit

1. Zmień linie i znajdź swój commit, że niewłaściwy plik wysłany jako commit

1. możesz zobaczyć listę zmian w tym zatwierdzeniu
2. wybierz go, a następnie kliknij na ... przyciski po prawej stronie ... kliknij odwrotny plik
3. wtedy możesz zobaczyć it na karcie status pliku w lewym dolnym rogu następnie kliknij unstage:

1. Otwórz kod programu visual studio i przywróć go, zatwierdzając usunięte pliki
2. po nich wszystkich możesz zobaczyć wyniki w ostatnim zatwierdzeniu w drzewie źródłowym