git-reset - Online in de cloud

PROGRAMMA:

NAAM

git-reset - Reset de huidige HEAD naar de opgegeven staat

KORTE INHOUD

git opnieuw in te stellen [-Q] [ ] [--] ...
git opnieuw in te stellen (--patch | -p) [ ] [--] [ ...]
git opnieuw in te stellen [--zacht | --gemengd [-N] | --moeilijk | --samenvoegen | --houden] [-q] [ ]

PRODUCTBESCHRIJVING

Kopieer in het eerste en tweede formulier de vermeldingen uit naar de index. In de derde
formulier, stelt u de huidige vertakkingskop (HEAD) in , optioneel door index en
bijpassende werkende boom. De / standaard ingesteld op HEAD in alle vormen.

git opnieuw in te stellen [-Q] [ ] [--] ...
Met dit formulier worden de indexvermeldingen voor iedereen opnieuw ingesteld naar hun staat op . (Het
heeft geen invloed op de werkende boom of de huidige tak.)

Dit betekent dat git reset is het tegenovergestelde van git add .

Na het uitvoeren van git reset om het indexitem bij te werken, kunt u gebruiken git-afrekenen(1)
om de inhoud van de index naar de werkboom te controleren. Als alternatief gebruiken git-
uitchecken(1) en door een commit op te geven, kunt u de inhoud van een pad uit een kopiëren
commit je in één keer aan de index en aan de werkboom.

git opnieuw in te stellen (--patch | -p) [ ] [--] [ ...]
Selecteer interactief hunks in het verschil tussen de index en
(standaard ingesteld op HEAD). De gekozen hunks worden omgekeerd ten opzichte van de index toegepast.

Dit betekent dat git reset -p het tegenovergestelde is van git add -p, dat wil zeggen dat je het daarvoor kunt gebruiken
selectief resetten van hunks. Zie het gedeelte ‘Interactieve modus’ van git-toevoegen(1) om te leren hoe
om de --patch-modus te bedienen.

git opnieuw in te stellen [ ] [ ]
Met dit formulier wordt de huidige vertakkingskop opnieuw ingesteld en werkt mogelijk de index bij
(het resetten naar de boom van ) en de werkboom afhankelijk van . Als
wordt weggelaten, is standaard "--mixed". De moet een van de volgende zijn:

--zacht
Raakt het indexbestand of de werkboom helemaal niet aan (maar reset de kop naar
, net zoals alle modi dat doen). Hierdoor blijven al uw gewijzigde bestanden "Wijzigingen in
gepleegd worden", zoals git toestand zou stellen.

--gemengd
Reset de index, maar niet de werkboom (dat wil zeggen, de gewijzigde bestanden blijven behouden
maar niet gemarkeerd voor commit) en rapporteert wat niet is bijgewerkt. Dit is de
standaard actie.

Als -N is opgegeven, worden verwijderde paden gemarkeerd als intent-to-add (zie git-toevoegen(1)).

--moeilijk
Reset de index en werkboom. Eventuele wijzigingen in bijgehouden bestanden zijn in uitvoering
boom sinds worden weggegooid.

--samenvoegen
Reset de index en werkt de bestanden in de werkboom bij die verschillend zijn
tussen en HEAD, maar behoudt de waarden die verschillend zijn tussen de index
en werkboom (dwz die wijzigingen bevatten die niet zijn toegevoegd). Als een bestand
dat is verschillend tussen en de index heeft niet-gefaseerde wijzigingen, reset is
afgebroken.

Met andere woorden: --merge doet zoiets als a git lees-boom -u -m , Maar
draagt ​​niet-samengevoegde indexgegevens over.

--houden
Reset indexitems en werkt bestanden in de werkboom bij die verschillend zijn
tussen en HOOFD. Als een bestand dat verschillend is tussen en HOOFD
lokale wijzigingen heeft, wordt de reset afgebroken.

Als je een andere commit dan de laatste op een branch ongedaan wilt maken, git-terugzetten(1) is van jou
vriend.

OPTIES

-q, --stil
Wees stil, rapporteer alleen fouten.

Voorbeelden

