Cum pot anula cele mai recente locale se angajează în Git?

Anula o comite și redo

$ git commit -m "Something terribly misguided"             # (1)
$ git reset HEAD~                                          # (2)
>                              # (3)
$ git add ...                                              # (4)
$ git commit -c ORIG_HEAD                                  # (5)

1. Aceasta este ceea ce doriți să anulați.
2. Asta nu face nimic pentru dumneavoastră de lucru brad (starea de fișiere de pe disc), dar anulează comite și frunze de modificările pe care le-a comis nestaditizat (astfel încât acestea'll apar ca "Modificări nu au organizat pentru a comite" în git de stare, așa că&#39;ll nevoie pentru a le adăuga din nou înainte de a comite). Dacă tu *singura* vrei să - *add* mai multe schimbări la comiterea precedentă, sau schimba comite mesaj<sup>1</sup>, ai putea folosigit reset-moale CAPUL~în loc, care este cagit reset CAP~`2 dar lasă existente modificări organizat.
3. Face corecții la lucru arbore de fișiere.
4. `git adăuga nimic care doriți să le includeți în noua ta a comis-o.
5. Se fac schimbările, reutilizarea vechi comite mesaj. "reset" copiat vechiul capul .git/ORIG_HEAD; a comis " cu " - c ORIG_HEAD se va deschide un editor, care conține inițial jurnalul mesaj de la vechi a comis-o și vă permite să-l editați. Dacă nu aveți nevoie pentru a edita mesajul, ai putea folosi "- C " opțiune.

Feriți-vă, totuși, că dacă ați adăugat noi modificări la index, folosind a comis-o ... amend le va adăuga la dvs. anterior a comis-o.

În cazul în care codul este deja împins la server-ul dvs. și aveți permisiuni pentru a suprascrie istorie (rebazare), atunci:

git push origin master --force

Puteți, de asemenea, uita-te la acest răspuns:

https://stackoverflow.com/questions/34519665/how-to-move-head-back-to-a-previous-location-detached-head/34519716#34519716

Răspunsul de mai sus vă va arăta git reflog care este folosit pentru a afla ce este SHA-1 care doriți să reveniți la. Odată ce ați găsit punctul la care doriți să anulați pentru a utiliza secvența de comenzi cum am explicat mai sus.

1 Rețineți, totuși, că nu't nevoie pentru a reseta la o mai devreme comite dacă ai făcut o greșeală în comite mesaj. Mai simplă opțiune-este de a git reset (a unstage orice modificări pe care le'am făcut de atunci) și apoi git a comis-o ... amend, care va deschide implicit comite editor mesaj de pre-populate cu ultimul comite mesaj.

2 CAPUL~este acelasi lucru cuCAPUL~1`

Anularea unei comite este un pic înfricoșător, dacă nu't știu cum funcționează. Dar's, de fapt uimitor de ușor, dacă înțelegi.

Spune că ai acest lucru, în cazul în care C este CAPUL și (F) este starea dumneavoastră de fișiere.

   (F)
A-B-C
    ↑
  master

Vrei sa bomba comis-C și niciodată nu-l văd din nou. Puteți face acest lucru:

git reset --hard HEAD~1

Rezultatul este:

 (F)
A-B
  ↑
master

Acum B este CAPUL. Pentru că ai folosit greu, fișierele dvs. sunt resetate la starea lor la comiterea B.

Ah, dar să presupunem că a comis C n't un dezastru, dar doar un pic off. Vrei sa anula-a comis, dar ține-ți modificări pentru un pic de editare înainte de a face o mai comit. Pornind din nou de aici, cu C CAPULUI tău:

   (F)
A-B-C
    ↑
  master

Puteți face acest lucru, lăsând pe greu:

git reset HEAD~1

În acest caz, rezultatul este:

   (F)
A-B-C
  ↑
master

În ambele cazuri, CAPUL este doar un pointer la ultima comis-o. Atunci când faci un git reset CAP~1, spune Git pentru a muta indicatorul CAP înapoi o comite. Dar (dacă nu utilizați greu) vă lăsați fișiere cum au fost. Deci, acum git status arată modificările pe care le-am verificat în C. Ai't pierdut nimic!

Pentru cea mai ușoară atingere, puteți chiar anulare se angajeze, dar lasă fișierele și index:

git reset --soft HEAD~1

Acest lucru nu numai că lasă fișierele singur, chiar frunze de ta index singur. Când faci git status, ai'll vedea că aceleași fișiere sunt în index ca și mai înainte. În fapt, imediat după această comandă, ai putea să faci pentru git commit` și'd fi refăcute același comite tocmai ai avut-o.

Un lucru mai mult: să Presupunem că distruge o comite ca și în primul exemplu, dar apoi descoperi ca ai nevoie de ea, după toate? Ghinion, nu?

Nu, nu's ** încă o modalitate de a obține înapoi. Tip git reflog și'll vedea o lista (partiala) a comis shas (care este, hash-uri) pe care le's-a mutat în jurul valorii de în. Găsi comis-ai distrus, și face acest lucru:

git checkout -b someNewBranchName shaYouDestroyed

Te'am acum înviat care a comis-o. Se angajează don't obține de fapt, distruse in Git pentru 90 de zile, astfel încât să puteți, de obicei, du-te înapoi și de a salva o ai n't înseamnă a scăpa de.

Mi-a luat ceva timp să-mi dau seama, așa că poate asta va ajuta pe cineva...

Există două moduri de a "anula" ultima ta comite, în funcție de dacă sau nu ați făcut deja comite publice (împins la depozit la distanță):

Cum de a anula o comite locale

Las's spun m-am angajat la nivel local, dar acum vreau pentru a elimina pe care a comis-o.

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

Pentru a restabili totul cum a fost înainte de ultima comis-o, trebuie să "reset" pentru a comite înainte de "ȘEF":

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

Acum git log va arăta că ultima noastră comite a fost eliminat.

Cum de a anula o comite publice

Dacă ați făcut deja ți se angajează public, veți dori să creați un nou comit care va "reveniți" modificările efectuate în comiterea precedentă (actualul ȘEF).

git revert HEAD

Modificările dvs. vor fi acum a revenit și gata pentru a comite:

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

Pentru mai multe informații, a verifica afară Git de Bază - Desfacerea Lucruri

Adaugă/șterge fișierele pentru a obține lucrurile așa cum doriți:

git rm classdir
git add sourcedir

Apoi modifica comite:

git commit --amend

Anterior, eronate comite vor fi editate pentru a reflecta noua indicele de stat - cu alte cuvinte,'ll fi ca tine n-a făcut niciodată o greșeală în primul rând.

Rețineți că trebuie să fac asta doar dacă te-ai't împins încă. Dacă ați apăsat, apoi'll trebui să comită o stabilească în mod normal.

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

sau

git reset --hard HEAD~1

Avertisment: comanda De mai sus va elimina definitiv modificările `.java fișierele (și orice alte fișiere) pe care ai vrut să se angajeze.

Pe `hard reset " la " CAP-1 va seta copia de lucru a statului de a comite înainte de a-ți greșit comis-o.

Pentru a schimba ultima comite

Înlocuiți fișierele în index:

git rm --cached *.class
git add *.java

Apoi, dacă-l's o ramură privată, modifica commit:

git commit --amend

Sau, dacă-l's o sucursală în comun, a face un nou comite:

git commit -m 'Replace .class files with .java files'

(pentru a schimba un precedent comite, utilizați minunat [interactive rebazare])

ProTip™:   Adauga *.clasa la o gitignore pentru a opri acest lucru se întâmplă din nou.

Pentru a reveni o comite

De modificare a o comite este soluția ideală dacă aveți nevoie pentru a schimba ultimele comis-o, dar o mai soluție generală este de "reset".

Puteți reseta git la orice comite cu:

git reset @~N

Unde " N "este numărul de comite înainte de "ȘEF", și @~ resetează la care anterior a comis-o.

Deci, în loc de modificare a comis-o, ai putea folosi:

git reset @~
git add *.java
git commit -m "Add .java files"

Check out git ajuta reset, în special în secțiunile privind - moale --mixte " și " greu, pentru o mai bună înțelegere a ceea ce face.

Reflog

Dacă o dai în bară, îl poți folosi întotdeauna reflog pentru a găsi scăzut se angajează:

$ git reset @~
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~
2c52489 HEAD@{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

Folosesc git reveni `

Dacă sunteți de planificare pentru a anula un local comite în întregime, orice ai schimba-ai făcut pe comis-o, iar dacă nu't vă faceți griji nimic despre asta, doar face următoarea comandă.

git reset --hard HEAD^1

(Această comandă va ignora tot a comis-o și modificările vor fi pierdute complet de lucru locală copac). Dacă doriți să anulați comis-o, dar doriți ca modificările efectuate în zonă de așteptare (înainte de a comite doar ca dupa git add), apoi face următoarea comandă.

git reset --soft HEAD^1

Acum comis fișiere venit în zonă de așteptare. Să presupunem că, dacă vrei să upstage fișiere, pentru că aveți nevoie pentru a edita un conținut greșit, apoi face următoarea comandă

git reset HEAD

Acum comis fișiere să vină din partea organizat zonă în nestaditizat zona. Acum fișierele sunt gata pentru a edita, astfel încât orice ai schimba, vrei să mergi edita și-a adăugat și un nou/noi a comis-o.

Mai mult

Dacă aveți Git Extras instalat, puteți rula git de anulare pentru a anula ultima comis-o.git anula 3` va anula ultimele 3 angajează.

Am vrut să-anulează cea mai recentă 5 se angajează în nostru depozit comun. M-am uitat de revizuire id-ul pe care am vrut să rollback. Apoi am scris în cele ce urmează.

prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
prompt> git push origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To git@bitbucket.org:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
prompt>

Eu prefer să folosesc git rebazare -am pentru treaba asta, pentru că o listă apare de unde pot alege angajează să scape de. S-ar putea să nu fie la fel de directă ca și alte răspunsuri, dar se simte bine.

Alegeți cât de multe se angajează doriți să lista, apoi invoca ca aceasta (să se înroleze ultimele trei)

git rebase -i HEAD~3

Listă eșantion

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

Apoi Git va elimina angajează pentru orice linie care te elimina.

Cum de a repara locale anterioare comite

Utilizare git-gui (sau similare) pentru a efectua o git a comis-o ... amend. Din GUI puteți adăuga sau elimina fișiere individuale din comit. Puteți modifica, de asemenea, comite mesaj.

Cum de a anula locale anterioare comite

Doar reseta ramură de la locul precedent (de exemplu, folosind gitk " sau " git rebazare). Apoi reaplica se schimbă de la o copia salvată. După colectarea gunoiului în depozit local, acesta va fi o astfel de nedorite comite niciodată nu s-a întâmplat. Pentru a face toate astea într-o singură comandă, utilizați git reset CAP~1.

Avertisment: utilizarea Neglijentă a git reset este o modalitate buna de a obține copia de lucru într-un confuz de stat. Recomand Git novici evita acest lucru, dacă se poate.

Cum de a anula o publice comite

Efectuați o reverse aleagă (git-a reveni) pentru a anula modificările.

Dacă te-ai't tras încă alte modificări pe ramură, puteți face pur și simplu...

git revert --no-edit HEAD

Apoi împingeți actualizat ramură la depozit comun.

Comite istoria va arăta ambele se angajează, separat.

Avansata: Corectarea privat filiala din depozit publice

Acest lucru poate fi periculos -- asigurați-vă că aveți o copie locală a filialei a repush.

De asemenea, rețineți: nu't vrei să faci asta dacă altcineva ar putea fi de lucru pe ramură.

git push --delete (branch_name) ## remove public version of branch

Curat filiala local atunci repush...

git push origin (branch_name)

În cazul normal, probabil ai nevoie de't vă faceți griji despre dvs. private-filiala comite o istorie a fi curat. Împinge doar o urmarire comite (a se vedea 'Cum de a anula o publice comit' de mai sus), și mai târziu, face un squash-merge pentru a ascunde istoria.

Dacă vrei să-permanent-l desfaci și ai clonat un depozit

A comite id-ul poate fi văzut de către

git log 

Apoi, puteți face -

git reset --hard 

git push origin  -f

Dacă ați comis nedorite, dar nu împins,

git reset --soft HEAD~1

CAP~1 este o prescurtare pentru a comite înainte de cap. Alternativ, puteți face referire la SHA-1 hash dacă doriți să resetați sa. - moale opțiune va șterge comis, dar se va lăsa toate fișierele modificate "Schimbări să fi comis", ca git status-ar pune.

Dacă vrei să scapi de orice modificare a urmărit fișiere în arborele de lucru de la comite înainte de a cap de utilizare "greu" în loc.

SAU

Dacă deja ai împins și l-a tras cineva care este de obicei cazul meu, puteți't de a folosi git reset. Cu toate acestea, puteți face o git reveni,

git revert HEAD

Acest lucru va crea un nou comit care inverseaza totul introduse prin accidentală a comis-o.

Pe SourceTree (GUI pentru GitHub), puteți face clic dreapta pe cea de comite și de a face o 'Invers Comis'. Acest lucru ar trebui să anulați modificările.

Pe terminal:

Puteți folosi alternativ:

git revert

Sau:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

O singură comandă:

git reset --soft 'HEAD^' 

It works mare pentru a anula ultima locale comis-o!

Doar resetarea se face comanda de mai jos, folosind git:

git reset --soft HEAD~1

Explicați: * ce git reset nu, l's de fapt "reset" pentru orice se angajeze'd dori să mă întorc, apoi, dacă îl combinați cu - moale-cheie, se va întoarce, dar păstrați modificările în fișierul(e), astfel încât să obțineți înapoi la stadiul în care fișierul a fost adăugat, "CAPUL" este șeful filialei și dacă combina cu~1(în acest caz, utilizați, de asemenea, CAPUL^), se va reveni doar unul care comite ceea ce vrei...

Am crea pașii din imaginea de mai jos în mai multe detalii pentru tine, inclusiv toate măsurile care se întâmplă în situații reale și comiterea cod:

Cum de a anula ultima Git commit?

Pentru a restabili totul cum a fost înainte de ultima comis-o, trebuie să resetați să se angajeze înainte de CAP.

1. Dacă tu nu't doriți să păstrați modificările pe care le-a făcut:

git reset --greu de CAP^

2. Dacă doriți să păstrați modificările:

git reset-moale CAPUL^

Acum verifica git log. Se va arăta că ultima noastră comite a fost eliminat.

Utilizarea reflog pentru a găsi o corectă stat

git reflog

REFLOG ÎNAINTE RESET

Selectați corect reflog (f3cb6e2 în cazul meu) și de tip

git reset --hard f3cb6e2

După aceea repo CAPUL va fi resetat la care HEADid LOG DUPĂ RESET

În cele din urmă reflog arată ca în imaginea de mai jos

REFLOG FINAL

"Reseta arborele de lucru la ultimul comite"

git reset --hard HEAD^ 

"Curat fișierele necunoscute de pe arborele de lucru"

git clean    

vezi - Git de Referință Rapidă

NOTĂ: - Această comandă va șterge precedent comis-o, deci utilizați cu prudență! git reset ... e greu e mai în siguranță ...