204 Comments:

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

    o o o o o

    git reset --hard HEAD~1
    

    attenzione: il comando di cui sopra rimuoverà definitivamente le modifiche ai file .java (e ad altri file) che si voleva commettere.

    il hard reset a HEAD-1 imposta la tua copia di lavoro allo stato della commit prima della tua commit sbagliata.

    1. "--hard" eliminerà i file .java modificati nella directory di lavoro che voleva commettere.
    1. puoi modificare la copia di "git stash save", fare un reset hard e poi "git stash pop" per riottenerla, anche se suppongo che un reset soft sarebbe più semplice.
    1. un altro uso di 'scorciatoia' di stash; se vuoi sbloccare tutto (Annulla git add), solo git stash, poi git stash pop
  2. annullare una commit e ripristinare

    $ 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)
    
    1. questo è ciò che si desidera annullare.
    2. questo lascia il tuo albero di lavoro (lo stato dei tuoi file sul disco) invariato, ma annulla la commit e lascia i cambiamenti che hai commesso unstaged (in modo che appariranno come "Modifiche non messe in scena per commit" in git status, quindi avrai bisogno di aggiungerli di nuovo prima di fare commit). se si desidera solo aggiungere ulteriori modifiche alla commit precedente, o modificare il messaggio di commit 1, è possibile utilizzare git reset --soft HEAD~, che è come git reset HEAD~ (dove HEAD~ è lo stesso di HEAD~1), ma lascia le modifiche esistenti in scena.
    3. apportare le correzioni ai file albero di lavoro.
    4. git add tutto ciò che si desidera includere nella nuova commit.
    5. commetti le modifiche, riusando il vecchio messaggio di commit. reset copiato il vecchio capo a .git/ORIG_HEAD; commit con -c ORIG_HEAD aprirà un editor, che inizialmente contiene il messaggio di log della vecchia commit e consente di modificarlo. se non è necessario modificare il messaggio, è possibile utilizzare l'opzione -C.

    attenzione però che se hai aggiunto nuove modifiche all'indice, usando commit --amend le aggiungerai alla commit precedente.

    se il codice è già spinto al server e hai i permessi per sovrascrivere la cronologia (rebase) allora:

    git push origin master --force
    

    puoi anche guardare questa risposta:

    come spostare HEAD verso una posizione precedente? (testa staccata) & amp; Annulla commit

    la risposta di cui sopra vi mostrerà git reflog che viene utilizzato per scoprire qual è l'SHA-1 che si desidera ripristinare. una volta trovato il punto a cui si desidera annullare per utilizzare la sequenza di comandi come spiegato sopra.


    1 Nota, tuttavia, che non hai bisogno di reimpostare una commit precedente se hai appena fatto un errore nel tuo messaggio di commit. l'opzione più semplice è quella di git reset (per annullare le modifiche che hai fatto da allora) e poi git commit --amend, che aprirà il tuo editor predefinito di messaggi di commit pre-popolato con l'ultimo messaggio di commit.

    1. e se la commit era nel ramo sbagliato, puoi git checkout theRightBranch con tutte le fasi dei cambiamenti. come ho dovuto fare.
    1. se stai lavorando in DOS, invece di git reset --soft HEAD^ dovrai usare git reset --soft HEAD~1. il ^ è un carattere di continuazione nel DOS in modo da non funzionerà correttamente. inoltre, --soft è il default, in modo da poter omettere se ti piace e dire solo git reset HEAD~1.
    1. inoltre, in zsh devi citare ^, quindi git reset --soft 'HEAD^'... almeno ho fatto
    1. (correzione a quello che ho scritto sopra; --mixed è il default. --mixed significa mantenere i file modificati, ma non tenerli nell'indice. --soft mantiene i file modificati e li mantiene nell'indice come erano appena prima della commit modificata. scusa per la confusione.)
    1. @madhairsilence, git in realtà mantiene i file in giro per circa 30 giorni prima di raccogliere i pacchetti, quindi con git-fu sufficiente puoi anche annullare un reset hard! Otoh, si dovrebbe essere mantenere copie di backup del codice altrove, perché nemmeno reflog in grado di proteggere da un accidentale rm -rf o un crash del disco rigido.
    1. gli utenti zsh potrebbero ottenere: zsh: no matches found: HEAD^ - è necessario sfuggire ^ cioè git reset --soft HEAD\^
    1. questa risposta è fonte di confusione! i numeri rappresentano alternative o passi da fare in ordine? non vedo come potrebbe funzionare.
    1. FYI: dopo la fase 2, i cambiamenti sono ancora in scena. se stai cercando di rimuovere un file specifico dalla tua commit, dovrai scompattarlo manualmente: git reset HEAD filename
    1. cosa succede se non si impegnano a -c ORIG_HEAD, ma solo impegnarsi regolarmente?
    1. sto usando gitbash e quando ho provato il passo 3 (cioè $edit), produce il seguente sh.exe ": Edit: command not found
    1. @Daniel "modifica" significa: USA il tuo editor preferito per apportare le modifiche che intendevi fare prima della commit accidentale.
    1. solo git reset HEAD ^ annullerà la commit precedente e lascerà tutti i file lì.
    1. la risposta non è corretta se, per esempio per caso, git commit -a è stato rilasciato quando il -a dovrebbe essere stato lasciato fuori. in tal caso, è meglio non lasciare fuori il --soft (che si tradurrà in --mixed che è il default) e quindi è possibile ripristinare i cambiamenti che si intendeva commettere.
    1. vale la pena ricordare che git reset --soft HEAD~1 metterà i cambiamenti della commit annullata nell'area di staging (indice), anche se ci sono altri cambiamenti non messi in scena, quindi è fondamentalmente un modo completamente perfetto per tornare a poco prima git commit.
    1. fatal: ambiguous argument 'HEAD~1': unknown revision or path not in the working tree.
    1. perché non usare solo git commit --amend direttamente? e 'molto più facile da ricordare e, a mia conoscenza, funziona esattamente allo stesso modo.
    1. questa soluzione è un problema se qualcuno accidentalmente spinge una commit errata?
    1. Git add... non è un comando corretto, git add documentation non ha mai un pattern per tre punti, inoltre ho provato questo comando nel mio locale, non funziona
    1. @IcyBrk git add è un comando. git add [--verbose | -v] [--dry-run | -n] [--force | -f] [--interactive | -i] [--patch | -p] [--edit | -e] [--[no-]all | --[no-]ignore-removal | [--update | -u]] [--intent-to-add | -N] [--refresh] [--ignore-errors] [--ignore-missing] [--chmod=(+|-)x] [--] [<pathspec>…​]
    1. questo in realtà non serve come modo per annullare un insieme di cambiamenti quelli? questo è più se avete bisogno di modificare un cambiamento?
    1. se hai già inviato le tue modifiche ad un ramo remoto, e fai git reset come mostrato sopra, sarai dietro al ramo remoto. in questa situazione, è preferibile usare git revert che aggiungerà un'altra commit che restituirà le modifiche precedenti. maggiori informazioni qui
    1. @Green Penso che questo accada se si dispone solo di 1 commit... non c'è alcun commit precedente per il reset.
    1. è quasi una risposta completa. nel caso in cui il tuo 'ultimo commit' = = 'il tuo primo commit' - reset non farà altro che lanciare un bel messaggio fatale. in questo caso usare git update-ref -d HEAD.
    1. c'è comunque da annullare gli ultimi 5 commit? qualcosa come git reset HEAD~6 funziona?
    1. anche se hai file troppo grandi che non appartengono e cant completare i tuoi commit iniziali. puoi cancellare .git, rimuovere i tuoi file troppo grandi. Git init e commit -m 'commit iniziale' e poi push -u origin master
      • Git resettare --hard HEAD ~ 1, tornerà ad una commit ed eliminerà tutti i file che git conosce, ma non i file non tracciati, dato che git non ne ha idea. - git reset HEAD ~ 1, manterrà tutte le modifiche della commit corrente, ma le renderà non tracciate - git reset --soft HEAD ~ 1, manterrà i tuoi file registrati e non tracciati
    1. questo è reso più facile da git gui, ancora utile per il server remoto che non hanno gui installato!
  3. aggiungere / rimuovere file per ottenere le cose nel modo desiderato:

    git rm classdir
    git add sourcedir
    

    poi modificare la commit:

    git commit --amend
    

    la commit precedente, errata, sarà modificata per riflettere il nuovo stato dell'indice - in altre parole, sarà come non hai mai fatto l'errore in primo luogo.

    si noti che si dovrebbe fare questo solo se non hai ancora spinto. se hai spinto, allora devi solo commettere una correzione normalmente.

    1. fa questo lavoro quando ho fatto un git commit --amend e quello che volevo veramente fare è un git commit?
    1. @dbm, se accidentalmente modificato, utilizzare git reset --soft <oldref>, dove oldref è l'ID commit prima della modifica. è possibile utilizzare git reflog per identificare il vecchio ID commit. questo annullerà gli effetti della modifica, ma lascia i cambiamenti in scena. poi basta fare git commit per commettere come un commit regolare.
    1. @Dennis, git commit --modify trasforma l'albero corrente (cioè le modifiche messe in scena) in una commit, sovrascrivendo l'attuale HEAD. dopo questo punto, non sono più considerati messi in scena perché fanno parte della commit (cioè, git diff --cached è vuoto), ma non sono "rimossi" o "persi".
  4. per cambiare l'ultima commit

    sostituire i file nell'indice:

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

    quindi, se si tratta di un ramo privato, modificare la commit:

    git commit --amend
    

    oppure, se è un ramo condiviso, fai una nuova commit:

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


    (per cambiare un commit precedente, usa il rebase interattivo impressionante)


    ProTip ™: aggiungere *.class ad un gitignore per fermare questo accada di nuovo.


    come ripristinare una commit

    modificare un commit è la soluzione ideale se devi cambiare l'ultimo commit, ma una soluzione più generale è reset.

    puoi reimpostare git a qualsiasi commit con:

    git reset @~N
    

    dove N è il numero di commit prima di HEAD, e @~ ripristina la commit precedente.

    quindi, invece di modificare la commit, potresti usare:

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

    controllare git help reset, in particolare le sezioni su --soft --mixed e --hard, per una migliore comprensione di ciò che questo fa.

    reflog flog

    se sbagli, puoi sempre usare il reflog per trovare i commit scartati:

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


    1. per chi legge in futuro - si prega di notare che git revert è un comando separato - che fondamentalmente 'ripristina' un singolo commimt.
  5. questo mi ha preso un po 'per capire, quindi forse questo aiuterà qualcuno...

    ci sono due modi per "annullare" la tua ultima commit, a seconda che tu abbia già reso pubblico il tuo commit (spinto al tuo repository remoto):

    come annullare una commit locale

    diciamo che ho commesso localmente, ma ora voglio rimuovere quella commit.

    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
    

    per ripristinare tutto indietro al modo in cui era prima dell'ultimo commit, dobbiamo reset alla commit prima di HEAD:

    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
    

    ora git log mostrerà che il nostro ultimo commit è stato rimosso.

    come annullare un commit pubblico

    se hai già reso pubbliche le tue commit, vuoi creare una nuova commit che "restituisca" le modifiche apportate nella commit precedente (HEAD corrente).

    git revert HEAD
    

    i tuoi cambiamenti saranno ora invertiti e pronti per il tuo commit:

    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
    

    per maggiori informazioni, dai un'occhiata a Git Basics - Undoing Things

    1. ho trovato questa risposta la più chiara. git revert HEAD^ non è il precedente, è il precedente del precedente. ho fatto: git revert HEAD e poi spingere di nuovo e ha funzionato:)
  6. annullare una commit è un po 'spaventoso se non sai come funziona. ma in realtà è incredibilmente facile se si capisce.

    diciamo che hai questo, dove C è il tuo HEAD e (F) è lo stato dei tuoi file.

       (F)
    A-B-C
        ↑
      master
    

    vuoi nuke commit C e non lo vedi mai più. tu fai questo:

    git reset --hard HEAD~1
    

    il risultato è:

     (F)
    A-B
      ↑
    master
    

    ora B è l'HEAD. poiché hai usato --hard, i file vengono reimpostati al loro stato alla commit B.

    Ah, ma supponiamo che il commit C non sia stato un disastro, ma solo un po 'fuori. si desidera annullare la commit ma mantenere le modifiche per un po 'di editing prima di fare una commit migliore. ripartire da qui, con C come HEAD:

       (F)
    A-B-C
        ↑
      master
    

    si può fare questo, lasciando fuori il --hard:

    git reset HEAD~1
    

    in questo caso il risultato è:

       (F)
    A-B-C
      ↑
    master
    

    in entrambi i casi, HEAD è solo un puntatore all'ultima commit. quando si fa un git reset HEAD~1, si dice a Git di spostare il puntatore HEAD indietro di una commit. ma (a meno che non si utilizza --hard) si lasciano i file come erano. così ora git status mostra le modifiche che hai controllato in C. Non hai perso nulla!

    per il tocco più leggero, puoi anche annullare la tua commit ma lasciare i tuoi file e il tuo indice:

    git reset --soft HEAD~1
    

    questo non solo lascia i file da solo, lascia anche il tuo indice da solo. quando si fa git status, vedrete che gli stessi file sono nell'indice come prima. infatti, subito dopo questo comando, si potrebbe fare git commit e si sarebbe rifare la stessa commit che hai appena avuto.

    un'altra cosa: supponiamo di distruggere una commit come nel primo esempio, ma poi scoprire che ne avevi bisogno dopo tutto? fortuna difficile, giusto?

    no, c'è ancora un modo per tornare indietro. digitate git reflog e vedrete una lista di (parziali) SHAS commit (cioè hash) che avete spostato. trova il commit che hai distrutto, e fai questo:

    git checkout -b someNewBranchName shaYouDestroyed
    

    ora sei risorto quel commit. le commit in realtà non vengono distrutte in Git per circa 90 giorni, quindi di solito puoi tornare indietro e salvarne una che non intendevi eliminare.

    1. @Kyralessa: Se faccio due volte git reset --hard HEAD^, lo stato si sposterà a (A)?
    1. @dma_k, sì. oppure si potrebbe fare git reset --hard HEAD^^ una volta. uso la notazione tilde (~) perché la notazione caret (^) non funziona in DOS.
    1. non funziona con OS x. - Ho "argomento ambiguo 'HEAD ^'... Non so revisione o percorso non nell'albero di lavoro". utilizzando lui tilde versione non fa alcuna differenza. ma git log e git status entrambi sembrano mostrare che c'è una commit valida
    1. @Kyralessa - sì, penso che potrebbe essere il problema. in questo caso, ho commesso qualcosa che pensavo fosse piccolo - e quando ho provato a Push, ho trovato che era 400 MB di dati (!) (una cartella Risorse profondamente annidate contenente file video e musicali). quindi, ho bisogno di annullare la commit, ma mantenere i file sorgente, e io li commit più tardi, quando ho una migliore connessione netta - o ad un repo diverso.
    1. un altro bel suggerimento: puoi riattaccare il branch alla commit da cui l'hai rimosso con git branch -f <branch> <commit-id>. salva la necessità di ri-creare commit!
    1. per un principiante di git, non è ovvio quale sia la differenza tra le ultime due opzioni (--soft e quella sopra). menzionare l'indice non aiuta, non sappiamo ancora cosa significa. @nessur's connessione tra soft e Ctrl-Z davvero aiutato! ma ancora non capisco la differenza tra le due opzioni.
    1. e 'molto meglio dire' perché 'qualcosa funziona, che solo per essere detto la risposta. complimenti a questa descrizione - ha aiutato ad essere 'get' git.
    1. grazie anche per la spiegazione. domanda su questa affermazione (ri --hard): "i tuoi file sono reimpostati al loro stato alla commit B". diciamo che ho commesso solo alcune delle mie modifiche, altri file sono destinati a future commit. quanto sto ripristinando? solo i file impegnati? o reimpostare l'intero set di lavoro?
    1. dal momento che così tante persone sono di supporto alla risposta, offro questo feedback: scrivere un quickly leggibile e facilmente eseguito insieme di istruzioni che posso eseguire per risolvere il mio problema. l'altra risposta l'ha; questa non lo fa.
    1. attenzione! attenzione! questo potrebbe non fare quello che ti aspetti se la tua commit errata fosse una fusione (fast-forward)! se la tua testa è su una commit di merge (ex: merged branch feature in master), git reset --hard~1 punta il ramo master all'ultima commit all'interno del ramo feature. in questo caso l'ID di commit specifico dovrebbe essere usato al posto del comando relativo.
    1. dopo aver riflettuto ulteriormente questo comportamento è stato il risultato della fusione del ramo master nel ramo funzionalità prima, testing e poi (fast-forward) fusione del ramo funzionalità nel master.
    1. si consideri che il numero in HEAD~1 può essere sostituito a qualsiasi numero intero positivo, ad esempio HEAD~3. può sembrare ovvio, ma i principianti (come me) sono molto attenti quando eseguono i comandi git, quindi potrebbero non rischiare di rovinare qualcosa testando queste cose.
    1. qualcuno potrebbe commentare "cosa succede se hai già spinto la commit?". questa risposta è ancora valida, o lo rende ancora più difficile?
    1. ottimo suggerimento. appena usato, anche se penso che sia rilevante notare che qualsiasi tag associato alla commit cancellata continuerà ad esistere, anche se non apparirà in gitk. cancellarlo con "git tag -d XXXXX" dove XXXXX è il nome del tag.
    1. manca un punto cruciale: se la commit precedente era 'spinta' al telecomando, qualsiasi operazione 'Annulla', non importa quanto semplice, causerà enorme dolore e sofferenza al resto degli utenti che hanno questa commit nella loro copia locale, quando faranno 'git pull' in futuro.

      quindi, se la commit era già 'spinta', fai questo invece:

      git revert <bad-commit-sha1-id>
      git push origin :
      
    1. @FractalSpace, non causerà "enorme dolore e sofferenza." ho fatto qualche forza push usando Git con un team. basta la comunicazione.
    1. @Kyralessa Nel mio posto di lavoro, rovinare il flusso di lavoro di tutta la squadra e poi dire loro come risolvere sh * t non è chiamato 'comunicazione'. la riscrittura della cronologia di Git è un'operazione distruttiva che si traduce in una scomposizione di parti del repo. insistere sul suo uso, mentre sono disponibili alternative chiare e sicure è semplicemente irresponsabile.
    1. @Kyralessa, Ho una domanda sulla tua risposta. tu dici che "git reset --soft" "non solo lascia i tuoi file da solo, ma lascia anche il tuo indice da solo. quando esegui git status, vedrai che gli stessi file sono nell'indice di prima. infatti, subito dopo questo comando, potresti fare git commit e rifaresti la stessa commit che avevi. " ma se "git reset --soft" non cambia l'indice, "git commit" non farebbe nulla. vuoi dire "git commit -a" (assumendo che non ci siano state modifiche nella directory di lavoro prima) o mi manca qualcosa (più simile)?
    1. @espertus, forse un modo per guardare è che ci sono tre cose che lavorano qui: i file, il vostro indice, e la vostra storia (cioè, il puntatore ramo). diciamo che sei al commit C (come sopra). i tuoi file, indice e puntatore ramo corrispondono. se usi git reset --soft HEAD ~ 1, il tuo puntatore del ramo torna a B, ma i tuoi file e indice rimangono nelle loro versioni in C. Se usi git reset --mixed HEAD ~ 1, il puntatore del ramo e l'indice tornano a B, ma i tuoi file rimangono nel loro stato in C. Allora i tuoi file mostrano modifiche ma il tuo indice non lo fa. Git resetta --hard HEAD ~ 1 sposta tutti e tre indietro.
    1. @Kyralessa, Grazie mille per la risposta rapida. quando mi sono svegliato, ho capito quello che mi mancava. ho assunto che l'indice è vuoto quando tutto è impegnato, ma ora capisco che è una copia.
    1. reset demistificato da Scott Chacon (GitHub CIO, Pro autore di Git) spiega e illustra il comando git reset e come spostare l'HEAD (--soft), aggiornare l'indice (--mixed, default) e aggiornare la directory di lavoro (--hard), dal basso verso l'alto.

      ho sempre usato risposta di arrogante come un foglio imbroglio, ma post del blog di Scott finalmente fatto clic e bastone!

    1. adottato le illustrazioni con alcuni miglioramenti. http://ru.stackoverflow.com/a/431521/181472
    1. ho voluto nuke un commit e mai più vederlo. ho usato il vostro esempio con --hard, ma quello che non ho capito è che tutti i miei cambiamenti non in scena nel mio albero di lavoro anche ottenere nuked! stavo per commettere questi file come parte di un commit successivo. ora sembra impossibile ottenere questi file indietro - Ho anche provato la soluzione che hai postato su reflog, ma questo non ripristinare i cambiamenti in precedenza non in scena.
    1. link su index aggiunto nel contesto, più commento sul backup di tutto il progetto come precauzione @Kidburla.
    1. @Kyralessa Vedo. ma è meglio parlare di "SHAS" che di "hashes"? la pagina man di git menziona solo hash e "hash SHA-1". la domanda è piuttosto: che cosa migliora la risposta più?
    1. qual è la differenza tra git reset --hard HEAD~1 e git reset --hard, se quello che ti serve è semplicemente sbarazzarsi di tutti i cambiamenti che hai fatto dopo la tua ultima commit? uso sempre git reset --hard e mi riporta alla mia ultima commit. per un'analogia, ritengo che è genere di chiusura dell'applicazione senza i cambiamenti di risparmio in modo che tutto che fosse sulla memoria della RAM sia perso, ma che cosa avete avuto sulla memoria della ROM è mantenuto, usando la vostra ultima commit come memoria della ROM in questa analogia ed i vostri cambiamenti che non sono stati commessi come roba nella memoria della RAM che non è stata salvata ancora.
    1. citando @poorva dai commenti in altri post qui sotto: 'per annullare le ultime modifiche puoi usare git reset --hard, ma se devi rimuovere duramente le ultime commit "n" specifichi un SHA'.
    1. si può riorganizzare il post per rendere il --soft il primo suggerimento mostrato? uno dei nostri ingegneri non ha letto l'articolo completo e ha usato --hard su una directory di lavoro condivisa, che per fortuna ci è costato solo un giorno di lavoro. - Grazie.

      P.S. P.S. P.S. P.S. P.S.: sì, sappiamo che usare le directory di lavoro condivise è una cattiva pratica, ma questo non memorizza codice, ma configurazione fantoccio.

    1. sto provando git reset --soft HEAD ~ 1 e continuo a ottenere quanto segue, perché? : Fatal: argomento ambiguo 'HEAD ~ 1': revisione sconosciuta o percorso non nell'albero di lavoro. USA '--' per separare i percorsi dalle revisioni, come questo: 'Git [...] -- [...]'
    1. @gangelo, quanti commit hai nel tuo repository? più di uno? è difficile resettare prima di ogni commit, quindi di solito inizio un repo con un commit "fittizio" (come un file .gitignore vuoto) per aggirare questo tipo di problema.
    1. @Kyralessa Ho solo 1 commit, ma non è spinto perché, stranamente, devo estrarre il mio file .gitignore dal mio repository. credo di poter commettere e applicare il .gitignore dopo il fatto, ma non ricordo come farlo e ricordare che è una seccatura. voglio solo annullare la commit in un punto in cui se faccio 'git status' vedrò tutti i miei file tracciati, e pronto a commit come se non fosse mai successo.
    1. @gangelo, dare un'occhiata qui per alcune idee su come ripristinare la prima commit: https://stackoverflow.com/questions/6632191/how-to-revert-initial-git-commit
    1. quell'ultima riga che "Commit non viene realmente distrutto in Git per circa 90 giorni" è per me una nuova notizia così impressionante.
      • Git resettare --hard HEAD ~ 1, tornerà ad una commit ed eliminerà tutti i file che git conosce, ma non i file non tracciati, dato che git non ne ha idea.

      • Git reimposta HEAD ~ 1, manterrà tutte le modifiche della commit corrente, ma le renderà non tracciate

      • Git resettare --soft HEAD ~ 1, manterrà i tuoi file commited in stage e i file non tracciati ancora non tracciati

    1. questo è grande. super utile se la tua ultima commit è stata una "wip" ma vuoi ri-organizzarti in commit più significative, nel qual caso usa. git reset --soft HEAD~1
    1. come indicato da @Kidburla, quando si utilizza git reset --hard HEAD~1 elimina le modifiche attuali che non sono state commited. e 'un po' confuso, perché sembra che (F) rappresenta questi cambiamenti e si mantiene (F) dopo reset --hard. ci dovrebbe essere un avviso o qualcosa per impedire alle persone di cancellare le loro modifiche. oppure potresti anche rappresentare i "cambiamenti non commessi" negli esempi.
  7. volevo annullare gli ultimi 5 commit nel nostro repository condiviso. ho guardato l'id di revisione che volevo rollback a. poi ho digitato il seguente.

    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>
    
    1. riscrivere la storia su un repository condiviso è generalmente una pessima idea. presumo che tu sappia quello che stai facendo, spero solo che i futuri lettori fanno troppo.
    1. sì rollback è pericoloso. assicurarsi che la copia di lavoro è nello stato desiderato prima di spingere. quando si preme poi le commit indesiderati viene eliminato in modo permanente.
    1. "proprio come nel mondo reale, se volete riscrivere la storia, avete bisogno di una cospirazione: tutti devono essere" dentro "sulla cospirazione (almeno tutti quelli che conoscono la storia, cioè tutti quelli che hanno tirato dal ramo). " fonte: http://stackoverflow.com/a/2046748/334451
  8. utilizzare git revert <commit-id>

    per ottenere l'ID commit, basta usare git log

    1. se ti sei impegnato nel ramo sbagliato: una volta ritornato, passa al ramo corretto e seleziona la commit.
    1. che cosa significa, ciliegio scegliere il commit? nel mio caso, ero sul ramo sbagliato quando ho modificato un file. l'ho commessa poi capito che ero nel ramo sbagliato. usando "git reset --soft HEAD ~ 1" mi sono riportato subito prima della commit, ma ora se faccio il checkout del ramo corretto, come posso annullare le modifiche al file nel ramo sbagliato, ma invece le faccio (nello stesso file chiamato) nel ramo corretto?
    1. ho appena utilizzato git revert commit-id funzionato come un fascino. naturalmente allora sarà necessario spingere le modifiche.
    1. credo che sarebbe git cherry-pick <<erroneous-commit-sha>> @astronomerdave. Da, Mr. Quasi-2-anni-Late-to-the-Party.
    1. @Kris: Invece di usare cherry-pick rebase. perché è avanzato cherry-picking
  9. preferisco usare git rebase -i per questo lavoro, perché si apre una bella lista dove posso scegliere i commit da eliminare. potrebbe non essere così diretta come alcune altre risposte qui, ma ci si sente giusto.

    scegli quante commit vuoi elencare, poi invocane così (per elencare le ultime tre)

    git rebase -i HEAD~3
    

    elenco dei campioni

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

    poi Git rimuoverà i commit per qualsiasi linea rimossa.

  10. se hai intenzione di annullare una commit locale interamente, qualunque sia il cambiamento che hai fatto sulla commit, e se non ti preoccupi nulla, fai il seguente comando.

    git reset --hard HEAD^1
    

    (questo comando ignorerà l'intero commit e le modifiche andranno perse completamente dal tuo albero di lavoro locale). se vuoi annullare la tua commit, ma vuoi che i tuoi cambiamenti nell'area di staging (prima della commit come dopo git add) poi fai il seguente comando.

    git reset --soft HEAD^1
    

    ora i tuoi file impegnati entrano nell'area di staging. supponiamo che se si desidera eseguire l'upstage dei file, perché è necessario modificare alcuni contenuti sbagliati, quindi fare il seguente comando

    git reset HEAD
    

    ora i file impegnati a venire dall'area in scena nella zona non in scena. ora i file sono pronti per la modifica, in modo che qualsiasi cosa si cambia, si desidera andare modificare e aggiunto e fare una nuova / nuova commit.

    più di più

    1. @SMR, Nel tuo esempio, tutti puntano solo nell'HEAD corrente. testa ^ = TESTA ^ 1. così come HEAD ^ 1 = HEAD ~ 1. quando si utilizza HEAD ~ 2, c'è una differenza tra i simboli ~ e ^. se si utilizza ~ 2 significa "il primo genitore del primo genitore" o "il nonno".
  11. come risolvere la commit locale precedente

    utilizzare git-gui (o simili) per eseguire un git commit --amend. dalla GUI puoi aggiungere o rimuovere singoli file dalla commit. puoi anche modificare il messaggio di commit.

    come annullare la commit locale precedente

    basta ripristinare il ramo nella posizione precedente (ad esempio, usando gitk o git rebase). quindi riapplicare le modifiche da una copia salvata. dopo la raccolta dei rifiuti nel repository locale, sarà come la commit indesiderata non è mai successo. per fare tutto questo in un solo comando, usare git reset HEAD~1.

    parola di avvertimento: uso negligente di git reset è un buon modo per ottenere la vostra copia di lavoro in uno stato di confusione. raccomando ai novizi di Git di evitarlo se possono.

    come annullare un commit pubblico

    eseguire una selezione inversa (git-revert) per annullare le modifiche.

    se non hai ancora tirato altri cambiamenti sul tuo ramo, puoi semplicemente fare...

    git revert --no-edit HEAD
    

    poi invia il tuo ramo aggiornato al repository condiviso.

    la cronologia delle commit mostrerà entrambe le commit, separatamente.


    avanzato: correzione del ramo privato nel repository pubblico

    questo può essere pericoloso -- assicuratevi di avere una copia locale del ramo per repeush.

    nota anche: non vuoi farlo se qualcun altro può lavorare sul ramo.

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

    pulire il ramo a livello locale poi remake...

    git push origin (branch_name)
    

    nel caso normale, probabilmente non hai bisogno di preoccuparti che la tua storia di commit privata sia intatta. basta premere un commit successivo (vedere 'Come annullare un commit pubblico' sopra), e poi, fare un squash-merge per nascondere la storia.

    1. gitk --all $(git reflog | cut -c1-7)& può essere utile per trovare la revisione precedente se vuoi annullare una commit '--modify'.
    1. va notato che se stai tentando di rimuovere le informazioni segrete prima di passare a un repository condiviso, fare un revert non ti aiuterà, perché le informazioni saranno ancora nella storia della commit precedente. se si vuole garantire il cambiamento non è mai visibile ad altri è necessario utilizzare git reset
    1. penso che 'privato' / 'pubblico' sarebbe più correttamente 'locale' / 'remoto'.
    1. correggere un ramo privato nel repository remoto può anche essere fatto semplicemente git push origin (branch_name) --force
  12. un altro modo:

    verifica il ramo che vuoi ripristinare, quindi reimposta la tua copia di lavoro locale alla commit che vuoi essere l'ultima sul server remoto (tutto dopo sarà bye-bye). per fare questo, in SourceTree ho cliccato con il tasto destro sul e selezionato "Reset branchname to this commit".

    poi naviga nella directory locale del tuo repository ed esegui questo comando:

    git -c diff.mnemonicprefix=false -c core.quotepath=false push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME
    

    questo cancellerà tutti i commit dopo quello corrente nel tuo repository locale ma solo per quel ramo.

  13. digitare git log e trovare l'ultimo codice hash commit e quindi inserire:

    git reset <the previous co>
    
  14. se vuoi annullarla definitivamente e hai clonato un repository

    l'id commit può essere visto da

    git log 
    

    poi si può fare -

    git reset --hard <commit_id>
    
    git push origin <branch_name> -f
    
    1. cosa succede se non usi "" e usi semplicemente "git reset --hard"? in genere voglio solo eliminare i miei ultimi aggiornamenti che non ho ancora commesso e tornare all'ultima commit che ho fatto, e uso sempre "git reset --hard".
    1. @JaimeMontoya Per annullare le ultime modifiche è possibile utilizzare git reset --hard, ma se si deve rimuovere con impegno l'ultima "n" commit si specifica un SHA
  15. su SourceTree (GUI per GitHub), puoi cliccare col tasto destro sul commit e fare una 'Reverse Commit'. questo dovrebbe annullare le modifiche.

    sul terminal:

    in alternativa puoi usare:

    git revert
    

    o: o:

    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.
    
  16. nel mio caso ho accidentalmente commesso alcuni file che non volevo. così ho fatto quanto segue e ha funzionato:

    git reset --soft HEAD^
    git rm --cached [files you do not need]
    git add [files you need]
    git commit -c ORIG_HEAD
    

    verificare i risultati con gitk o git log --stat

  17. USA SourceTree (strumento grafico per Git) per vedere le tue commit e il tuo albero. è possibile reimpostare manualmente direttamente facendo clic destro.

  18. "resettare l'albero di lavoro all'ultima commit"

    git reset --hard HEAD^ 
    

    "pulire file sconosciuti dall'albero di lavoro"

    git clean    
    

    vedere - Riferimento rapido di Git

    nota: questo comando cancella la tua commit precedente, quindi usa cautela! git reset --hard è più sicuro -

  19. prima esecuzione:

    git reflog
    

    ti mostrerà tutte le possibili azioni che hai eseguito sul tuo repository, per esempio, commit, merge, pull, ecc.

    poi fare:

    git reset --hard ActionIdFromRefLog
    
  20. utilizzare reflog per trovare uno stato corretto

    git reflog
    

    reflog beforereflog prima del ritorno

    selezionare il reflog corretto (f3cb6e2 nel mio caso) e digitare

    git reset --hard f3cb6e2
    

    reset effectdopo di che il repo HEAD sarà reimpostato a quello HEADID LOG DOPO RESET

    infine il reflog assomiglia alla foto qui sotto

    reflog afterreflog FINAL

  21. per una commit locale

    git reset --soft HEAD~1
    

    o se non ricordi esattamente in quale commit è, potresti usare

    git rm --cached <file>
    

    per un commit spinto

    il modo corretto di rimuovere i file dalla cronologia del repository sta usando git filter-branch. che è, che è,

    git filter-branch --index-filter 'git rm --cached <file>' HEAD
    

    ma vi consiglio di usare questo comando con cura. legga più alla pagina manuale di git-filter-branch (1).

  22. un solo comando:

    git reset --soft 'HEAD^' 
    

    funziona benissimo per annullare l'ultimo commit locale!

    1. avevo bisogno di scrivere git reset --soft "HEAD ^" con virgolette doppie, perché lo scrivo dal prompt dei comandi di Windows.
  23. come annullare l'ultimo commit di Git?

    per ripristinare tutto nel modo in cui era prima dell'ultima commit, dobbiamo reimpostare la commit prima di HEAD.

    1. se non vuoi mantenere le modifiche apportate:

      git reset --hard HEAD^
      
    2. se vuoi mantenere le tue modifiche:

      git reset --soft HEAD^
      

    ora controlla il tuo git log. mostrerà che il nostro ultimo commit è stato rimosso.

  24. per ripristinare la revisione precedente, eliminando definitivamente tutte le modifiche non committate:

    git reset --hard HEAD~1
    
    1. forse si potrebbe ad una nota / avviso che il suo comando butterà via la commit e le modifiche nella directory di lavoro senza chiedere ulteriori.
    1. se vi capita di farlo per caso, non tutto è perduto, però. vedere http://stackoverflow.com/questions/10099258/how-can-i-recover-a-lost-commit-in-git, http://stackoverflow.com/questions/15479501/git-commit-lost-after-reset-hard-not-found-by-fsck-not-in-reflog e http://stackoverflow.com/questions/7374069/undo-git-reset-hard/7376959.
    1. @Zaz: Hai ragione; forse avrei dovuto chiarire che. solo i file / modifiche che sono stati aggiunti all'indice (/ staged) o sono stati commessi possono essere recuperati. non impegnati, cambiamenti non in scena sono, come hai detto, completamente gettato via da git reset --hard.
    1. come nota: ogni volta che un file viene messo in scena, git memorizza il suo contenuto nel suo database di oggetti. i contenuti memorizzati vengono rimossi solo quando viene eseguita la raccolta dei rifiuti. e 'quindi possibile recuperare l'ultima versione in scena di un file che non è stato attualmente messo in scena quando git reset --hard è stato eseguito (vedere i messaggi linkati sopra per maggiori informazioni).
    1. questo è un consiglio terribile. questo non solo ripristina il telecomando, questo elimina i file effettivi dalla cartella che si sta facendo. questo non era affatto chiaro per me, e ho pensato che stavi dicendo che stavi semplicemente ripristinando il git head, non ripristinando i tuoi file attuali su quello che c'è nel repository. se i miei notebook di ieri non erano nella mia RAM avrei perso tutto quello che ho fatto ieri.
  25. se hai commesso spazzatura ma non spinto,

    git reset --soft HEAD~1
    

    HEAD~1 is a shorthand for the commit before head. Alternatively you can refer to the SHA-1 of the hash if you want to reset to. --soft option will delete the commit but it will leave all your changed files "Changes to be committed", as git status would put it.

    If you want to get rid of any changes to tracked files in the working tree since the commit before head use "--hard" instead.

    o o o o o

    If you already pushed and someone pulled which is usually my case, you can't use git reset. You can however do a git revert,

    git revert HEAD
    

    This will create a new commit that reverses everything introduced by the accidental commit.

    1. sono nel secondo caso, ma quando faccio "git revert HEAD" dice "errore: commit [ID] è un merge ma non è stata data alcuna opzione -m. Fatal: revert failed ". qualche suggerimento?
    1. probabilmente vale la pena menzionare che invece di HEAD~1 puoi usare l'hash reale come mostrato da git log --stat o da git reflog - utile quando devi 'annullare' più di una commit.
  26. ci sono due scenari principali

    non hai ancora spinto la commit

    se il problema era file extra che si commited (e non si desidera quelli sul repository), è possibile rimuovere utilizzando git rm e poi commiting con --amend

    git rm <pathToFile>
    

    è anche possibile rimuovere intere directory con -r, o anche combinare con altri comandi Bash

    git rm -r <pathToDirectory>
    git rm $(find -name '*.class')
    

    dopo aver rimosso i file, puoi fare commit con l'opzione --modify

    git commit --amend -C HEAD # the -C option is to use the same commit message
    

    questo riscrive la commit locale recente rimuovendo i file extra, quindi questi file non saranno mai inviati in push e saranno rimossi dal repository locale .git da GC.

    hai già spinto il commit

    è possibile applicare la stessa soluzione dell'altro scenario e poi fare git push con l'opzione -f, ma non è raccomandato in quanto sovrascrive la cronologia remota con un cambiamento divergente (può rovinare il repository).

    invece, devi fare la commit senza --amend (ricorda questo riguardo a -amend ': questa opzione riscrive la cronologia dell'ultimo commit).

  27. di solito, vuoi annullare una commit perché hai fatto un errore e vuoi correggerlo - essenzialmente cosa ha fatto il OP quando ha fatto la domanda. così davvero, in realtà si vuole rifare un commit.

    la maggior parte delle risposte qui si concentrano sulla riga di comando. mentre la riga di comando è il modo migliore per usare Git quando sei a tuo agio con lui, probabilmente è un po 'alieno da quelli provenienti da altri sistemi di controllo di versione a Git.

    ecco come farlo usando una GUI. se hai Git installato, hai già tutto quello che ti serve per seguire queste istruzioni.

    nota: presumerò che hai capito che la commit era sbagliata prima di averla spinta. se non sai cosa significa spingere, allora probabilmente non hai spinto. quindi continuate con le istruzioni. se hai spinto la commit difettosa, il modo meno rischioso è solo seguire la commit difettosa con un nuovo commit che corregge le cose, il modo in cui lo faresti in un sistema di controllo della versione che non ti permette di riscrivere la storia.

    detto questo, ecco come correggere il tuo errore più recente usando una GUI:

    1. passare al repository dalla riga di comando e avviare la GUI con git gui
    2. scegli "Amend last commit". vedrai il tuo ultimo messaggio di commit, i file che hai messo in scena e i file che non hai fatto.
    3. ora cambiare le cose a come si vuole loro di guardare e fare clic su Commit.
  28. basta annullare l'ultima commit:

    git reset --soft HEAD~
    

    oppure annullare l'ora prima dell'ultima commit:

    git reset --soft HEAD~2
    

    o annulla qualsiasi commit precedente:

    git reset --soft <commitID>
    

    (puoi ottenere il commit usando git reflog)

    quando si annulla una commit precedente, ricordarsi di pulire il posto di lavoro con

    git clean
    

    maggiori dettagli si possono trovare nella documentazione: git-reset

  29. attenzione: si dovrebbe fare questo solo se non avete ancora spinto la commit a un telecomando, altrimenti si rovinare la storia di altri che hanno già tirato la commit dal remoto!
  30. è necessario fare il facile e veloce

        git commit --amend
    

    se si tratta di un ramo privato o

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

    se è un ramo condiviso o pubblico.

  31. nel mio caso ho commesso e spinto al ramo sbagliato, così quello che volevo era avere tutti i miei cambiamenti indietro in modo da poter metterli a un nuovo ramo corretto, così ho fatto questo:

    sullo stesso ramo che hai committato e spinto, se scrivi "git status" non vedrai nulla di nuovo perché hai fatto commit e push, scrivi:

    git reset --soft HEAD~1

    questo otterrà tutte le modifiche (file) indietro nell'area di stage, ora per farli tornare nella directory di lavoro (unstage) è sufficiente digitare:

    git reset FILE
    

    dove "File" è il file che si desidera commit di nuovo. ora, questo FILE dovrebbe essere nella directory di lavoro (unstaged) con tutti i cambiamenti che avete fatto. ora puoi cambiare il ramo che vuoi e fare i cambiamenti in quel ramo. spero che questo aiuti altre persone che hanno fatto lo stesso errore che ho fatto. naturalmente, il ramo iniziale che hai commesso è ancora lì con tutti i cambiamenti, ma nel mio caso che era ok, se non è per voi si può cercare il modo per ripristinare quel commit in quel ramo.

  32. rimuovere una commit sbagliata che è già stata spinta a Github

    git push origin +(previous good commit id):(branch name)
    

    si prega di specificare l'ultimo commit valido che si desidera ripristinare in Github.

    per esempio. se l'ultimo commit id è sbagliato, specifica l'id commit precedente nel comando git sopra con il nome del branch.

    puoi ottenere l'id commit precedente usando git log

  33. puoi sempre fare un git checkout <SHA code> della versione precedente e poi effettuare nuovamente il commit con il nuovo codice.

  34. un ciclo tipico di Git

    parlando dei comandi relativi a Git nelle risposte precedenti, vorrei condividere i miei tipici cicli Git con tutti i lettori che potrebbero essere utili. ecco come lavoro con Git,

    1. clonare la prima volta dal server remoto

      git clone $project

    2. tirare da remoto (quando non ho un commit locale in attesa di push)

      git pull

    3. aggiungere un nuovo file1 locale in $to _ be _ committed _ list (immagina che $to _ be _ committed _ list significhi staged area)

      git add $file1

    4. rimuovendo erroneamente aggiunto file2 da $a _ be _ committed _ list (supponiamo che file2 sia aggiunto come passo 3, che non volevo)

      git reset $file2

    5. commit di file1 che è in $to _ be _ committed _ list

      git commit -m "commit message description"

    6. sincronizzazione delle commit locali con il repository remoto prima di fare push

      git pull --rebase

    7. risolvere quando si verifica un conflitto prerequisito configurare mergetool

      git mergetool #resolve merging here, also can manually merge

    8. aggiungere file risolti in conflitto, diciamo file1:

      git add $file1

    9. continuando il mio precedente comando rebase

      git rebase --continue

    10. spingendo pronto e già sincronizzato ultima commit locale

      git push origin head:refs/for/$branch # branch = master, dev, etc.

    1. cosa succede se sto lavorando su una diramazione, quindi fondamentalmente ho 2 telecomandi effettivi repo es incubatore-mxnet ed il mio repo forked ChaiBapchya / incubatore-mxnet

      così in un tal caso, come posso risolvere i conflitti di fusione da locale al mio ramo biforcato di repo

  35. per annullare la commit locale si usa git reset <commit>. anche questo tutorial è molto utile per mostrare come funziona.

    in alternativa, puoi usare git revert <commit>: il revering dovrebbe essere usato quando vuoi aggiungere un altro commit che riavvia i cambiamenti (ma li mantiene nella cronologia del progetto).

    1. fare molta attenzione quando si invertono le commit della fusione. potresti perdere le tue commit. leggi cosa dice Linus su questo: https://www.kernel.org/pub/software/scm/git/docs/howto/revert-a-faulty-merge.html
  36. ci sono molti modi per farlo:

    comando Git per annullare l'ultima commit / commit precedenti:

    attenzione: non usare --difficile se non sai cosa stai facendo. --hard è troppo pericoloso, e potrebbe eliminare i file.

    il comando di base per ripristinare il commit in Git è:

    $ git reset --hard <COMMIT -ID>
    

    o o o o o

    $ git reset --hard HEAD~<n>
    

    COMIT-ID: ID per il commit

    n: è il numero delle ultime commit che vuoi ripristinare

    puoi ottenere l'id commit come mostrato di seguito:

    $ **git log --oneline**
    
    d81d3f1 function to subtract two numbers
    
    be20eb8 function to add two numbers
    
    bedgfgg function to mulitply two numbers
    

    dove d81d3f1 e be20eb8 sono commit id.

    ora vediamo alcuni casi:

    supponiamo di voler ripristinare l'ultima commit 'd81d3f1'. ecco due opzioni:

    $ git reset --hard d81d3f1
    

    o o o o o

    $ git reset --hard HEAD~1
    

    supponiamo di voler ripristinare la commit 'be20eb8':

    $ git reset --hard be20eb8
    

    per informazioni più dettagliate è possibile fare riferimento e provare anche altri comandi per ripristinare la testa ad uno stato specificato:

    $ git reset --help
    
    1. git reset --hard HEAD~1 è troppo pericoloso! questo non solo annullerà l'ultima commit, ma restituirà repo completamente alla commit precedente. così si perde tutti i cambiamenti commessi nell'ultimo commit!
    1. è giusto, per annullare questo è possibile utilizzare git push -f <remote> HEAD@git push -f <remote> HEAD@{1}:<branch>:<branch>
    1. sfortunatamente, io uso --hard, e i miei file vengono cancellati! non ho controllato il commento prima perché è crollato. non usare --hard se non sai cosa stai facendo!
  37. annullare l'ultima commit:

    git reset --soft HEAD^ o git reset --soft HEAD~

    questo annullerà l'ultima commit.

    qui --soft significa reimpostare nella messa in scena.

    HEAD~ o HEAD^ significa passare alla commit prima di HEAD.


    sostituire l'ultima commit alla nuova commit:

    git commit --amend -m "message"
    

    sostituirà l'ultima commit con la nuova commit.

  38. ho ottenuto l'ID commit da bitbucket e poi ho fatto:

    git checkout commitID .
    

    esempio: esempio:

    git checkout 7991072 .
    

    e l'ha restituita a quella copia funzionante di quella commit.

    1. nota: controllare '5456cea9'.

      sei in stato HEAD staccato. puoi guardarti intorno, fare delle modifiche sperimentali e committarle, e puoi scartare qualsiasi commit che fai in questo stato senza impattare sui branch eseguendo un altro checkout.

      se vuoi creare un nuovo ramo per mantenere le commit che crei, puoi farlo (ora o dopo) usando di nuovo -b con il comando checkout. esempio: esempio:

      checkout di Git - b

      la testa è ora a 5456cea... è necessario eliminare Esclusions.xslt dalla cartella Documentazione. - Cancella cosa devo fare dopo questo

  39. Visual STUDIO USERS (2015, ecc.)

    se Lei non può sincronizzarsi in Studio Visivo siccome Lei non è permesso spingere a un ramo come "sviluppo" allora tanto quanto io provai, in Studio Visivo né il NOR REVERT il RESET (duro o morbido) funzionerebbe.

    per la risposta con TONI DI VOTE:

    utilizzare questo al prompt dei comandi di root del progetto per nuke tutto ciò che cercherà di ottenere spinto:

    git reset --hard HEAD~1
    

    backup o zip i file solo nel caso in cui non si desidera perdere qualsiasi lavoro, ecc...

  40. basta usare git reset --hard <last good SHA> per ripristinare le modifiche e dare nuovo commit. è anche possibile utilizzare git checkout -- <bad filename>.

  41. è possibile utilizzare:

    git reset HEAD@
    git reset HEAD@{1}
    

    questo comando elimina il commit sbagliato senza un log di Git.

  42. cosa utilizzare, reset --soft o reset --hard?

    sto solo aggiungendo due centesimi per @Kyralessa's risposta:

    se non sei sicuro di cosa usare vai per --soft (ho usato questa convenzione per ricordarlo -- s oft for safe).

    perché? perché?

    se si sceglie --hard per errore si perde i cambiamenti come non era prima. se si sceglie --soft per errore è possibile ottenere gli stessi risultati di --hard applicando comandi aggiuntivi

    git reset HEAD file.html
    git checkout -- file.html
    

    esempio completo

    echo "some changes..." > file.html
    git add file.html
    git commit -m "wrong commit"
    
    # I need to reset
    git reset --hard HEAD~1 (cancel changes)
    # OR
    git reset --soft HEAD~1 # Back to staging
    git reset HEAD file.html # back to working directory
    git checkout -- file.html # cancel changes
    

    i crediti vanno a @Kyralessa.

    1. in realtà non si perdono le commit su un reset --hard in quanto saranno disponibili nel log ref per 30 giorni git reflog.
  43. se state lavorando con SourceTree, questo vi aiuterà.

    fare clic con il pulsante destro del mouse sulla commit, quindi selezionare "Reset (ramo corrente) / master a questa commit" e infine selezionare "Soft" reset.

    Enter image description here

  44. per eliminare (tutte le modifiche) l'ultima commit, le ultime 2 commit e le ultime n commit:

    git reset --hard HEAD~1
    git reset --hard HEAD~2
    ...
    git reset --hard HEAD~n
    

    e, per sbarazzarsi di qualsiasi cosa dopo una specifica commit:

    git reset --hard <commit sha>
    

    ad esempio,

    git reset --hard 0d12345
    

    PS:
    1- Be careful, because of "hard" option, it deletes the local changes in your repo as well and reverts to the previous mentioned commit. You should run this if you are sure you messed up in your last commit(s) and would like to go back in time.

    2- Usually 7 letters of "commit sha" is enough, but in bigger projects, you may need up to 12 letters to guarantee be unique. You also can mention the whole 40 letters sha.

    3- The above commands work in Github for Windows as well.

  45. enter image description here

    supponendo che si sta lavorando in Visual Studio, se si va a voi ramo storia e guardare tutte le vostre commit, basta selezionare l'evento prima della commit che si desidera annullare, fare clic destro su di esso, e selezionare Revert. facile come quello.

  46. pensiamo di avere un file code.txt. facciamo alcuni cambiamenti su di esso e commit. possiamo annullare questa commit in tre modi, ma prima dovresti sapere qual è il file messo in scena... Un file messo in scena è un file pronto per la commit e se esegui git status questo file verrà mostrato con il colore verde e se questo non è messo in scena per la commit sarà mostrato con il colore rosso:

    enter image description here

    significa che se si commette il cambiamento, le modifiche su questo file non viene salvato. puoi aggiungere questo file nella tua fase con git add code.txt e poi effettuare il commit del tuo cambiamento:

    enter image description here

    annullare l'ultima commit:

    1. ora, se vogliamo semplicemente annullare commit senza altri cambiamenti, possiamo usare

      git reset --soft HEAD^

      enter image description here

    2. se vogliamo annullare commit e i suoi cambiamenti (QUESTO E 'DANGEROSO, perché il tuo cambiamento sarà perso), possiamo usare

      git reset --hard HEAD^

      enter image description here

    3. e se vogliamo annullare commit e rimuovere le modifiche dalla fase, possiamo usare

      git reset --mixed HEAD^ o in forma breve

      enter image description here

  47. ho trovato questo sito che descrive come annullare le cose che hai commesso nel repository.

    alcuni comandi:

    git commit --amend        # Change last commit
    git reset HEAD~1 --soft   # Undo last commit
    
  48. hai diverse opzioni per annullare l'ultima commit. ecco alcune delle vostre opzioni riassumere in una sola risposta con frammenti di codice

    prima di tutto devi capire quali sono i commit "sbagliati" che vuoi scartare. useremo git reflog per trovarlo.


    git reflog

    è sempre possibile utilizzare reflog pure.
    git reflog visualizzerà qualsiasi cambiamento che ha aggiornato il HEAD e controllando la voce reflog desiderata imposterà il HEAD di nuovo a questa commit.

    ogni volta che l'HEAD viene modificato ci sarà una nuova voce nel reflog.
    il reflog è simile al comando storia di Unix ed è mantenuto localmente sulla vostra macchina.

    git reflog
    git checkout HEAD@{...}
    # or
    git checkout <sha-1>
    

    usando il checkout puoi tornare alla commit desiderata e puoi creare un branch o qualsiasi altra opzione che git checkout ti permetterà di fare.

    enter image description here


    git reset HEAD --hard <commit_id>

    "sposta" la tua testa indietro alla commit desiderata.
    Git reset controllerà il contenuto del commit desiderato nella tua area di stage e / o nella tua directory di lavoro in base al valore --hard/--soft/--mixed che scegli. --hard aggiornerà sia l'area di fase che la directory di lavoro con il contenuto dato e "staccare" qualsiasi altra commit oltre questo punto sul ramo locale.

    se questi commit non fanno parte di nessun altro ramo diventeranno "penzolare".
    "Dangle" contenuto significa che c'è un contenuto non raggiungibile nel repository locale che non fa parte di qualsiasi altro ramo e può essere rimosso o sarà rimosso dal gc.

    # 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.
    

    questo schema illustra quale comando fa cosa.
    come si può vedere lì reset && checkout modificare il HEAD.

    enter image description here

  49. se si desidera eliminare i file errati si dovrebbe fare

    git reset --soft <your_last_good_commit_hash_here> Qui, se fai git status, vedrai i file nell'area di staging. puoi selezionare i file errati e rimuoverli dall'area di stage.

    come il seguente.

    git reset wrongFile1 wrongFile2 wrongFile3

    ora è possibile aggiungere solo i file che è necessario spingere,

    git add goodFile1 goodFile2

    li impegnamo

    git commit -v o git commit -am "Message"

    e spingere e spingere

    git push origin master

    tuttavia, se non ti importa dei file modificati, puoi reimpostare duramente il commit precedente e inviare tutto al server.

    da

    git reset --hard <your_last_good_commit_hash_here>
    

    git push origin master

    se hai già pubblicato i tuoi file errati sul server, puoi usare il flag --force per passare al server e modificare la cronologia.

    git push --force origin master

  50. riferimento: come annullare l'ultimo commit in Git?

    se hai installato le estensioni Git puoi facilmente annullare / ripristinare qualsiasi commit (da qui puoi scaricare le estensioni git).

    apri le estensioni Git, fai clic con il tasto destro sul commit che vuoi ripristinare e seleziona "Revert commit".

    Git Extensions screen shot

    verrà aperta una popup (vedere lo screenshot qui sotto)

    Revert commit popup

    selezionare "Crea automaticamente una commit" se si desidera eseguire direttamente le modifiche annullate o se si desidera eseguire manualmente le modifiche annullate, mantenere la casella non selezionata e fare clic sul pulsante "Ripristina questa commit".

  51. supponiamo di aver fatto una commit sbagliata localmente e di averla inviata a un repository remoto. è possibile annullare il pasticcio con questi due comandi:

    in primo luogo, dobbiamo correggere il nostro repository locale ritornando al commit che desideriamo:

    git reset --hard <previous good commit id where you want the local repository  to go>
    

    ora premiamo con forza questo buon commit sul repository remoto usando questo comando:

    git push --force-with-lease
    

    la versione 'with-lease' dell'opzione force impedirà la cancellazione accidentale di nuovi commit che non conosci (cioè venendo da un'altra fonte dal tuo ultimo tiro).

    1. questo ha funzionato per me il migliore, dal momento che avevo già spinto il cattivo commit fino a github
  52. trova l'ultimo codice hash commit vedendo il log da:

    git log
    

    poi poi poi poi

    git reset <the previous co>
    
  53. in IntelliJ IDEA puoi semplicemente aprire il log del repository Git premendo Alt + 9, fai clic con il tasto destro del mouse su qualche tag dall'elenco delle commit, e seleziona: "reimposta il ramo corrente su Qui...".

  54. basta reimpostarlo facendo il comando qui sotto usando git:

    git reset --soft HEAD~1
    

    explain :what { 3 } does , it 's basically { 4 } to any commit you 'd like to go back to , then if you combine it with { 5 } key , it will go back , but keep the changes in your file ( s ) , so you get back to the stage which the file was just added , { 6 } is the head of the branch and if you combine with { 7 } ( in this case you also use { 8 } ) , it will go back only one commit which what you want ...

    creo i passi nell'immagine qui sotto in più dettagli per voi, compresi tutti i passaggi che possono accadere in situazioni reali e commettere il codice:

    How to undo the last commits in Git?

  55. per completezza, darò l'unico metodo glaringly ovvio che è stato trascurato dalle risposte precedenti.

    poiché la commit non è stata spinta, il telecomando è rimasto invariato, così:

    1. elimina il repository locale.
    2. clonare il repository remoto.

    questo a volte è necessario se il tuo client Git è pronto. (ad esempio. non-fast-forward errori)

    non dimenticare di ri-commit delle modifiche salvate dall'ultima push.

  56. testa: testa:

    prima di resettare la commit dovremmo sapere su HEAD... HEAD non è altro che il tuo stato attuale nella tua directory di lavoro. è rappresentato da un numero di commit.

    commit di Git:

    ogni cambiamento assegnato sotto un commit che è rappresentato da un tag unico. le commit non possono essere cancellate. quindi, se si desidera il tuo ultimo commit, si può semplicemente immergersi in esso utilizzando git reset.

    puoi immergerti nell'ultima commit usando due metodi:

    metodo 1: (se non conosci il numero di commit, ma vuoi passare al primo)

    git reset HEAD~1  # It will move your head to last commit
    

    metodo 2: (se conosci la commit semplicemente reimposta la tua commit conosciuta)

    git reset 0xab3 # Numero di commit

    nota: se vuoi conoscere una commit recente prova git log -p -1

    ecco la rappresentazione grafica:

    Enter image description here

  57. puoi annullare le tue commit di Git in due modi: prima puoi usare git revert, se vuoi mantenere la cronologia delle commit:

    git revert HEAD~3
    git revert <hashcode of commit>
    

    in secondo luogo è possibile utilizzare git reset, che cancellerebbe tutta la cronologia delle commit e portare la testa a commettere dove si desidera.

    git reset <hashcode of commit>
    git reset HEAD~3
    

    è inoltre possibile utilizzare la parola chiave --hard se uno qualsiasi di esso inizia a comportarsi in altro modo. ma, lo consiglio solo fino a quando è estremamente necessario.

  58. annullare l'ultima commit

    ci sono tonnellate di situazioni in cui si vuole veramente annullare l'ultima commit nel codice. ad es. per esempio perché si desidera ristrutturare ampiamente - o addirittura scartare del tutto!

    in questi casi, il comando "reset" è il tuo migliore amico:

    $ git reset --soft HEAD~1
    

    il comando precedente (reset) riavvolgerà il ramo HEAD corrente alla revisione specificata. nel nostro esempio precedente, vorremmo tornare a quello prima della revisione corrente - facendo annullare l'ultima commit.

    nota il flag --soft: questo assicura che le modifiche delle revisioni annullate siano mantenute. dopo aver eseguito il comando, troverete le modifiche come non committed modifiche locali nella copia di lavoro.

    se non si desidera mantenere questi cambiamenti, è sufficiente utilizzare il flag --hard. assicurati di farlo solo quando sei sicuro di non aver più bisogno di questi cambiamenti.

    $ git reset --hard HEAD~1
    

    Enter image description here

  59. ciò che @thSoft detto è corretto, spingendo le tue commit e poi git reset --bla foo richiede un git --force push [--all] [somewhere-else-than-origin]. si noti che si tratta di una "forzatura" che richiede che altre persone fanno un "forzato-aggiornamento". essi non dovrebbero usare git pull in quanto ciò implica una fusione, ma usare git fetch [--all] e poi git rebase origin/master (supponiamo che l'aggiornamento forzato sia venuto da origin). tutti [bla] sono parametri opzionali, ma a volte necessari, per esempio quando si fa un push su più di un solo repository remoto.
  60. il motivo per git fetch [--all] + git rebase origin/master è che questo corregge la vostra storia locale evitando una fusione rendendo la storia più facile per GIT da gestire.
  61. annullare l'ultima commit:

    git reset --soft HEAD^ or git reset --soft HEAD~
    

    questo annullerà l'ultima commit.

    qui --soft significa reimpostare nella messa in scena.

    HEAD~ or HEAD^ significa passare alla commit prima di HEAD.

    sostituire l'ultima commit alla nuova commit:

    git commit --amend -m "message"
    

    sostituirà l'ultima commit con la nuova commit.

  62. ecco il sito: Oh shit, git!.

    ecco molte ricette per annullare le cose in Git. alcuni di loro:

    Oh shit, I need to change the message on my last commit!

    git commit --amend
    # follow prompts to change the commit message
    

    Oh shit, I accidentally committed something to master that should have been on a brand new branch!

    # Create a new branch from the current state of master
    git branch some-new-branch-name
    # Remove the commit from the master branch
    git reset HEAD~ --hard
    git checkout some-new-branch-name
    # Your commit lives in this branch now :)
    
  63. puoi annullare le tue commit dal repository locale. si prega di seguire lo scenario qui sotto.

    nell'immagine qui sotto controllo il ramo 'test' (usando il comando Git git checkout -b test) come stato locale e check (usando il comando Git git status) del ramo locale che non c'è niente da fare.

    Enter image description here

    nell'immagine successiva puoi vedere qui che ho fatto alcune modifiche in Filter1.txt ed aggiunto quel file all'area di staging e poi ho fatto le mie modifiche con qualche messaggio (usando il comando Git git commit -m "Doing commit to test revert back").

    "-m è per il messaggio di commit"

    Enter image description here

    nella prossima immagine puoi vedere il tuo log delle commit come hai fatto (usando il comando Git git log).

    Enter image description here

    quindi nell'immagine qui sopra puoi vedere l'id commit con ogni commit e con il tuo messaggio di commit ora qualsiasi commit vuoi ripristinare o annullare la copia dell'id commit e premere il comando Git, git revert {"paste your commit id"}. esempio: esempio:

    git revert 9ca304ed12b991f8251496b4ea452857b34353e7
    

    Enter image description here

    ho rinviato indietro il mio ultimo commit. ora, se controlli lo stato di Git, puoi vedere il file modificato che è Filter1.txt e ancora fare commit.

    Enter image description here

  64. sai di cosa ha bisogno git? git undo, questo è tutto. poi la reputazione che git ha per gestire gli errori commessi da noi comuni mortali scompare. implementa premendo lo stato corrente su uno stack git prima di eseguire qualsiasi comando git. potrebbe influenzare le prestazioni, quindi sarebbe meglio aggiungere un flag di configurazione su se abilitarlo.
  65. prova questo, hard reset alla commit precedente dove questi file non sono stati aggiunti, quindi:

    git reset --hard <commit_hash>
    

    assicurarsi di avere un backup dei cambiamenti nel caso, in quanto si tratta di un hard reset, il che significa che saranno persi (a meno che non è stato bloccato in precedenza)

  66. git push --delete (branch_name) //this will be removing the public version of your branch
    
    git push origin (branch_name) //This will add the previous version back
    
  67. rifondare e far cadere commit sono i migliori quando si vuole mantenere la cronologia pulita utile quando si propongono patch a un ramo pubblico ecc.

    se devi far cadere il commit più alto allora il seguente uno-liner aiuta

    git rebase --onto HEAD~1 HEAD
    

    ma se vuoi eliminare 1 delle molte commit hai detto

    a - > b - > c - > d - > master

    e vuoi eliminare commit 'c'

    git rebase --onto b c
    

    questo farà di 'b' la nuova base di 'd' eliminando 'c'

  68. una bella spiegazione che ho incontrato: https://www.git-tower.com/learn/git/faq/undo-last-commit
  69. git revert commit
    

    questo genererà i cambiamenti opposti dalla commit che si desidera ripristinare, e poi solo commit che cambia. penso che questo sia il modo più semplice.

    https://git-scm.com/docs/git-revert

  70. quello che faccio ogni volta che ho bisogno di annullare una commit / commit sono:

    1. git reset HEAD~<n> / / il numero di ultime commit che devo annullare
    2. git status / / opzionale. tutti i file sono ora in rosso (non in stage).

    3. ora, posso aggiungere & amp; commit solo i file che ho bisogno:

      • git add <file names> & git commit -m "message" -m "details"
    4. opzionale: posso effettuare il rollback delle modifiche dei file rimanenti, se necessario, alle loro condizioni precedenti, con checkout:
      • git checkout <filename>
    5. se l'avessi già spinto ad origine remota, in precedenza:
      • git push origin <branch name> -f / / use -f per forzare il push.
  71. se vuoi annullare la prima commit nel tuo repo

    incontrerai questo problema:

    $ git reset HEAD~
    fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
    Use '--' to separate paths from revisions, like this:
    'git <command> [<revision>...] -- [<file>...]'
    

    l'errore si verifica perché se l'ultima commit è la commit iniziale (o nessun genitore) del repository, non c'è HEAD ~.

    soluzione soluzione soluzione soluzione

    se vuoi reimpostare l'unica commit sul ramo "master"

    $ git update-ref -d HEAD
    $ git rm --cached -r .
    
  72. come modificare una commit precedente

    in genere non voglio annullare un mucchio di commit, ma piuttosto modificare una commit precedente su come vorrei averla commessa in primo luogo.

    mi sono trovato a fissare una commit del passato abbastanza frequentemente che ho scritto uno script per esso.

    ecco il flusso di lavoro:

    1. git commit-edit <commit-hash>
      

      questo ti farà cadere alla commit che vuoi modificare.

      i cambiamenti della commit saranno messi in scena, pronti per essere messi in scena come si desidera che fosse la prima volta.

    2. fissa e metti in scena la commit come vorresti fosse stata in primo luogo.

      (si consiglia di utilizzare git stash save --keep-index per scoiattolo via tutti i file che non si sta impegnando)

    3. riesegui la commit con --amend, ad esempio:

      git commit --amend
      
    4. completa la ribase:

      git rebase --continue
      

    chiamare questo seguente git-commit-edit e metterlo nel $PATH:

    #!/bin/bash
    
    # Do an automatic git rebase --interactive, editing the specified commit
    # Revert the index and working tree to the point before the commit was staged
    # https://stackoverflow.com/a/52324605/5353461
    
    set -euo pipefail
    
    script_name=${0de_*/}
    
    warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
    die () { warn "$@"; exit 1; }
    
    [[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"
    
    # Default to editing the parent of the most recent commit
    # The most recent commit can be edited with `git commit --amend`
    commit=$(git rev-parse --short "${1:-HEAD~}")
    
    # Be able to show what commit we're editing to the user
    if git config --get alias.print-commit-1 &>/dev/null; then
      message=$(git print-commit-1 "$commit")
    else
      message=$(git log -1 --format='%h %s' "$commit")
    fi
    
    if [[ $OSTYPE =~ ^darwin ]]; then
      sed_inplace=(sed -Ei "")
    else
      sed_inplace=(sed -Ei)
    fi
    
    export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
    git rebase --quiet --interactive --autostash --autosquash "$commit"~
    git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
    git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed
    
    echo
    echo "Editing commit: $message" >&2
    echo
    
  73. @YiminRong Questo può essere fatto con la funzione di Git alias: https://git-scm.com/book/en/v2/Git-Basics-Git-Aliases
  74. ottenere l'ultimo commit ID usando questo comando (nel log uno in alto è l'ultimo):

    git log
    

    ottieni il commit id (GUID) ed esegui questo comando:

    git revert <commit_id>
    
  75. se vuoi semplicemente cestinare tutti i tuoi cambiamenti / commit locali e far apparire il tuo ramo locale come il ramo di origine che hai iniziato da...

    git reset --hard origin/branch-name

  76. il modo più semplice per annullare l'ultima commit è

    git reset HEAD^
    

    questo porterà lo stato del progetto prima di aver fatto la commit.

  77. la differenza tra git reset --mixed, --soft e --hard

    Prerequisite: When a modification to an existing file in your repository is made, this change is initially considered as unstaged. In order to commit the changes, it needs to be staged which means adding it to the index using git add. During a commit operation, the files that are staged gets added to an index.

    facciamo un esempio:

    - A - B - C (master)
    

    HEAD indica C e l'indice corrisponde a C.

    --morbido --morbido

    • quando eseguiamo git reset --soft B con l'intenzione di rimuovere la commit C e puntare il master / HEAD su B.
    • il master / HEAD punta ora a B, ma l'indice è ancora cambiato da C.
    • quando si esegue git status si potrebbero vedere i file indicizzati nel commit C come in stage.
    • eseguire un git commit a questo punto creerà un nuovo commit con le stesse modifiche di C

    --misto - misto

    • eseguire git reset --mixed B.
    • durante l'esecuzione, master / HEAD punta a B e l'indice viene modificato anche per corrispondere a B a causa della bandiera mista utilizzata.
    • se eseguiremo git commit a questo punto, non succederà nulla poiché l'indice corrisponde a HEAD.
    • abbiamo ancora le modifiche nella directory di lavoro, ma poiché non sono nell'indice, git status le mostra come non in stage.
    • per commetterli, si dovrebbe git add e poi commettere come al solito.

    --duro --duro

    • eseguire git reset --hard B
    • in esecuzione, master / HEAD punta a B e modifica la directory di lavoro
    • le modifiche aggiunte in C e tutte le modifiche non committate saranno rimosse.
    • i file nella copia di lavoro corrispondono alla commit B, questo porterà a perdere definitivamente tutti i cambiamenti che sono stati fatti nella commit C più i cambiamenti non commessi

    spero che questo confronto di bandiere che sono disponibili a utilizzare con git reset comando aiuterà qualcuno a usarli con saggezza. fare riferimento questi per ulteriori dettagli Link1 & amp; Link2

  78. sostituisci la tua versione locale incluse le tue modifiche con la versione server, queste due righe di codice forzeranno git a tirare e sovrascrivere locale. aprire la riga di comando e passare alla radice del progetto git. se usi VS, clicca su Team, Sincronizza e clicca su "Apri prompt dei comandi" (vedi immagine) qui sotto.

    Visual Studio

    una volta nel prompt Cmd andare avanti con le seguenti due istruzioni.

    git fetch --all
    

    poi lo fai tu

    git reset --hard origin/master
    

    questo sovrascriverà la versione locale esistente con quella sul server git

  79. git reset --soft HEAD~1
    

    reset riavvolgerà il ramo HEAD corrente alla revisione specificata. nota il flag --soft: questo assicura che le modifiche apportate alle revisioni annullate siano mantenute. dopo aver eseguito il comando, troverete le modifiche come non committed modifiche locali nella copia di lavoro.

    se non volete mantenere questi cambiamenti, usate semplicemente --hard flag. assicurati di farlo solo quando sei sicuro di non aver più bisogno di questi cambiamenti.

     git reset --hard HEAD~1
    

    Undoing Multiple Commits

    git reset --hard 0ad5a7a6
    

    tieni presente, tuttavia, che usando il comando reset deseleziona tutte le commit che arrivano dopo quella a cui sei ritornato:

  80. per gli utenti VsCode, basta digitare ctrl + shift + G e quindi fare clic su tre punti, vale a dire, più opzioni e quindi fare clic su undo Last Commit

More similar articles:

  • come posso effettuare il commit con il modulo clonato nel repo?
  • come annullare 'git add' prima di commit?
  • come annullare le commit in git
  • Git: come "consolidare" le commit locali
  • come posso commettere l'inversione dell'ultima commit?
  • come posso rimuovere un file da una commit di un ramo privato?
  • Git - Trova quali commit sono locali
  • come posso annullare git reset --hard HEAD ~ 1?
  • come posso annullare 'git update-ref -d refs/heads/master'?
  • posso annullare una commit in git rebase?
  • come posso annullare un checkin in un bitkeeper che non fa parte di un changeset?
  • come annullare in modo sicuro i commit già nel ramo master remoto e spostarli in un altro ramo?
  • come annullare permanentemente le commit recenti da git remote ma mantenerle nel mio locale?
  • come cancellare un commit in Git che è già inviato in un branch remoto e presente nei miei colleghi di lavoro locali?
  • come annullare gli effetti di un commit in Mercurial, mantenendo i commit successivi?
  • come posso annullare il tracciamento di un ramo remoto in git?
  • come annullare git commit localmente e su remoto senza perdere modifiche
  • come posso definire le variabili d'ambiente locali in studio android?
  • come posso annullare l'inizializzazione di una cartella che ho già inizializzato con Git Shell sul mio PC?
  • come elencare le differenze di commit locali in git
  • come faccio ad abbandonare le commit locali ma non le modifiche dei file?
  • annullare le commit che sono state spinte a repo remoto
  • come posso annullare le modifiche non salvate nel Codice VS?
  • Git: tornare all'ultimo commit?
  • posso cancellare file e cartelle specifici dalla copia locale di git repo. & commetti/premi il codice? tutto è fatto in NetBeans IDE e non da terminale
  • due rami locali tracciano due telecomandi, come può auto-PUSH solo uno?
  • annullare una vecchia commit
  • traccia le commit personalizzate sul modulo Read Only git
  • Git Snapshots, come funzionano?
  • annullare le modifiche di copia di un file in Git?