Toevoegen ongedaan maken

$ bewerken (1)
$ git voeg frotz.c filfre.c toe
$ mailx (2)
$ git-reset (3)
$ git pull git://info.example.com/nitfol (4)

1. U werkt met plezier aan iets en merkt dat de wijzigingen in deze bestanden zijn doorgevoerd
goede bestelling. Je wilt ze niet zien als je "git diff" uitvoert, omdat je dat van plan bent
werk aan andere bestanden en wijzigingen met deze bestanden leiden af.
2. Iemand vraagt ​​je om te trekken, en de veranderingen klinken de moeite waard om samen te voegen.
3. U hebt de index echter al vervuild (dat wil zeggen dat uw index niet overeenkomt met de HEAD
verbinden). Maar je weet dat de trek die je gaat maken geen invloed heeft op frotz.c of
filfre.c, zodat u de indexwijzigingen voor deze twee bestanden ongedaan maakt. Uw veranderingen in het werken
boom blijft daar staan.
4. Vervolgens kunt u pull-en en mergen, waarbij de wijzigingen in frotz.c en filfre.c nog steeds in de
werkende boom.

Een commit ongedaan maken en opnieuw uitvoeren

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

1. Dit wordt meestal gedaan als u zich herinnert dat wat u zojuist hebt gedaan, onvolledig is.
of je hebt je commit-bericht verkeerd gespeld, of beide. Laat de werkende boom achter zoals voorheen
"resetten".
2. Breng correcties aan in werkende boombestanden.
3. "reset" kopieert de oude head naar .git/ORIG_HEAD; voer de commit opnieuw uit door te beginnen met its
log bericht. Als u het bericht niet verder hoeft te bewerken, kunt u de optie -C opgeven
gebruiken.

Zie ook de optie --amend voor git-commit(1).

Maak een commit ongedaan en maak er een onderwerpbranch van

$ git branch onderwerp/wip (1)
$ git reset --hard HEAD~3 (2)
$ git checkout onderwerp/wip (3)

1. Je hebt een aantal commits gedaan, maar beseft dat het voorbarig was om in de "master" te zitten
tak. Je wilt ze verder oppoetsen in een onderwerpbranch, dus maak "topic/wip" aan
aftakking van de huidige HEAD.
2. Spoel de master branch terug om van die drie commits af te komen.
3. Schakel over naar de "topic/wip" branch en blijf werken.

Maak commits permanent ongedaan

$ git vastleggen ...
$ git reset --hard HEAD~3 (1)

1. De laatste drie commits (HEAD, HEAD^ en HEAD~2) waren slecht en dat wil je niet
zie ze nooit meer terug. Doen niet doe dit als je deze commits al hebt gedaan
iemand anders. (Zie het gedeelte "HERSTELLEN VAN BOVENSTE REBASE" in git-rebase(1) voor
de gevolgen hiervan.)

Een samenvoeging of pull ongedaan maken

$ git-pull (1)
Automatisch samenvoegen van nitfol
CONFLICT (inhoud): Conflict samenvoegen in nitfol
Automatisch samenvoegen mislukt; conflicten oplossen en vervolgens het resultaat vastleggen.
$ git reset --hard (2)
$ git-pull. onderwerp/tak (3)
Bijwerken van 41223... naar 13134...
Snel vooruit
$ git reset --hard ORIG_HEAD (4)

1. Proberen upstream te updaten resulteerde in veel conflicten; je was er niet klaar voor
om nu veel tijd te besteden aan het samenvoegen, dus besluit u dat later te doen.
2. "pull" heeft geen merge commit gemaakt, dus "git reset --hard" wat een synoniem is voor "git
reset --hard HEAD" wist de rommel uit het indexbestand en de werkboom.
3. Voeg een onderwerpvertakking samen met de huidige vertakking, wat resulteerde in snel vooruitspoelen.
4. Maar je hebt besloten dat de onderwerptak nog niet klaar is voor publieke consumptie.
"pull" of "merge" laat altijd de oorspronkelijke punt van de huidige vertakking in ORIG_HEAD,
dus als je er hard naar reset, worden je indexbestand en de werkboom daar weer naartoe gebracht
state, en reset de tip van de branch naar die commit.

