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

Wprowadziłem kilka zmian w pliku, który został popełniony kilka razy w ramach grupy plików, ale teraz chcę zresetować / przywrócić zmiany w nim z powrotem do poprzedniej wersji.

Zrobiłem git lograzem z, git diffaby znaleźć potrzebną wersję, ale po prostu nie mam pojęcia, jak przywrócić plik do poprzedniego stanu w przeszłości.

Zakładając, że skrót żądanego zatwierdzenia to c5f567:

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

Strona podręcznika kasy git zawiera więcej informacji.

Jeśli chcesz wcześniej powrócić do zatwierdzenia c5f567, dołącz ~1(gdzie 1 to liczba zatwierdzeń, które chcesz cofnąć, może to być dowolna wartość):

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

Na marginesie, zawsze czułem się niekomfortowo z tym poleceniem, ponieważ jest ono używane zarówno do zwykłych rzeczy (zmiana między gałęziami), jak i do niezwykłych, destrukcyjnych rzeczy (odrzucanie zmian w katalogu roboczym).

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 zatwierdzenia, użyj polecenia reset:

git reset <commit hash> <filename>

Może być konieczne skorzystanie z tej --hardopcji, jeśli masz lokalne modyfikacje.

Dobrym sposobem zarządzania punktami na drodze 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 momentu. Aby to zrobić, użyj wygodnego polecenia realizacji transakcji:

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

Następnie możesz zmienić to ustawienie względem swojej głównej linii, 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 git commit, w tym SHA-1, jeśli jest to najwygodniejsze. Chodzi o to, że polecenie wygląda następująco:

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

git checkout -- foo

Zresetuje się foodo HEAD. Możesz też:

git checkout HEAD^ foo

