git-reset — Online w chmurze

PROGRAM:

IMIĘ

git-reset — Resetuje bieżącą głowicę do określonego stanu

STRESZCZENIE

odrzutowiec zresetuj [-Q] [ ] [--] ...
odrzutowiec zresetuj (--łatka | -p) [ ] [--] [ ...]
odrzutowiec zresetuj [--miękki | --mieszane [-N] | --trudne | --scal | --keep] [-q] [ ]

OPIS

W pierwszym i drugim formularzu skopiuj wpisy z do indeksu. W trzecim
formularzu, ustaw bieżącą głowicę gałęzi (HEAD) na , opcjonalnie modyfikując indeks i
drzewo robocze pasujące. The / domyślnie HEAD we wszystkich formularzach.

odrzutowiec zresetuj [-Q] [ ] [--] ...
Ten formularz resetuje wpisy indeksu dla wszystkich do swojego stanu o godz . (To
nie wpływa na działające drzewo ani na bieżącą gałąź.)

Oznacza to, że git reset jest przeciwieństwem git add .

Po uruchomieniu git reset aby zaktualizować wpis indeksu, możesz użyć git-checkout(1)
aby sprawdzić zawartość indeksu do drzewa roboczego. Alternatywnie, używając git-
checkout(1) i określając zatwierdzenie, możesz skopiować zawartość ścieżki z pliku
zatwierdź jednocześnie indeks i drzewo robocze.

odrzutowiec zresetuj (--łatka | -p) [ ] [--] [ ...]
Interaktywnie wybierz porcje w różnicy między indeksem a
(domyślnie HEAD). Wybrane porcje są stosowane odwrotnie do indeksu.

Oznacza to, że git reset -p jest przeciwieństwem git add -p, tzn. możesz go użyć
selektywnie resetuj porcje. Zobacz sekcję „Tryb interaktywny” w git-dodaj(1) aby dowiedzieć się jak
do obsługi trybu --patch.

odrzutowiec zresetuj [ ] [ ]
Ten formularz resetuje bieżący nagłówek oddziału i ewentualnie aktualizuje indeks
(resetowanie go do drzewa ) i drzewo robocze w zależności od . Jeśli
jest pominięty, domyślnie jest to „--mixed”. The musi być jednym z następujących:

--miękki
W ogóle nie dotyka pliku indeksu ani drzewa roboczego (ale resetuje głowę do
, tak jak wszystkie tryby). Spowoduje to pozostawienie wszystkich zmienionych plików „Zmiany w
zostać popełnione”, as odrzutowiec status by to ująć.

--mieszany
Resetuje indeks, ale nie drzewo robocze (tj. zmienione pliki zostają zachowane
ale nie oznaczone do zatwierdzenia) i raportuje, co nie zostało zaktualizowane. To jest
akcja domyślna.

Jeśli podano -N, usunięte ścieżki są oznaczone jako przeznaczone do dodania (patrz git-dodaj(1)).

--twardy
Resetuje indeks i drzewo robocze. Wszelkie zmiany w śledzonych plikach w pliku roboczym
drzewo od są odrzucane.

--łączyć
Resetuje indeks i aktualizuje pliki w drzewie roboczym, które są różne
między i HEAD, ale zachowuje te, które różnią się między indeksami
i drzewo robocze (tzn. zawierające zmiany, które nie zostały dodane). Jeśli plik
to się różni a indeks zawiera niestacjonarne zmiany, reset jest
niedonoszony.

Innymi słowy, --merge robi coś w rodzaju a odrzutowiec drzewo-odczyt -u -m , ale
przenosi niescalone wpisy indeksu.

--trzymać
Resetuje wpisy indeksu i aktualizuje pliki w drzewie roboczym, które są inne
między i GŁOWA. Jeśli plik różni się między i GŁOWA
zawiera zmiany lokalne, reset zostaje przerwany.

Jeśli chcesz cofnąć zatwierdzenie inne niż najnowsze w gałęzi, git-revert(1) jest twój
przyjaciel.

OPCJE

-q, --cichy
Bądź cicho, zgłaszaj tylko błędy.

PRZYKŁADY

Cofnij dodanie

$ edycja (1)
$ git dodaj frotz.c filfre.c
$ poczta (2)
$ git reset (3)
$ git pull git://info.example.com/nitfol (4)

