Acest lucru depinde foarte mult la ce te referi prin "reveniți".

Comuta temporar la o altă comite

Dacă doriți să temporar du-te înapoi la ea, prosti, apoi întoarce-te de unde ești, tot ce trebuie sa faci este a verifica afară de dorit comite:

# This will detach your HEAD, that is, leave you with no branch checked out:
git checkout 0d1d7fc32

Sau dacă vrei să faci comite în timp ce're aici, mergeți mai departe și de a face o nouă ramură în timp ce're la ea:

git checkout -b old-state 0d1d7fc32

Pentru a merge înapoi de unde ai fost, doar a verifica afară de filiala ai fost pe din nou. (Daca'am făcut schimbări, ca întotdeauna, atunci când trecerea de ramuri, tu'll au de a face cu ei, după caz. Ai putea reseta să le arunce; ai putea marfa, verificare marfa pop a le lua cu tine; ai putea să-i angajeze la o sucursală acolo daca vrei o sucursală acolo.)

Tare a șterge nepublicate se angajează

Dacă, pe de altă parte, vrei să scapi de tot ce ai'am făcut de atunci, există două posibilități. O, dacă te-ai't publicat oricare dintre acestea se angajează, pur și simplu reset:

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

Dacă o dai în bară, ai'am deja aruncate local schimbări, dar cel puțin puteți obține înapoi de unde ai fost înainte de resetarea din nou.

Undo publicat comite cu noi se angajează

Pe de altă parte, dacă te'am publicat lucrarea, probabil că don't doriți să resetați sucursala, din care's efectiv rescrierea istoriei. În acest caz, ai putea într-adevăr reveni angajează. Cu Git, reveniți are o semnificație foarte specifice: de a crea o comite cu reverse patch-uri pentru a-l anula. În acest fel nu't rescrie orice istorie.

# This will create three separate revert commits:
git revert a867b4af 25eee4ca 0766c053

# It also takes ranges. This will revert the last two commits:
git revert HEAD~2..HEAD

#Similarly, you can revert a range of commits using commit hashes:
git revert a867b4af..0766c053 

# Reverting a merge commit
git revert -m 1 <merge_commit_sha>

# To get just one, you could use `rebase -i` to squash them afterwards
# Or, you could do it manually (be sure to do this at top level of the repo)
# get your index and work tree into the desired state, without changing HEAD:
git checkout 0d1d7fc32 .

# Then commit. Be sure and write a good message describing what you just did
git commit

A git-revert manpage de fapt, acoperă o mulțime de acest lucru în descrierea acestuia. Un alt link util este acest git-scm.com secțiunea despre git-a reveni]2.

Dacă vă decideți ai n't doriți să reveniți la urma urmei, puteți reveni reveni (după cum este descris aici) sau reseta înapoi la înainte de a reveni (a se vedea secțiunea anterioară).

De asemenea, puteți găsi acest răspuns util în acest caz: https://stackoverflow.com/questions/34519665/how-to-move-head-forward-checkout-revet-reflog-reset/34519716#34519716

O mulțime de complicat și de periculos răspunsuri aici, dar's, de fapt, simplu:

git revert --no-commit 0766c053..HEAD
git commit

Acest lucru va reveni totul, de la CAP la comiterea hash, ceea ce înseamnă că va recrea care comit stat în arborele de lucru ca fiecare comite de când a fost de mers înapoi. Apoi, puteți comite actuala copac, și se va crea un nou brand comite în esență echivalent cu a comite tine "a revenit" pentru a.

