Reset lub zwrotu określonego pliku do określonej wersji Git?

dokonałem pewnych zmian w pliku, który został nagrany kilka razy jako część grupy plików, ale teraz chcę zresetować/zwrot zmiany na nim do poprzedniej wersji.

zrobiłem git log wraz z git diff aby znaleźć wersję muszę, ale po prostu nie wiem, jak przywrócić plik do poprzedniego stanu w przeszłości.


zakładając, że hash zatwierdzenia, którą chcesz, jest c5f567:

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

git checkout man strona daje więcej informacji.

jeśli chcesz wrócić do zatwierdzenia przed c5f567 dodaj ~1 (działa z dowolnego numeru):

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

na marginesie, zawsze mi było niewygodnie z tym zespołem, bo jest ona wykorzystywana zarówno do zwykłych rzeczy (zmiana między oddziałami), jak i nietypowych, szkodliwe rzeczy (odrzucenie zmian w pracy skorowidz.)


możesz szybko wyświetlić zmiany wprowadzone w pliku za pomocą polecenia diff:

git diff <commit hash> <filename>

następnie do zwrotu określonego pliku do tego zatwierdzenia, należy użyć polecenia reset:

git reset <commit hash> <filename>

być może Trzeba będzie użyć jeśli masz lokalne zmiany.

dobry workflow do zarządzania punktami trasy jest użycie tagów dla czystej oznaczenia punktów na osi czasu. Nie do końca rozumiem twoje ostatnie zdanie, ale to, że można chcieć, to odrzucić gałąź od poprzedniej momencie czasu. W tym celu skorzystaj z wygodnego zespołem checkout:

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

następnie można przenieść to na swoją linię podstawową, kiedy będziecie gotowi połączyć te zmiany:

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

można użyć dowolny link na utrwalenie git, w tym SHA-1, jeżeli jest to najbardziej wygodne. Rzecz w tym, że zespół wygląda tak:

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


git checkout -- foo

to zresetuje foo głowy. Można również:

git checkout HEAD^ foo

dla jednego przeglądu temu itp.


i aby powrócić do ostatniej dostępnej wersji, która najczęściej jest niezbędna, można użyć tego bardziej proste polecenie.

git checkout HEAD file/to/restore

miałem ten sam problem i znalazłem odpowiedź najłatwiej zrozumieć (commit-ref to wartość SHA zmiany w czasopiśmie, do którego chcesz wrócić):

git checkout [commit-ref] [filename]

To umieści tę starą wersję w swój katalog roboczy, i stamtąd można ją zablokować, jeśli chcesz.


Jeśli wiesz, ile commits musisz wrócić, można użyć:

git checkout master~5 image.png

to sugeruje, że na master gałąź, a wersja, którą chcesz, to 5 commits temu.


myślę, że go znalazł....od http://www-cs-students.stanford.edu / ~blynn/gitmagic/ch02.html

czasami po prostu chcesz wrócić i zapomnieć o każdej zmianie po upływie pewnego momentu, bo wszystkie są błędne.

uruchom:

$ git log

który pokazuje listę ostatnio commits i ich sumy kontrolne SHA1.

dalej, typu:

$ git reset --hard SHA1_HASH

przywracanie stanu do zadanej zatwierdzenia i usunąć wszystkie nowe commit z wpisów na zawsze.


to zadziałało dla mnie:

git checkout <commit hash> file

aby zatwierdzić wprowadzone zmiany:

git commit -a

trzeba być ostrożnym, kiedy mówisz "wycofanie". Jeśli korzystałeś z jedną wersję pliku w commit $A, a następnie wprowadzili dwie zmiany w dwóch oddzielnych commit $B i $C (tak, że widać trzeciej iteracji pliku), i jeśli mówisz: "chcę wrócić do pierwszego", naprawdę to masz na myśli?

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

$ git checkout $A file

i następnie zatwierdzasz wynik. Zespół pyta:"chcę sprawdzić, czy w pliku ze stanu nagranego blokadą $A".

Z drugiej strony, chcesz pozbyć się zmiany, wpisanego drugiej iteracji (tj. blokadą $B), zachowując przy tym to, że commit $C wykonane z plikiem chcesz odzyskać $B

$ git revert $B

zauważ, że ten, kto stworzył commit $B, być może, nie był bardzo zdyscyplinowany i, być może, popełnił zupełnie niezwiązaną zmiana w tym samym zatwierdzonej kopii, i to zwrot może dotknąć innych plików widzisz obraźliwe zmiany, więc można dokładnie sprawdzić wynik po.