1. Z radością nad czymś pracujesz i stwierdzasz, że zmiany w tych plikach zostały wprowadzone
dobre zamówienie. Nie chcesz ich widzieć po uruchomieniu „git diff”, ponieważ tak planujesz
praca na innych plikach i zmiany w tych plikach rozpraszają.
2. Ktoś prosi cię o pociągnięcie, a zmiany wydają się godne połączenia.
3. Jednak już zabrudziłeś indeks (tj. Twój indeks nie pasuje do HEAD
popełniać). Ale wiesz, że pociągnięcie, które zamierzasz wykonać, nie ma wpływu na frotz.c lub
filfre.c, więc cofnij zmiany indeksu dla tych dwóch plików. Twoje zmiany w pracy
drzewo tam pozostanie.
4. Następnie możesz przeciągnąć i scalić, pozostawiając zmiany w plikach frotz.c i filfre.c nadal w pliku
drzewo robocze.

Cofnij zatwierdzenie i wykonaj ponownie

$ git zatwierdzenie ...
$ git reset --soft HEAD^ (1)
$ edycja (2)
$ git commit -a -c ORIG_HEAD (3)

1. Dzieje się tak najczęściej, gdy przypominasz sobie, że to, co właśnie popełniłeś, jest niekompletne,
albo błędnie napisałeś wiadomość zatwierdzenia, albo jedno i drugie. Pozostawia działające drzewo tak, jak było wcześniej
"Resetowanie".
2. Wprowadź poprawki w działających plikach drzewa.
3. „reset” kopiuje stary nagłówek do .git/ORIG_HEAD; wykonaj ponownie zatwierdzenie, zaczynając od jego
wiadomość dziennika. Jeśli nie musisz dalej edytować wiadomości, możesz podać opcję -C
zamiast.

Zobacz także opcję --amend do git-commit(1).

Cofnij zatwierdzenie, czyniąc z niego gałąź tematyczną

$ temat gałęzi git/wip (1)
$ git reset --twarda GŁOWA~3 (2)
$ git sprawdź temat/wip (3)

1. Dokonałeś pewnych zobowiązań, ale zdajesz sobie sprawę, że były one przedwczesne, aby znaleźć się w „masterze”
oddział. Chcesz kontynuować dopracowywanie ich w gałęzi tematycznej, więc utwórz „temat/wip”
odgałęzienie bieżącego HEAD.
2. Przewiń gałąź master, aby pozbyć się tych trzech zatwierdzeń.
3. Przejdź do gałęzi „topic/wip” i pracuj dalej.

Cofnij zatwierdzenie na stałe

$ git zatwierdzenie ...
$ git reset --twarda GŁOWA~3 (1)

1. Ostatnie trzy zatwierdzenia (HEAD, HEAD^ i HEAD~2) były złe i nie chcesz tego robić
nigdy więcej ich nie zobaczyć. Do nie zrób to, jeśli już przekazałeś te zatwierdzenia
ktoś inny. (Zobacz sekcję „ODZYSKIWANIE Z WYŻSZEJ BAZY” w git-rebase(1) dla
konsekwencje takiego działania.)

Cofnij scalanie lub ściąganie

$ git pull (1)
Automatyczne łączenie nitfolu
KONFLIKT (treść): Połącz konflikt w nitfol
Automatyczne scalanie nie powiodło się; napraw konflikty, a następnie zatwierdź wynik.
$ git reset --twardy (2)
$ git pull . temat/branża (3)
Aktualizacja z 41223... do 13134...
Przewijanie do przodu
$ git reset --hard ORIG_HEAD (4)

1. Próba aktualizacji z wcześniejszego źródła spowodowała wiele konfliktów; nie byłeś gotowy
spędzać teraz dużo czasu na łączeniu, więc decydujesz się zrobić to później.
2. „pull” nie spowodowało zatwierdzenia scalania, więc „git reset --hard”, który jest synonimem „git
reset --hard HEAD” usuwa bałagan z pliku indeksu i drzewa roboczego.
3. Połącz gałąź tematyczną z bieżącą gałęzią, co spowodowało przewinięcie do przodu.
4. Ale zdecydowałeś, że gałąź tematyczna nie jest jeszcze gotowa do publicznego spożycia.
„pull” lub „merge” zawsze pozostawia oryginalną końcówkę bieżącej gałęzi w ORIG_HEAD,
więc twarde resetowanie przywraca do tego plik indeksu i drzewo robocze
stan i resetuje końcówkę gałęzi do tego zatwierdzenia.