Maak een samenvoeging ongedaan of trek een vuile, werkende boom binnen

$ git-pull (1)
Automatisch samenvoegen van nitfol
Samenvoeging gemaakt door recursief.
nifol | 20 +++++----
...
$ git reset --ORIG_HEAD samenvoegen (2)

1. Zelfs als u lokale wijzigingen in uw werkboom heeft, kunt u gerust zeggen
"git pull" als je weet dat de verandering in de andere branch niet overlapt
Hen.
2. Nadat u het resultaat van de samenvoeging heeft geïnspecteerd, zult u merken dat de verandering in de andere
afdeling is onbevredigend. Door "git reset --hard ORIG_HEAD" uit te voeren, kun je teruggaan naar
waar u was, maar uw lokale wijzigingen worden verwijderd, wat u niet wilt. "git
reset --merge" behoudt uw lokale wijzigingen.

Onderbroken werkstroom
Stel dat u wordt onderbroken door een dringend verzoek om een ​​oplossing terwijl u midden in een probleem zit
grote verandering. De bestanden in uw werkboom zijn nog niet in staat om te worden vastgelegd,
maar je moet naar de andere vestiging gaan voor een snelle bugfix.

$ git checkout feature ;# je werkte in de "feature" branch en
$ work work work ;# werd onderbroken
$ git commit -a -m "momentopname WIP" (1)
$ git kassa-master
$ repareren repareren repareren
$ git commit ;# commit met echte log
$ git afrekenfunctie
$ git reset --soft HEAD^ ;# ga terug naar WIP-status (2)
$ git-reset (3)

1. Deze commit wordt weggeblazen, dus een wegwerplogboekbericht is OK.
2. Dit verwijdert de WIP commit uit de commitgeschiedenis, en stelt uw werkboom in op
de staat vlak voordat u die momentopname maakte.
3. Op dit punt bevat het indexbestand nog steeds alle WIP-wijzigingen die u hebt vastgelegd
momentopname WIP. Hiermee wordt de index bijgewerkt, zodat uw WIP-bestanden als niet-vastgelegd worden weergegeven.

Zie ook git-stash(1).

Reset een enkel bestand in de index
Stel dat u een bestand aan uw index hebt toegevoegd, maar later besluit dat u dit niet wilt toevoegen
het aan uw verplichting. U kunt het bestand uit de index verwijderen terwijl uw wijzigingen behouden blijven
met git-reset.

$ git reset -- frotz.c (1)
$ git commit -m "Commit-bestanden in index" (2)
$ git voeg frotz.c toe (3)

1. Hierdoor wordt het bestand uit de index verwijderd en blijft het in de werkmap staan.
2. Hiermee worden alle andere wijzigingen in de index doorgevoerd.
3. Voegt het bestand opnieuw toe aan de index.

Houd wijzigingen in de werkboom vast terwijl u enkele eerdere commits verwijdert
Stel je voor dat je ergens aan werkt en dat je het vastlegt, en dan ga je door met werken
een beetje meer, maar nu denk je dat wat je in je werkboom hebt, erin zou moeten zitten
een andere branch die niets te maken heeft met wat je eerder hebt vastgelegd. Jij kan
start een nieuwe branch en reset deze terwijl u de wijzigingen in uw werkboom behoudt.

$ git-tag starten
$ git kassa -b branch1
$ bewerken
$ git vastleggen ... (1)
$ bewerken
$ git kassa -b branch2 (2)
$ git reset --bewaar start (3)