zabawne, "git checkout foo" nie będzie działać, jeśli kopia robocza znajduje się w katalogu o nazwie foo; jednak, jak "git checkout HEAD foo", jak i " git checkout ./ foo ' will:

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

tutaj 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>

dwie pierwsze drużyny ... popełniać git checkout PIP relokacji kreator

... sprawdź gałąź zmian, które chcesz zastosować do master oddziału. Element rebase zespół bierze commity od <my branch> (którzy nie znaleźli w master) i stosuje je do głowy master. Innymi słowy, rodzic najpierw odbyć w <my branch> już nie jest poprzednim blokadą w master historia, ale obecny szef master. Dwie drużyny są takie same, jak:

git rebase master <my branch>

może być łatwiejsze do zapamiętania tego polecenia, ponieważ gałęzie" base "i" modify " są jasne.

. Ostateczny wynik historii:

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

dwie ostatnie drużyny ...

git checkout master
git merge <my branch>

... wykonaj szybkie połączenie, aby zastosować all <my branch> zmiany na master. Bez tego kroku blokada rebase nie zostanie dodany do master. Ostateczny wynik:

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

master a <my branch> a B'. Ponadto, od tego momentu można bezpiecznie usunąć <my branch> link.

git branch -d <my branch>

git-aliasy, awk i shell-opcje na pomoc!

git prevision <N> <filename>

tutaj <N> to ilość wersji pliku do przywrócenia do pliku <filename>.
Na przykład, aby sprawdzić bezpośrednio poprzedniej wersji jednego pliku x/y/z.c za pomocą

git prevision -1 x/y/z.c

jak działa Git prevision?

dodać do gitconfig

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

zespół w zasadzie

  • wykonuje git log na podany plik i
  • wybiera odpowiedni identyfikator zatwierdzenia w historii pliku i
  • wykonuje git checkout w commit-id dla określonego pliku.

w rzeczywistości, wszystko, co można było zrobić ręcznie w tej sytuacji,
opakowane w jeden piękny, wydajny git-alias - git-prevision


muszę podłączyć EasyGit tutaj, który jest folią, aby zrobić git bardziej przystępne dla początkujących, nie mylące doświadczonych użytkowników. Jedną z rzeczy, które on robi, to daj więcej wartości 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 zatwierdzenia (i plik, który chcesz odzyskać już zarejestrowane), można użyć

git checkout HEAD^1 path/to/file

lub

git checkout HEAD~1 path/to/file

następnie po prostu etap i załatwiać "nowej" wersji.

albo będzie działać, jeśli jest tylko jeden rodzic w drzewo.


zauważ jednak, że git checkout ./foo a git checkout HEAD ./foo nie dokładnie to samo; przykład:

$ 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

(druga add этапирует plik w indeksie, ale robi ci oddany.)

Git checkout ./foo znaczy, przywrócić drogę ./fooindeks; dodawanie HEAD instruuje Git odzyskać w ten sposób w indeksie do jego HEAD przegląd przed tym.


Pierwsza Głowica Reset Dla Docelowego Pliku

git reset HEAD path_to_file

Druga Kwestia Tego Pliku

git checkout -- path_to_file

wiele zdań tutaj, większość z nich wierszami git checkout $revision -- $file. Kilka niejasnych alternatyw:

git show $revision:$file > $file

a także, używam tego dużo, aby zobaczyć konkretną wersję tymczasowo:

git show $revision:$file

lub

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

(OBS:$file musi mieć przedrostek ./ jeśli jest to ścieżka względna do git show $revision:$file do pracy)

i jeszcze bardziej dziwne:

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

aby przejść do poprzedniej wersji zatwierdzenia pliku, otrzymasz numer zatwierdzenia, powiedzmy eb917a1 wtedy

git checkout eb917a1 YourFileName

Jeśli po prostu trzeba wrócić do najnowszej wersji commited

git reset HEAD YourFileName
git checkout YourFileName

To tylko doprowadzi cię do ostatniego nastawionego stanu pliku


git checkout ref / commitHash -- filePath

np.

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

dla mnie żadna z odpowiedzi nie wydawał się naprawdę jasne, i dlatego chciałbym dodać swój, który wydaje się bardzo łatwe.