(The ... nu-comite pavilion vă permite git reveni tot se angajează la o dată - altfel'll fi determinat pentru un mesaj pentru fiecare comite în intervalul, gunoaiele istoria ta cu inutile nou comite.)

Aceasta este o mod sigur și ușor de revenire la o stare anterioară. Nu istoria este distrus, astfel încât acesta poate fi utilizat pentru a comite că au fost deja făcute publice.

Rogue Coder?

Lucrează pe cont propriu și doar doresc să lucreze? Urmați aceste instrucțiuni de mai jos, au lucrat în mod fiabil pentru mine si multi altii de ani de zile.

De lucru cu alții? Git este complicat. Citesc comentariile de mai jos acest răspuns înainte de a face ceva necugetat.

Revenirea Copie de Lucru pentru a Comite cele Mai Recente

Pentru a reveni la o versiune anterioară a comis, ignorând orice modificări:

git reset --hard HEAD

în cazul în care CAPUL este ultimul comite în ramură

Revenirea În Copia de Lucru la o Vârstă mai Comite

Pentru a reveni la un comis's mai mari decât cele mai recente comite:

# Resets index to former commit; replace '56e05fced' with your commit code
git reset 56e05fced 

# Moves pointer back to previous HEAD
git reset --soft HEAD@{1}

git commit -m "Revert to 56e05fced"

# Updates working copy to reflect the new commit
git reset --hard

Du-te la credite similare Stack Overflow întrebare, https://stackoverflow.com/questions/1895059/git-revert-to-a-commit-by-sha-hash.

Cea mai bună opțiune pentru mine și probabil și altele este Git opțiune de resetare:

git reset --hard <commidId> && git clean -f

Aceasta a fost cea mai bună opțiune pentru mine! Este simplu, rapid și eficient!

Notă : după Cum sa menționat în comentarii don't face acest lucru daca're schimbul de ramură cu alte persoane care au copii de vârstă se angajează

De asemenea, de la comentarii, dacă ai vrut-o mai 'ballzy' metoda ai putea folosi

`git curat -o

Înainte de a răspunde să's adăuga unele fundal, explicând de ce acest "CAPUL" este.

Mai întâi de toate ce este CAPUL?`

"CAPUL" este pur și simplu o referire la curent comite (cele mai recente) pe ramura curentă. Nu poate fi doar un singur " ȘEF " la un moment dat (cu excepția git worktree).

Conținutul de " ȘEF " este stocat în interiorul .git/HEAD, și conține 40 de bytes SHA-1 de curent a comis-o.

desprinse CAPUL

Dacă nu sunteți pe cele mai recente comite - în sensul că "ȘEFUL" este îndreptat spre o prealabilă se angajeze în istorie l's desprinse CAPUL.

În linia de comandă se va arata ca asta - SHA-1 în loc de ramura numele de " ȘEF " nu este îndreptat spre vârful ramură de curent:

Câteva opțiuni cu privire la modul de a recupera de la un CAP detașat:

git checkout

git checkout <commit_id>
git checkout -b <new branch> <commit_id>
git checkout HEAD~X // x is the number of commits t go back

Acest lucru va checkout nouă ramură de indicare a dorit a comis-o. Această comandă va plateste pentru a o dat a comis-o.

În acest moment, puteți crea o sucursală și începe să lucreze la acest moment:

# Checkout a given commit.
# Doing so will result in a `detached HEAD` which mean that the `HEAD`
# is not pointing to the latest so you will need to checkout branch
# in order to be able to update the code.
git checkout <commit-id>

# Create a new branch forked to the given commit
git checkout -b <branch name>

git reflog

Îl poți folosi întotdeauna reflog, la fel de bine.git reflog ` va afișa orice schimbare care a actualizat " ȘEF "și verificarea dorit reflog intrare va stabili" ȘEF " înapoi la acest comis-o.

De fiecare dată când CAPUL este modificat nu va fi o nouă intrare în reflog`

git reflog
git checkout HEAD@{...}

Acest lucru va duce înapoi dorit comite

git reset CAP ... greu <commit_id>

"Mut" capul pe spate dorit a comis-o.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

• Notă: (Din Git 2.7), puteți utiliza, de asemenea, `git rebazare ... nu-autostash, la fel de bine.

Această schemă ilustrează care comanda ce face. După cum puteți vedea acolo reset && checkout modifica CAP.

Dacă doriți pentru a "uncommit", șterge ultimul comite mesaj, și pune fișierele modificate înapoi în așteptare, ar trebui să utilizați comanda:

git reset --soft HEAD~1

• --soft indică faptul că neangajate fișiere ar trebui să fie păstrate ca fișiere de lucru deosebire de greu, care ar aruncați-le.
• CAP~1este ultimul a comis-o. Dacă doriți să rollback 3 se angajează ai putea folosi CAPUL~3. Dacă doriți să rollback la un anumit număr de revizie, ai putea face, de asemenea, că utilizarea acestuia SHA hash.

Aceasta este o comandă extrem de utilă în situații în care ai comis ceva greșit și doriți să anulați ultima comis-o.

Sursa: http://nakkaya.com/2009/09/24/git-delete-last-commit/

Puteți face acest lucru prin următoarele două comenzi:

git reset --hard [previous Commit SHA id here]
git push origin [branch Name] -f

Se va elimina anterioare Git commit.

Dacă doriți să păstrați modificările, puteți utiliza, de asemenea:

git reset --soft [previous Commit SHA id here]

Apoi se va salva modificările.

Am încercat o mulțime de moduri de a reveni modificări locale în Git, și se pare că acest lucru funcționează cel mai bine dacă doriți doar pentru a reveni la cea mai recentă comite de stat.

git add . && git checkout master -f

Scurta descriere:

• NU va crea nicio angajează ca git reveni nu.
• NU-ți rupă CAPUL ca `git checkout nu mai contează.
• Se VA suprascrie toate modificările locale și a ȘTERGE toate fișierele adăugate de la ultima comite în ramură.
• Functioneaza numai cu ramuri de nume, astfel încât să puteți reveni doar la cele mai recente comite în ramura de acest fel.

Am găsit-o mult mai comod si simplu mod de a obține rezultatele de mai sus:

git add . && git reset --hard HEAD

în cazul în care CAPUL puncte cele mai recente comite la curent ramură.

Este acelasi cod ca boulder_ruby sugerat, dar am adăugat `git add . "înainte de" git reset ... e greu CAPUL pentru a șterge toate fișierele noi create de la ultima comite deoarece aceasta este ceea ce majoritatea oamenilor se așteaptă cred că atunci când revenirea la cea mai recentă a comis-o.

OK merge înapoi la precedentă în git este destul de ușor...

Reveniți fără a ține modificări:

git reset --hard <commit>

Reveniți cu păstrarea modificări:

git reset --soft <commit>

Explicați: folosind git reset, puteți reseta la un anumit stat, l's comună folosind-o cu o comite hash după cum vedeți mai sus.

Dar, după cum vedeți diferența este folosind două steaguri - moale " și "greu, în mod implicit git reset "folosind" - moale pavilion, dar's o bună practică întotdeauna folosind steagul, am explica fiecare pavilion:

- moale

Implicit pavilion a explicat ca, nu trebuie să-l ofere, nu se schimba arborele de lucru, dar se adaugă toate modificările de fișiere gata să se angajeze, așa că du-te înapoi la comiterea de stare care modificări la fișierele nestaditizat.

--hard

Fii atent cu acest steag, se resetează arborele de lucru și toate modificările urmărite fișiere și totul va fi plecat!

Am creat, de asemenea, imaginea de mai jos, care se poate întâmpla într-o viață reală de lucru cu git:

Presupunând că ai're vorbesc despre maestru și pe care filialelor respective (asta a spus, acest lucru ar putea fi orice lucru sucursala're în cauză cu):

# Reset local master branch to November 3rd commit ID
git reset --hard 0d1d7fc32e5a947fbd92ee598033d85bfc445a50

# Reset remote master branch to November 3rd commit ID
git push -f origin 0d1d7fc32e5a947fbd92ee598033d85bfc445a50:master

Am găsit răspunsul într-un post pe blog (acum nu mai există)

Rețineți că acest lucru este Resetarea și Forțând schimbarea de la distanță, așa că, dacă alții din echipa ta au deja git tras, vă va cauza probleme pentru ei. Te distrug schimba istoria, care este un motiv important pentru care oamenii folosesc git în primul rând.

Mai bine să folosiți reveni (a se vedea alte răspunsuri) decat reset. Daca're un om de o echipa de atunci, probabil, nu't contează.

Nimic de aici nu a lucrat pentru mine în afară de exact această combinație:

git reset --hard <commit_hash>
git push origin <branch_name> --force

Cheia aici este forțând împinge, nu se angajează/comite mesaje etc.

Spune că ai avea următoarele se angajează într-un fișier text cu numele ~/commits-to-revert.txt (eu am folosit git log-destul de=oneline pentru a le obține)

fe60adeba6436ed8f4cc5f5c0b20df7ac9d93219
0c27ecfdab3cbb08a448659aa61764ad80533a1b
f85007f35a23a7f29fa14b3b47c8b2ef3803d542
e9ec660ba9c06317888f901e3a5ad833d4963283
6a80768d44ccc2107ce410c4e28c7147b382cd8f
9cf6c21f5adfac3732c76c1194bbe6a330fb83e3
fff2336bf8690fbfb2b4890a96549dc58bf548a5
1f7082f3f52880cb49bc37c40531fc478823b4f5
e9b317d36a9d1db88bd34831a32de327244df36a
f6ea0e7208cf22fba17952fb162a01afb26de806
137a681351037a2204f088a8d8f0db6e1f9179ca

A crea un Bash script de shell pentru a reveni în fiecare dintre ele:

#!/bin/bash
cd /path/to/working/copy
for i in `cat ~/commits-to-revert.txt`
do
    git revert $i --no-commit
done

Aceasta revine totul înapoi la starea anterioară, inclusiv de fișier și director creații, și eliminări, comite la filiala dumneavoastră și de a vă păstra istoria, dar ai revenit la aceeași structură de fișiere. De ce Git nu't au o git reveni --a <hash> este dincolo de mine.

În plus Alternative la Jefromi's Soluții

Jefromi's soluțiilor sunt cu siguranta cele mai bune, și cu siguranță ar trebui să le folosească. Cu toate acestea, pentru motive de exhaustivitate, de asemenea, am vrut să arăt aceste alte soluții alternative care pot fi, de asemenea, folosit pentru a reveni un comite (în sensul că: crearea unui nou comite că anulează modificările anterioare se angajeze, doar ca ce git reveni nu).

Să fie clar, aceste alternative nu sunt cel mai bun mod de a reveni comite, Jefromi's soluții sunt, dar vreau doar să subliniez că, de asemenea, puteți utiliza aceste metode pentru a realiza același lucru ca git reveni.

Alternativa 1: Hard si Soft Resetează

Aceasta este o versiune ușor modificată a lui Charles Bailey's soluție pentru a https://stackoverflow.com/questions/1895059/revert-to-a-commit-by-sha-hash-in-git/1895095#1895095:

# Reset the index to the desired commit
git reset --hard <commit>

# Move the branch pointer back to the previous HEAD
git reset --soft HEAD@{1}

# Commit the changes
git commit -m "Revert to <commit>"

Acest principiu funcționează prin utilizarea faptul că moale resetează va părăsi statul anterior a comis organizat în index/intermediere-zona, pe care o puteți apoi a comis-o.

Alternativa 2: Ștergeți Curent Copac și Înlocuiți-l cu Unul Nou

Această soluție vine de la svick's soluție pentru a https://stackoverflow.com/questions/3380805/checkout-old-commit-and-make-it-a-new-commit/3382249#3382249:

git rm -r .
git checkout <commit> .
git commit

În mod similar la alternative #1, aceasta reproduce starea de <comit> în actualul copia de lucru. Este necesar să se facă git rm în primul rând pentru că git checkout va't a elimina fișierele care au fost adăugate de`.

Aici este un mult mai simplu modalitate de a merge înapoi la o versiune anterioară a comis (și să-l într-un uncommited de stat, de-a face cu ce vrei):

git reset HEAD~1

Deci, nu este nevoie pentru a comite id-uri și așa mai departe :)