1. Hiermee worden uw eerste bewerkingen in branch1 vastgelegd.
2. In de ideale wereld had je je kunnen realiseren dat de eerdere commit er niet bij hoorde
naar het nieuwe onderwerp toen je branch2 aanmaakte en er naar overschakelde (dat wil zeggen "git checkout -b
branch2 start"), maar niemand is perfect.
3. Maar je kunt "reset --keep" gebruiken om de ongewenste commit te verwijderen nadat je bent overgeschakeld naar
"tak2".

DISCUSSIE

De onderstaande tabellen laten zien wat er gebeurt tijdens het hardlopen:

git reset --optie doel

om de HEAD te resetten naar een andere commit (doel) met de verschillende reset-opties afhankelijk van
de staat van de bestanden.

In deze tabellen zijn A, B, C en D enkele verschillende statussen van een bestand. Bijvoorbeeld de eerste
regel van de eerste tabel betekent dat als een bestand zich in staat A bevindt in de werkboom, ook in staat B
in de index, in staat C in HEAD en in staat D in het doel, dan "git reset --soft
target" laat het bestand in de werkboom in staat A en in de index in staat B. It
reset (dwz verplaatst) de HEAD (dwz de punt van de huidige tak, als u zich op een tak bevindt).
"target" (waarin het bestand de status D heeft).

werkindex HEAD doelwerkindex HEAD
-------------------------------------------------- -
ABCD -zachte ABD
--gemengd TOEVOEGEN
--harde DDD
--samenvoegen (niet toegestaan)
--houden (niet toegestaan)

werkindex HEAD doelwerkindex HEAD
-------------------------------------------------- -
ABCC --zacht ABC
--gemengde ACC
--harde CCC
--samenvoegen (niet toegestaan)
--houd ACC

werkindex HEAD doelwerkindex HEAD
-------------------------------------------------- -
BBCD --zachte BBD
--gemengde BDD
--harde DDD
--DDD samenvoegen
--houden (niet toegestaan)

werkindex HEAD doelwerkindex HEAD
-------------------------------------------------- -
BBCC -zachte BBC
--gemengde BCC
--harde CCC
--CCC samenvoegen
--BCC behouden

werkindex HEAD doelwerkindex HEAD
-------------------------------------------------- -
BCCD -zachte BCD
--gemengde BDD
--harde DDD
--samenvoegen (niet toegestaan)
--houden (niet toegestaan)

werkindex HEAD doelwerkindex HEAD
-------------------------------------------------- -
BCCC --zachte BCC
--gemengde BCC
--harde CCC
--BCC samenvoegen
--BCC behouden

"reset --merge" is bedoeld om te worden gebruikt bij het resetten van een conflicterende merge. Elke fusie
operatie garandeert dat het werkboombestand dat bij de samenvoeging betrokken is, dat niet doet
lokale wijzigingen in de index hebben voordat deze start, en dat het resultaat naar de
werkende boom. Dus als we enig verschil zien tussen de index en het doel, en ook
tussen de index en de werkboom, dan betekent dit dat we niet vanuit a resetten
stellen dat een fusieoperatie is mislukt nadat een conflict is mislukt. Daarom weigeren wij het
--merge optie in dit geval.

"reset --keep" is bedoeld om te worden gebruikt bij het verwijderen van enkele van de laatste commits in de huidige
vertakking terwijl de wijzigingen in de werkboom behouden blijven. Als er conflicten zouden kunnen ontstaan ​​tussen de
veranderingen in de commit die we willen verwijderen en de veranderingen in de werkboom die we willen
behouden, is de reset niet toegestaan. Daarom is het niet toegestaan ​​als er beide wijzigingen zijn
tussen de werkboom en HEAD, en tussen HEAD en het doel. Voor de zekerheid is dat ook zo
niet toegestaan ​​als er niet-samengevoegde vermeldingen zijn.

De volgende tabellen laten zien wat er gebeurt als er niet-samengevoegde vermeldingen zijn:

werkindex HEAD doelwerkindex HEAD
-------------------------------------------------- -
XUAB --zacht (niet toegestaan)
--gemengde XBB
--harde BBB
--BBB samenvoegen
--houden (niet toegestaan)

werkindex HEAD doelwerkindex HEAD
-------------------------------------------------- -
XUAA --zacht (niet toegestaan)
--gemengde XAA
--harde AAA
--AAA samenvoegen
--houden (niet toegestaan)

X betekent elke staat en U betekent een niet-samengevoegde index.

GIT

Een deel van de git(1) Suite

Gebruik git-reset online met behulp van onworks.net-services