mam commit abc1 i wtedy zrobiłem kilka (lub jedną modyfikację w pliku file.txt.

powiedz, że ja coś pomyliłem w pliku file.txt i chcę wrócić do poprzedniego commit abc1.

1.git checkout file.txt: to usunie lokalne zmiany, jeśli nie musisz je!--12-->

2.git checkout abc1 file.txt: to doprowadzi swój plik do komputera chciałem wersja

3.git commit -m "Restored file.txt to version abc1" : to uczyni twój powrót.

  1. git push : to będzie pchać wszystko do zdalnego repozytorium

między krokami 2 i 3, Oczywiście, można zrobić git status aby zrozumieć, co się dzieje. Zazwyczaj powinieneś zobaczyć file.txt już dodane, a więc nie ma potrzeby git add.


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

Uwaga: nie zapomnij wpisać skrót do ostatniego. Ostatni skrót wskazuje bieżącą pozycję (głowę) i nic się nie zmienia.


oczywiście, ktoś musi napisać zrozumiałe książkę o git, lub git musi być lepiej wyjaśnione w dokumentacji. Spotkałem się z tym samym problemem domyślałem się, że

cd <working copy>
git revert master

anuluje ostatni commit, który, wydawałoby się, robi.

Ian


wiele odpowiedzi tutaj twierdzą, że korzystają git reset ... <file> lub git checkout ... <file> ale przy tym stracisz wszystkie modyfikacje <file> popełnionych po zatwierdzeniu, którą chcesz anulować.

jeśli chcesz anulować zmiany z jednego zamocowania tylko w jednym pliku, tak samo jak git revert zrobił, ale tylko dla jednego pliku (lub, powiedzmy, podzbiory plików zatwierdzenia), proponuję używać obu git diff a git apply (Z <sha> = hash zatwierdzenia, którą chcesz anulować) :

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

w zasadzie, to najpierw generuje patch, odpowiednie zmiany, które chcesz przywrócić, a następnie usuń, aby zastosować poprawkę, aby usunąć te zmiany.

oczywiście, że nie będzie działać, jeśli zwracane wiersze zostały zmienione w dowolny blokadą między <sha1> a HEAD (konfliktu).


git revert <hash>

zwróci tę blokadę. To brzmi jak myślisz git revert wpływa tylko na najnowszą utrwalenie.

to nie rozwiązuje problemu, jeśli chcesz anulować zmianę w określonym pliku, i ten ogranicznik zmienił się więcej niż ten plik.


Jeśli zanotowali nieprawidłowy plik w swoich ostatnich коммитах, postępuj zgodnie z instrukcjami:

  1. drzewo open source, zmień na ten commit

open source tree

  1. zmień wiersze i znajdź utrwalenie, że nieprawidłowy plik wysłany jako zatwierdzenie

enter image description here

  1. możesz zobaczyć listę twoich zmian w tej zatwierdzenia list of files in the source tree
  2. kliknij w. .. przyciski po prawej stronie ... kliknij zwrotny plik
  3. następnie można go zobaczyć na karcie stanu pliku w lewej dolnej części kliknij przycisk Anuluj dodaj:

file status tab

  1. otwórz kod visual studio i wróć, wsuwając usunięte pliki
  2. po każdym z nich można zobaczyć wyniki swojej najnowszej zatwierdzenia w drzewie źródłowym

enter image description here


można to zrobić w 4 krokach:

  1. anuluj wszystkie blokady z plikiem, który chcesz specjalnie anulować-stworzy nową blokadę w twojej gałęzi
  2. miękki reset, który rejestruje-usuwa blokady i przenosi zmiany w obszar roboczy
  3. handpick pliki do refundacji i ustalania ich
  4. usuń wszystkie inne pliki w obszarze roboczym

co trzeba wpisać w swój 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


oto mój sposób.

a) w Android Studio otwórz plik.

b) git -> pokaż historię, znaleźć poprzednie zatwierdzenie, do którego chcę wrócić. Uzyskaj commit_id (tj. mieszania zatwierdzenia).

c)git checkout commit_id file_path


Jeśli używasz rozszerzenia Git, i chcesz wrócić do nadrzędnego zatwierdzenia do pliku, możesz wybrać blokadę, która zawiera zmiany, które chcesz przywrócić, a następnie wybierz zakładkę "Diff" w okienku szczegółów kliknij prawym przyciskiem myszy plik, który chcesz odzyskać, a następnie "wyczyść plik(i)".... wtedy 'A' (rodzic)