za jedną wersję wstecz itp.

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 najłatwiej zrozumieć tę odpowiedź ( commit-refjest to wartość SHA zmiany w dzienniku, do której 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 zatwierdzeń musisz cofnąć, możesz użyć:

git checkout master~5 image.png

Zakłada się, że jesteś w masteroddziale, a żądana wersja to 5 zatwierdza z powrotem.

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

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

Zacząć od:

$ git log

która pokazuje listę ostatnich zatwierdzeń i ich skrótów SHA1.

Następnie wpisz:

$ git reset --hard SHA1_HASH

aby przywrócić stan do danego zatwierdzenia i trwale usunąć wszystkie nowsze zatwierdzenia z rekordu.

To działało dla mnie:

git checkout <commit hash> file

Następnie zatwierdź zmianę:

git commit -a

Musisz być ostrożny, mówiąc „wycofać”. Jeśli kiedyś miałeś jedną wersję pliku w zatwierdzeniu $ A, a następnie dokonałeś dwóch zmian w dwóch osobnych zatwierdzeniach $ B i $ C (więc widzisz trzecią iterację pliku) i jeśli mówisz „ Chcę przywrócić do pierwszego ”, czy naprawdę to masz 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. Polecenie pyta: „Chcę sprawdzić plik ze stanu zarejestrowanego przez zatwierdzenie $ A”.

Z drugiej strony, chodziło ci o to, aby pozbyć się wprowadzonej drugiej iteracji (tj. Zatwierdzenia $ B), zachowując zachowanie pliku C dokonane w pliku, chciałbyś przywrócić $ B

$ git revert $B

Pamiętaj, że ktokolwiek stworzył zatwierdzenie $ B, może nie był zbyt zdyscyplinowany i mógł popełnić całkowicie niezwiązaną zmianę w tym samym zatwierdzeniu, a to przywrócenie może dotykać plików innych niż pliki, które widzisz obrażające zmiany, więc możesz chcieć dokładnie sprawdzić wynik po wykonaniu więc.

Zabawne, git checkout foonie będzie działać, jeśli kopia robocza znajduje się w katalogu o nazwie foo; Jednak zarówno git checkout HEAD fooi git checkout ./foobędzie:

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

Oto jak rebasedział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 ... zatwierdzają polecenie git checkout git rebase master

... sprawdź gałąź zmian, którą chcesz zastosować do mastergałęzi. rebaseKomenda bierze rewizje u <my branch>(które nie występują w master) i występuje ponownie je na głowę master. Innymi słowy, rodzic pierwszego zatwierdzenia w <my branch>nie jest już poprzednim zatwierdzeniem w masterhistorii, ale bieżącym szefem master. Te dwa polecenia są takie same jak:

git rebase master <my branch>

Może być łatwiej zapamiętać to polecenie, ponieważ gałęzie „podstawowa” i „modyfikująca” 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 przewijanie do przodu, aby zastosować wszystkie <my branch>zmiany master. Bez tego kroku zatwierdzenie rebase nie zostanie dodane do master. Ostateczny wynik to:

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

masteri <my branch>oba odniesienia B'. Od tego momentu można bezpiecznie usunąć <my branch>odwołanie.

git branch -d <my branch>

Począwszy od git v2.23.0 istnieje nowa metoda git restore , która powinna przyjąć część tego, za co git checkoutbyła odpowiedzialna (nawet zaakceptowana odpowiedź wspomina, co git checkoutjest dość mylące). Zobacz najważniejsze zmiany na blogu github .

Domyślne zachowanie tego polecenia polega na przywróceniu stanu drzewa roboczego z zawartością pochodzącą z sourceparametru (który w twoim przypadku będzie skrótem zatwierdzenia).

Zatem na podstawie odpowiedzi Grega Hewgilla (zakładając, że jest to suma zatwierdzenia c5f567), polecenie wyglądałoby tak:

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

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

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

Najpierw zresetuj głowicę do pliku docelowego

git reset HEAD path_to_file

Drugie pobranie tego pliku

git checkout -- path_to_file

git-aliasy, awk i funkcje powłoki na ratunek!

git prevision <N> <filename>

gdzie <N>jest liczba wersji pliku do wycofania dla pliku <filename>.
Na przykład, aby pobrać bieżącą poprzednią wersję pojedynczego pliku x/y/z.c, uruchom

git prevision -1 x/y/z.c

Jak działa Git Prevision?

Dodaj następujące elementy do swojego gitconfig

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

Komenda w zasadzie

• wykonuje a git logna podanym pliku i
• wybiera odpowiedni identyfikator zatwierdzenia w historii pliku i
• wykonuje a git checkoutdla identyfikatora zatwierdzenia dla określonego pliku.

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

Muszę tu podłączyć EasyGit , który jest otoką , aby uczynić git bardziej dostępnym dla nowicjuszy bez mylenia doświadczonych użytkowników. Jedną z rzeczy, które robi, jest nadawanie większego znaczeniagit revert . W takim przypadku wystarczy powiedzieć:

eg revert foo/bar foo/baz

W przypadku, gdy chcesz przywrócić plik do poprzedniego zatwierdzenia (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 po prostu zrób scenariusz i zatwierdź „nową” wersję.

Uzbrojeni w wiedzę, że zatwierdzenie może mieć dwoje rodziców w przypadku scalenia, 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.

Wiele sugestii tutaj, większość podobnych do git checkout $revision -- $file. Kilka niejasnych alternatyw:

git show $revision:$file > $file

Często też używam tego, aby chwilowo zobaczyć konkretną wersję:

git show $revision:$file

lub

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

(OBS: $filenależy go poprzedzić, ./jeśli jest to ścieżka względna git show $revision:$filedo działania)

A jeszcze bardziej dziwne:

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

Zauważ jednak, że git checkout ./fooi git checkout HEAD ./foo nie są dokładnie tym samym; przykładem:

$ 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 addetap pliku w indeksie, ale nie zostaje zatwierdzony .)

Git checkout ./foooznacza odwróć ścieżkę ./foood indeksu ; dodanie HEADinstruuje Git, aby HEADprzed wykonaniem tej operacji przywrócił tę ścieżkę indeksu do swojej wersji.

Dla mnie żadna odpowiedź nie wydawała się naprawdę jasna, dlatego chciałbym dodać moją, która wydaje się bardzo łatwa.

Mam zatwierdzenie, abc1a następnie dokonałem kilku (lub jednej modyfikacji) pliku file.txt.

Teraz powiedz, że coś pomieszałem w pliku file.txti chcę wrócić do poprzedniego zatwierdzenia abc1.

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

2 git checkout abc1 file.txt.: spowoduje to przeniesienie pliku do poszukiwanej wersji

3 git commit -m "Restored file.txt to version abc1".: spowoduje to twoje cofnięcie.

4. git push : spowoduje to wypchnięcie wszystkiego ze zdalnego repozytorium

Pomiędzy krokiem 2 i 3 oczywiście możesz zrobić, git statusaby zrozumieć, co się dzieje. Zwykle powinieneś zobaczyć file.txtjuż dodane i dlatego nie ma potrzeby git add.

1. Git przywraca plik do konkretnego zatwierdzenia

git checkout Last_Stable_commit_Number -- fileName

2. Przywróć plik do określonej gałęzi

git checkout branchName_Which_Has_stable_Commit fileName

Aby przejść do poprzedniej wersji zatwierdzenia pliku, pobierz numer zatwierdzenia, powiedz eb917a1

git checkout eb917a1 YourFileName

Jeśli chcesz tylko wrócić do ostatniej zatwierdzonej wersji

git reset HEAD YourFileName
git checkout YourFileName

Spowoduje to po prostu przejście do ostatniego zatwierdzonego stanu pliku

git checkout ref | commitHash - filePath

na przykład

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

Wiele odpowiedzi tutaj roszczenia w użyciu git reset ... <file>lub git checkout ... <file>, ale przez to, co tracisz na modyfikacje <file>popełnione po popełnić chcesz przywrócić.

Jeśli chcesz cofnąć zmiany z jednego zatwierdzenia tylko w jednym pliku, tak jak git revertzrobiłby to tylko jeden plik (lub powiedzmy podzbiór plików zatwierdzenia), sugeruję użycie obu git diffi git applytak (z <sha>hash = zatwierdzenie, które chcesz cofnąć):

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

Zasadniczo najpierw wygeneruje łatkę odpowiadającą zmianom, które chcesz cofnąć, a następnie zastosuje ją odwrotnie, aby usunąć te zmiany.

Oczywiście nie zadziała, jeśli odwrócone linie zostały zmodyfikowane przez jakiekolwiek zatwierdzenie między <sha1>i HEAD(konflikt).

Użyj, git logaby uzyskać klucz skrótu dla określonej wersji, a następnie użyjgit checkout <hashkey>

Uwaga: Nie zapomnij wpisać skrótu przed ostatnim. Ostatni hash wskazuje twoją aktualną pozycję (HEAD) i niczego nie zmienia.

Oczywiście ktoś albo musi napisać zrozumiałą książkę na temat git, albo git musi być lepiej wyjaśniony w dokumentacji. W obliczu tego samego problemu zgadłem

cd <working copy>
git revert master

cofnie ostatnie zatwierdzenie, które wydaje się robić.

Ian

Możesz to zrobić w 4 krokach:

1. cofnij całe zatwierdzenie z plikiem, który chcesz przywrócić - spowoduje to utworzenie nowego zatwierdzenia w oddziale
2. miękki reset, który zatwierdza - usuwa zatwierdzenie i przenosi zmiany do obszaru roboczego
3. ręcznie wybierz pliki, aby je przywrócić i zatwierdzić
4. upuść wszystkie inne pliki w obszarze roboczym

Co musisz wpisać w swoim terminalu :

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

powodzenia

To bardzo prosty krok. Pobierz plik do identyfikatora zatwierdzenia, który chcemy, tutaj jeden identyfikator zatwierdzenia wcześniej, a następnie po prostu wprowadź zmiany i zakończ.

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

To jest bardzo przydatne. Jeśli chcemy przenieść dowolny plik do dowolnego wcześniejszego identyfikatora zatwierdzenia u góry zatwierdzenia, możemy to łatwo zrobić.

git revert <hash>

Cofa zatwierdzenie. Wygląda na to, że uważasz, że git revertdotyczy tylko ostatniego zatwierdzenia.

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

jeśli popełnisz zły plik w swoich ostatnich zatwierdzeniach, postępuj zgodnie z instrukcją:

1. drzewo open source, zmień to zatwierdzenie

2. zmień linie i znajdź swoje zatwierdzenie, że niewłaściwy plik wysłany jako zatwierdzenie

3. możesz zobaczyć listę swoich zmian w tym zatwierdzeniu
4. wybierz go, a następnie kliknij ... przyciski po prawej stronie ... kliknij odwróć plik
5. możesz to zobaczyć na zakładce stanu pliku w lewym dolnym rogu, a następnie kliknij odłączyć scenę:

6. otwórz kod studia wizualnego i przywróć, zatwierdzając usunięte pliki
7. po nich wszystkich możesz zobaczyć wyniki ostatniego zatwierdzenia w drzewie źródłowym