Există o comanda (nu fac parte din core Git, dar este în git-extras pachet) special pentru revenirea și stadializarea veche se angajează:

git back

Pe pagina, acesta poate fi de asemenea folosit ca atare:

# Remove the latest three commits
git back 3

După toate modificările, atunci când vă împinge toate aceste comenzi, s-ar putea să utilizați:

git push -f ...

Și nu numai git push.

Puteți completa toate aceste etape inițiale-te și împinge înapoi de la git repo.

1. Trage ultima versiune de depozit de la Bitbucket folosind git pull-toate comanda.

2. Rula git log de comandă cu -n 4 de la terminal. Numărul de după -n determină numărul de comite în jurnal pornind de la cele mai recente comite în istoria locală.

$ git log-n 4

3. Resetare șeful de depozit's istorie, folosind git reset --greu de CAP~N unde N este numărul de comite doriți să ia capul înapoi. În exemplul următor cap ar fi dat înapoi cu o comite, la ultimul comite în repository istorie:

4. Împinge schimbarea la git repo folosind git push --vigoare la forța de împingere schimbarea.

Dacă doriți depozit git la un precedent comite

git pull --all
git reset --hard HEAD~1
git push --force

Reveniți la cele mai recente să se angajeze și ignorând toate modificările locale:

git reset --hard HEAD

Selectați necesare comis-o, și verificați-l de

git show HEAD
git show HEAD~1
git show HEAD~2 

până ajungi necesare comis-o. Pentru a face CAPUL punct pentru asta, nu

git reset --hard HEAD~1

sau git reset --greu de CAP~2 sau orice altceva.

Pentru a curăța complet de un coder's director de unele modificări accidentale, am folosit:

git add -A .
git reset --hard HEAD

Doar git reset --greu de CAP va scapa de modificări, dar nu o't a scăpa de "noi" fișiere. În cazul lor au'd accidental tras un dosar important, undeva, la întâmplare, și toate aceste fișiere au fost tratați ca noi de Git, deci un reset-hard n't fix it. Prin rularea git add-O . în prealabil, în mod explicit, i-a urmărit toate cu git, pentru a fi sters de resetare.