Cofnij scalanie lub wciągnij wewnątrz brudnego drzewa roboczego

$ git pull (1)
Automatyczne łączenie nitfolu
Scalanie wykonane metodą rekurencyjną.
nitfol | 20 +++++----
...
$ git reset --scal ORIG_HEAD (2)

1. Nawet jeśli możesz mieć lokalne modyfikacje w swoim drzewie roboczym, możesz śmiało powiedzieć
„git pull”, gdy wiesz, że zmiana w drugiej gałęzi nie pokrywa się z
Im.
2. Po sprawdzeniu wyniku scalania może się okazać, że nastąpiła zmiana w drugim
oddział jest niezadowalający. Uruchomienie „git reset --hard ORIG_HEAD” pozwoli ci wrócić do
gdzie byłeś, ale odrzuci Twoje lokalne zmiany, których nie chcesz. „git
reset --merge” zachowuje lokalne zmiany.

Przerwany przepływ pracy
Załóżmy, że przerwało Ci pilne żądanie naprawy, gdy jesteś w trakcie jakiegoś zadania
duża zmiana. Pliki w drzewie roboczym nie są jeszcze w jakimkolwiek stanie do zatwierdzenia,
ale musisz dostać się do drugiej gałęzi, aby szybko naprawić błąd.

$ git checkout feature ;# pracowałeś w branży „feature” i
$ praca praca praca ;# przerwano mi
$ git commit -a -m „migawka WIP” (1)
$ git mistrz kasy
$ poprawka napraw poprawka
$ git commit ;# commit z prawdziwym logiem
Funkcja kasy $ git
$ git reset --soft HEAD^ ;# wróć do stanu WIP (2)
$ git reset (3)

1. To zatwierdzenie zostanie zniesione, więc komunikat dziennika o wyrzuceniu będzie OK.
2. To usuwa WIP commit z historii zatwierdzeń i ustawia drzewo robocze na
stan tuż przed wykonaniem migawki.
3. W tym momencie plik indeksu nadal zawiera wszystkie zmiany WIP, które zatwierdziłeś
migawka WIP. Spowoduje to aktualizację indeksu i pokazanie plików WIP jako niezatwierdzonych.

Zobacz też git-schowek(1).

Zresetuj pojedynczy plik w indeksie
Załóżmy, że dodałeś plik do swojego indeksu, ale później zdecydowałeś, że nie chcesz go dodawać
to do twojego zobowiązania. Możesz usunąć plik z indeksu, zachowując zmiany
z git reset.

$ git reset -- frotz.c (1)
$ git commit -m „Zatwierdź pliki w indeksie” (2)
$ git dodaj frotz.c (3)

1. Spowoduje to usunięcie pliku z indeksu, zachowując go w katalogu roboczym.
2. Spowoduje to zatwierdzenie wszystkich pozostałych zmian w indeksie.
3. Ponownie dodaje plik do indeksu.

Zachowaj zmiany w drzewie roboczym, odrzucając niektóre poprzednie zatwierdzenia
Załóżmy, że pracujesz nad czymś, zatwierdzasz to, a następnie kontynuujesz pracę
trochę więcej, ale teraz myślisz, że to, co masz w swoim drzewie roboczym, powinno się w nim znajdować
kolejna gałąź, która nie ma nic wspólnego z tym, co popełniłeś wcześniej. Możesz
rozpocznij nową gałąź i zresetuj ją, zachowując zmiany w drzewie roboczym.

Początek tagu $ git
$ git kasa -b oddział1
$ edycja
$ git zatwierdzenie ... (1)
$ edycja
$ git kasa -b oddział2 (2)
$ git reset --kontynuuj start (3)

1. Spowoduje to zatwierdzenie pierwszych zmian w gałęzi 1.
2. W idealnym świecie mógłbyś zdać sobie sprawę, że wcześniejsze zatwierdzenie nie pasowało
do nowego tematu po utworzeniu i przejściu do gałęzi 2 (tj. „git checkout -b
gałąź2 start”), ale nikt nie jest doskonały.
3. Ale możesz użyć „reset --keep”, aby usunąć niechciane zatwierdzenie po przełączeniu na
„oddział 2”.

