Din greșeală am comis greșit fișiere pentru a Git, dar nu am't împins să comită încă pe server.
Cum pot anula aceste se angajează de la depozitul local?
$ git commit -m "Something terribly misguided" # (1)
$ git reset HEAD~ # (2)
<< edit files as necessary >> # (3)
$ git add ... # (4)
$ git commit -c ORIG_HEAD # (5)
git de stare, așa că'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 folosi
git reset-moale CAPUL~în loc, care este ca
git reset CAP~`2 dar lasă existente modificări organizat..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:
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 cu
CAPUL~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ță):
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.
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.
Î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.
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.
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
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.
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 [email protected]: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.
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.
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.
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.
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ă 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.
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.
git reset --greu de CAP^
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ță ...