DYSKUSJA

Poniższe tabele pokazują, co dzieje się podczas działania:

git reset --opcja cel

aby zresetować HEAD do innego zatwierdzenia (celu) z różnymi opcjami resetowania w zależności od
stan plików.

W tych tabelach A, B, C i D oznaczają różne stany pliku. Na przykład pierwszy
wiersz pierwszej tabeli oznacza, że ​​jeśli plik w drzewie roboczym znajduje się w stanie A, to w stanie B
w indeksie, w stanie C w HEAD i w stanie D w celu, a następnie „git reset --soft
target” pozostawi plik w drzewie roboczym w stanie A i w indeksie w stanie B. It
resetuje (tj. przesuwa) HEAD (tj. końcówkę bieżącej gałęzi, jeśli na niej jesteś).
„target” (który ma plik w stanie D).

indeks roboczy HEAD docelowy indeks roboczy HEAD
-------------------------------------------------- -
ABCD – miękkie ABD
--mieszane DODAJ
--trudne DDD
--scal (niedozwolone)
--keep (niedozwolone)

indeks roboczy HEAD docelowy indeks roboczy HEAD
-------------------------------------------------- -
ABCC – miękkie ABC
--mieszane ACC
--twarde CCC
--scal (niedozwolone)
--zachowaj ACC

indeks roboczy HEAD docelowy indeks roboczy HEAD
-------------------------------------------------- -
BBCD – miękkie BBD
--mieszane BDD
--trudne DDD
--połącz DDD
--keep (niedozwolone)

indeks roboczy HEAD docelowy indeks roboczy HEAD
-------------------------------------------------- -
BBCC – miękkie BBC
--mieszane BCC
--twarde CCC
--połącz CCC
--zatrzymaj BCC

indeks roboczy HEAD docelowy indeks roboczy HEAD
-------------------------------------------------- -
BCCD – miękki BCD
--mieszane BDD
--trudne DDD
--scal (niedozwolone)
--keep (niedozwolone)

indeks roboczy HEAD docelowy indeks roboczy HEAD
-------------------------------------------------- -
BCCC – miękkie BCC
--mieszane BCC
--twarde CCC
--połącz BCC
--zatrzymaj BCC

„reset --merge” ma być używane podczas resetowania połączenia, które powoduje konflikt. Jakakolwiek fuzja
operacja gwarantuje, że działający plik drzewa biorący udział w łączeniu nie
mieć lokalną zmianę w indeksie przed jego uruchomieniem i zapisywać wynik w pliku
drzewo robocze. Jeśli więc zobaczymy pewną różnicę między indeksem a celem, a także
między indeksem a drzewem roboczym, oznacza to, że nie resetujemy się z a
stwierdza, że ​​operacja łączenia zakończyła się niepowodzeniem w wyniku konfliktu. Dlatego nie pozwalamy
--merge opcja w tym przypadku.

„reset --keep” ma być używany podczas usuwania niektórych ostatnich zatwierdzeń w bieżącym
gałęzi, zachowując zmiany w drzewie roboczym. Jeżeli mogłyby wystąpić konflikty pomiędzy
zmiany w zatwierdzeniu, które chcemy usunąć, i zmiany w drzewie roboczym, które chcemy
zachowaj, resetowanie jest niedozwolone. Dlatego niedozwolone jest, jeśli występują obie zmiany
pomiędzy drzewem roboczym a HEAD oraz pomiędzy HEAD a celem. Dla bezpieczeństwa też tak jest
niedozwolone, jeśli istnieją niepołączone wpisy.

Poniższe tabele pokazują, co się dzieje, gdy istnieją niepołączone wpisy:

indeks roboczy HEAD docelowy indeks roboczy HEAD
-------------------------------------------------- -
XUAB --soft (niedozwolone)
--mieszane XBB
--twardy BBB
--połącz BBB
--keep (niedozwolone)

indeks roboczy HEAD docelowy indeks roboczy HEAD
-------------------------------------------------- -
XUAA – miękkie (niedozwolone)
--mieszane XAA
--twarde AAA
--połącz AAA
--keep (niedozwolone)

X oznacza dowolny stan, a U oznacza niepołączony indeks.

GIT

Część odrzutowiec(1) apartament

Użyj git-reset online, korzystając z usług onworks.net