Come modificare i messaggi di commit esistenti e non compressi?


7664

Ho scritto la cosa sbagliata in un messaggio di commit.

Come posso cambiare il messaggio? Il commit non è stato ancora inviato.


868
Per chi è un po 'nuovo a git: il punto di Laurie di non aver ancora spinto è importante. Come il rebasing, questo sta cambiando la storia. Se qualcuno ha clonato / estratto dal repository tra la cronologia originale e riscritta, non sarà in grado di estrarre dopo la riscrittura (per quel ramo).
Pat Notz,

Risposte:


16132

Modifica del messaggio di commit più recente

git commit --amend

aprirà il tuo editor, consentendoti di modificare il messaggio di commit dell'ultimo commit. Inoltre, è possibile impostare il messaggio di commit direttamente nella riga di comando con:

git commit --amend -m "New commit message"

... tuttavia, ciò può rendere più ingombrante l'inserimento di messaggi di commit su più righe o piccole correzioni.

Assicurati di non aver messo in scena alcuna modifica della copia funzionante prima di farlo, altrimenti si impegneranno anche loro. (Le modifiche non messe in scena non verranno impegnate.)

Modifica del messaggio di un commit che hai già inviato al tuo ramo remoto

Se hai già inviato il commit al tuo ramo remoto, quindi - dopo aver modificato il commit in locale (come descritto sopra) - dovrai anche forzare il push con il commit con:

git push <remote> <branch> --force
# Or
git push <remote> <branch> -f

Avvertenza: la spinta forzata sovrascriverà il ramo remoto con lo stato di quello locale . Se ci sono commit sul ramo remoto che non avete nella vostra filiale locale, si dovrà perdere quei commit.

Attenzione: sii cauto sulla modifica degli impegni che hai già condiviso con altre persone. I commit di modifica essenzialmente li riscrivono per avere ID SHA diversi , il che rappresenta un problema se altre persone hanno copie del vecchio commit che hai riscritto. Chiunque abbia una copia del vecchio commit dovrà sincronizzare il proprio lavoro con il nuovo commit riscritto, che a volte può essere difficile, quindi assicurati di coordinarti con gli altri quando tenti di riscrivere la cronologia dei commit condivisi o semplicemente di evitare di riscrivere i commit condivisi del tutto.


Esegui un rebase interattivo

Un'altra opzione è quella di utilizzare rebase interattivo. Ciò consente di modificare qualsiasi messaggio che si desidera aggiornare anche se non è l'ultimo messaggio.

Per fare una zucca Git, segui questi passaggi:

// n is the number of commits up to the last commit you want to be able to edit
git rebase -i HEAD~n

Dopo aver annullato i commit, scegli e/rper modificare il messaggio:

Inserisci qui la descrizione dell'immagine

Nota importante sul rebase interattivo

Quando usi git rebase -i HEAD~nci possono essere più di n commit. Git "raccoglierà" tutti i commit negli ultimi n commit, e se ci fosse una fusione da qualche parte in quell'intervallo vedrai anche tutti i commit, quindi il risultato sarà n +.

Buona dritta:

Se devi farlo per più di un singolo ramo e potresti riscontrare conflitti durante la modifica del contenuto, configura git rereree lascia che Git risolva tali conflitti automaticamente per te.


Documentazione


257
Tuttavia git commit --amendnon è potente come git rebase -i.
Jeffrey Jose,

76
@jeffjose, Sicuramente non è necessario. Inoltre, è git commit --amendpossibile correggere il commit (a?) Master.
Strager

116
Se hai già spinto, basta forzare di nuovo la spinta:git push -f origin branchname
hughes

177
@hughes non è git push -fun po 'pericoloso se altre persone usano lo stesso repository?
Armand,

91
Se non vuoi riscrivere l'intero messaggio di commit, vai su git commit --amend -c HEAD. Questo aprirà l'editor precompilato con il tuo vecchio messaggio di commit, quindi puoi cambiarlo.
Sam,

2506
git commit --amend -m "your new message"

7
Ho fatto git commit --amend -m "Nuovo messaggio", ma spingendo su Github ho generato il "Unisci i cambiamenti remoti prima di premere di nuovo". Dopo pull, commit --amend, e premi di nuovo, il nuovo messaggio non appare. Invece ho "Merge branch 'master' di github.com:[myrepo]"
Dave Everitt,

8
@DaveEveritt molto probabilmente hai spinto a monte il tuo commit prima di provare a risolverlo.
Thorbjørn Ravn Andersen,

12
@Kyralessa non è vera. In bash puoi facilmente comporre messaggi di commit multilinea semplicemente non chiudendo il preventivo fino a quando non hai finito (premendo il ritorno alla fine di ogni riga tra virgolette).
Piani cottura

32
Non capisco come una risposta che assomigli molto all'idea principale di una risposta scritta due anni fa e anche la risposta accettata ottiene così tanti voti. Strano. (niente di sbagliato nella risposta però)
felice programmatore

7
@AmalMurali, beh. Il mio punto non era tanto sulla popolarità della domanda, né sull'utilità della risposta. Ma questa particolare risposta non è la risposta più antica, né offre ulteriori approfondimenti sulla risposta accettata. Sembra essere una copia di una sezione della risposta accettata. Questo era il mio punto. SALUTI!
buon programmatore,

2376

Se il commit che vuoi correggere non è il più recente:

  1. git rebase --interactive $parent_of_flawed_commit

    Se si desidera correggere diversi commit errati, passare il genitore del più vecchio di essi.

  2. Apparirà un editore, con un elenco di tutti i commit da quello che hai dato.

    1. Passa picka reword(o nelle versioni precedenti di Git, in edit) di fronte a qualsiasi commit che desideri correggere.
    2. Una volta salvato, Git riprodurrà i commit elencati.

  3. Per ogni commit che desideri riformulare , Git ti riporterà nel tuo editor. Per ogni commit che vuoi modificare , Git ti fa cadere nella shell. Se sei nella shell:

    1. Modifica il commit nel modo che preferisci.
    2. git commit --amend
    3. git rebase --continue

La maggior parte di questa sequenza ti verrà spiegata dall'output dei vari comandi mentre procedi. È molto facile; non è necessario memorizzarlo - ricorda solo che git rebase --interactiveti consente di correggere gli commit, non importa quanto tempo fa.


Nota che non vorrai cambiare i commit che hai già premuto. O forse lo fai, ma in tal caso dovrai fare molta attenzione a comunicare con tutti coloro che potrebbero aver fatto i tuoi impegni e aver lavorato su di essi. Come posso recuperare / risincronizzare dopo che qualcuno invia un rebase o un reset a un ramo pubblicato?


39
Si può cambiare il messaggio del primo commit (che non ha un genitore)?
13

27
Questo è menzionato in una delle altre risposte, ma ne metterò una nota qui. Da git 1.6.6 è possibile utilizzare rewordal posto di pickper modificare il messaggio di registro.
MitMaro,

89
Per inciso, $parent_of_flawed_commitè equivalente a $flawed_commit^.
Peeja,

67
Mai e poi mai farlo (o rebase in generale) se hai già spinto a monte!
Daniel Rinser,

20
Utilizzare -p( --preserve-merges) se si è verificata un'unione dopo il commit errato.
anche il

778

Per modificare il commit precedente, apportare le modifiche desiderate e metterle in scena, quindi eseguire

git commit --amend

Questo aprirà un file nel tuo editor di testo che rappresenta il tuo nuovo messaggio di commit. Inizia popolato con il testo del tuo vecchio messaggio di commit. Modificare il messaggio di commit come desiderato, quindi salvare il file e chiudere l'editor per terminare.

Per modificare il commit precedente e mantenere lo stesso messaggio di registro, eseguire

git commit --amend -C HEAD

Per correggere il commit precedente rimuovendolo completamente, esegui

git reset --hard HEAD^

Se si desidera modificare più di un messaggio di commit, eseguire

git rebase -i HEAD~commit_count

(Sostituisci commit_count con il numero di commit che vuoi modificare.) Questo comando avvia il tuo editor. Contrassegna il primo commit (quello che desideri modificare) come "modifica" anziché "scegli", quindi salva ed esci dal tuo editor. Apporta la modifica che desideri impegnare ed esegui

git commit --amend
git rebase --continue

Nota: è anche possibile "Apportare la modifica desiderata" dall'editor aperto da git commit --amend


18
git rebase -i HEAD~commit_countti consentirà anche di modificare i messaggi di commit di qualunque commit tu scelga. Contrassegna semplicemente i commit scelti come "reword" anziché "pick".
Joe,

2
Che cosa succede se non vuoi rifare? Vuoi solo cambiare un messaggio più vecchio?
SuperUberDuper,

3
git reset --hardannulla i cambiamenti non impegnati. Si prega di sostituire --hardcon --soft.
Eel GhEEz,

1
D'accordo, git reset --hardè un comando perfettamente legittimo, ma è fuorviante data la domanda. Usi --hardse hai commesso le modifiche che vuoi buttare via, non se hai fatto un refuso nel messaggio di commit!
Soren Bjornstad,

398

Come già accennato, git commit --amendè il modo di sovrascrivere l'ultimo commit. Una nota: se si desidera sovrascrivere anche i file , il comando sarebbe

git commit -a --amend -m "My new commit message"

4
E se non vuoi aggiungere tutto, puoi prima fare git add file.extsolo alloragit commit --amend
MalcolmOcean

358

Puoi anche usarlo git filter-branchper questo.

git filter-branch -f --msg-filter "sed 's/errror/error/'" $flawed_commit..HEAD

Non è facile come un banale git commit --amend, ma è particolarmente utile, se hai già delle fusioni dopo il tuo messaggio di commit errato.

Nota che questo tenterà di riscrivere ogni commit tra HEADe il commit imperfetto, quindi dovresti scegliere il tuo msg-filtercomando molto saggiamente ;-)


4
Esiste una versione di questo che non cambia il commit se il regex non trova nulla?
sjakubowski,

3
Filiale-filtro AFAIK --msg-filter genererà nuovi commit in ogni caso. Tuttavia, è possibile verificare all'interno del filtro msg, se sed ha avuto successo e utilizzare queste informazioni al termine dell'operazione di diramazione del filtro per ripristinare l'albero su refs / original.
Marco

4
@DavidHogue Questo è vero solo quando si utilizza il metodo filtro-ramo. Gli ID di commit a seguito di un commit modificato non cambiano se si utilizza il rebase interattivo.
Segna il

6
@Mark Sì, lo sono, sono tenuti a farlo. Gli ID di commit dipendono dai commit precedenti. Se non cambiassero, git sarebbe inutile.
Miles Rout,

2
È necessario $flawed_commit^..HEAD, non è $flawed_commit..HEAD. come indicato dalla pagina man: « Il comando riscriverà solo i riferimenti positivi menzionati nella riga di comando (ad es. se si passa a..b, verrà riscritto solo b). »
Ángel,

319

Preferisco così:

git commit --amend -c <commit ID>

Altrimenti, ci sarà un nuovo commit con un nuovo ID commit.


7
Per me, l'utilizzo del comando sopra in realtà crea un nuovo commit con un nuovo ID commit più un commit aggiuntivo che dice "unisci ramo" come messaggio di commit predefinito.
Jan

46
La modifica crea sempre un nuovo commit con un nuovo ID commit. L'ID commit è l'hash SHA del contenuto del commit, inclusi il messaggio di commit e i timestamp creati / impegnati. Questa è una caratteristica di Git che, escludendo le collisioni di hash, garantisce che due commit con lo stesso ID siano esattamente lo stesso commit, con esattamente lo stesso contenuto, cronologia e così via.
Emil Lundberg,

7
D'accordo con Emil. Inoltre, leggendo i documenti - sembra che tutto ciò che "-c" fa è dire a git quale messaggio di commit utilizzare come predefinito / modello per il nuovo commit ... In realtà sta già per fare "-c <commit ID>" per impostazione predefinita , quindi non è necessario specificarlo.
Gal

2
La -cfa un paio di cose. Utilizza il vecchio messaggio per impostazione predefinita, ma copia anche le informazioni sull'autore (persona e ora). -Cfa la stessa cosa, tranne per il fatto che non ti chiede di modificare il messaggio.
Joseph K. Strauss,

1
Come @SantanuDey, non ha funzionato per me. Ho avutofatal: Option -m cannot be combined with -c/-C/-F/--fixup.
Andrew Grimm il

312

Se si utilizza lo strumento Git GUI, è presente un pulsante denominato Modifica ultimo commit . Fai clic su quel pulsante e quindi verranno visualizzati i tuoi ultimi file e messaggi di commit. Basta modificare quel messaggio e puoi impegnarlo con un nuovo messaggio di commit.

Oppure usa questo comando da una console / terminale:

git commit -a --amend -m "My new commit message"

4
Questa risposta è letteralmente identica a questa più vecchia . Hai controllato le risposte esistenti prima di fornirne un'altra?
Dan Dascalescu,

284

Puoi usare il rebasing di Git . Ad esempio, se si desidera modificare nuovamente per eseguire il commit di bbc643cd, eseguire

$ git rebase bbc643cd^ --interactive

Nell'editor predefinito, modifica "scegli" per "modificare" nella riga di cui desideri modificare il commit. Apporta le tue modifiche e poi mettile in scena con

$ git add <filepattern>

Adesso puoi usare

$ git commit --amend

per modificare il commit e successivamente

$ git rebase --continue

per tornare al precedente head commit.


1
Se vuoi assicurarti che la modifica abbia git commit --amendavuto effetto, puoi usare git showe mostrerà il nuovo messaggio.
Steve Tauber,

279
  1. Se vuoi solo modificare il tuo ultimo messaggio di commit, allora fai:

    git commit --amend
    

Questo ti farà entrare nel tuo editor di testo e ti permetterà di cambiare l'ultimo messaggio di commit.

  1. Se si desidera modificare gli ultimi tre messaggi di commit o uno qualsiasi dei messaggi di commit fino a quel momento, fornire HEAD~3al git rebase -icomando:

    git rebase -i HEAD~3
    

6
Questo precedente risposta dice già che è possibile utilizzare git commit --amend, e si dice anche che è possibile utilizzare git rebase -i HEAD~commit_count, tutto quello che ha fatto è stato plug-in 3per commit_count.

Anche sottovalutato. Le persone non si preoccupano di leggere le risposte esistenti .
Dan Dascalescu,

261

Se devi cambiare un vecchio messaggio di commit su più rami (ovvero, il commit con il messaggio errato è presente in più rami) potresti voler usare:

git filter-branch -f --msg-filter \
'sed "s/<old message>/<new message>/g"' -- --all

Git creerà una directory temporanea per riscrivere e fare anche il backup dei vecchi riferimenti in refs/original/.

  • -fimporrà l'esecuzione dell'operazione. Ciò è necessario se la directory temporanea è già presente o se sono già presenti riferimenti memorizzati refs/original. In caso contrario, è possibile eliminare questo flag.

  • -- separa le opzioni di filtro-ramo dalle opzioni di revisione.

  • --allfarà in modo che tutti i rami e i tag vengano riscritti.

A causa del backup dei vecchi riferimenti, è possibile tornare facilmente allo stato prima di eseguire il comando.

Dì, vuoi recuperare il tuo master e accedervi nel ramo old_master:

git checkout -b old_master refs/original/refs/heads/master

3
Questa risposta non affronta la domanda del PO, poiché sono puramente interessati a correggere un commit che hanno appena fatto. Ho regolarmente uso git commit --amendper sistemare commenti o aggiungere file ho dimenticato di git add, ma solo mai prima di aver git pushcato. Lo uso anche git filter-branchquando desidero scherzare totalmente con la cronologia delle versioni, ma l'OP non lo vuole, quindi questa risposta ha bisogno di un grande avviso di salute: non provarlo a casa, sbircia !!
Kbro,

226

Uso

git commit --amend

Per capirlo in dettaglio, un post eccellente è 4. Riscrivere Git History . Parla anche di quando non usarlo git commit --amend .


2
Esiste un buon modo per correggere i messaggi di commit già inviati a un repository pubblico? Finora sono giunto alla conclusione che, una volta spinto, i miei errori di battitura e i miei pensieri di commit devono vivere per sempre.
Stackunderflow

2
In una parola, NOPE! Non esiste un buon modo per ritrarre qualcosa che hai spinto. Tutte le ritrattazioni sono CATTIVE in misura maggiore o minore. Devi adottare la disciplina di lavorare in un ramo nel tuo repository privato, fare più commit mentre aggiungi un po ', testare un po', modificare un po '. Quindi unisci l'intero ramo in un unico commit, scrivi un nuovo messaggio di commit che descriva la modifica generale, PROVA e fai push.
Kbro,

1
Giusto per sottolineare l'ovvio che non è necessario effettuare un singolo commit quando si torna da un ramo di funzionalità. Ciò che molte persone fanno è rifare sul ramo di destinazione (per rendere le cose pulite), quindi fondersi con l'opzione per sopprimere l'avanzamento rapido. Concordi con il punto principale di essere attento prima di alzare comunque.
ShawnFumo,

1
La git commit --amendrisposta era già stata data (diverse volte) prima che tu scrivessi la tua. Perché l'hai pubblicato di nuovo? Se volessi aggiungere un link a "Riscrivere Git History", avresti potuto modificare una delle risposte esistenti o lasciare un commento.
Dan Dascalescu,

199

emendare

Hai un paio di opzioni qui. Tu puoi fare

git commit --amend

purché sia ​​il tuo ultimo commit.

Rebase interattivo

Altrimenti, se non è il tuo ultimo commit, puoi fare un rebase interattivo,

git rebase -i [branched_from] [hash before commit]

Quindi, all'interno del rebase interattivo, aggiungi semplicemente la modifica a quel commit. Quando viene visualizzato, eseguire un git commit --amende modificare il messaggio di commit. Se vuoi eseguire il rollback prima di quel punto di commit, puoi anche usare git refloged eliminare quel commit. Quindi lo fai di git commitnuovo.


191

Se è il tuo ultimo commit, basta modificare il commit:

git commit --amend -o -m "New commit message"

(Utilizzando il flag -o( --only) per assicurarsi di modificare solo il messaggio di commit)


Se è un commit sepolto, usa il fantastico rebase interattivo :

git rebase -i @~9   # Show the last 9 commits in a text editor

Trova il commit che desideri, cambia pick in r( reword), salva e chiudi il file. Fatto!



Tutorial Vim in miniatura (o, come rifare con solo 8 sequenze di tasti 3jcwrEscZZ):

  • Esegui vimtutorse hai tempo
  • hjkl corrisponde ai tasti di movimento
  • Tutti i comandi possono essere preceduti da un "intervallo", ad es 3j sposta in basso di tre righe
  • i per accedere alla modalità di inserimento - il testo digitato verrà visualizzato nel file
  • Esc o Ctrlc per uscire dalla modalità di inserimento e tornare alla modalità "normale"
  • u per annullare
  • Ctrlr da rifare
  • dd, dw,dl Per cancellare una riga, una parola o lettera, rispettivamente,
  • cc, cw, clPer modificare una riga, parola o lettera, rispettivamente (ugualeddi )
  • yy, yw, ylCopiare ( "Yank") una linea, una parola o lettera, rispettivamente,
  • po Pincollare dopo, o prima della posizione corrente, rispettivamente
  • :wEnter per salvare (scrivere) un file
  • :q!Enter per uscire senza salvare
  • :wqEntero ZZper salvare ed uscire

Se modifichi molto il testo, passa al layout di tastiera Dvorak , impara a digitare il tocco e impara Vim. Ne vale la pena? Sì.



ProTip ™: non aver paura di sperimentare comandi "pericolosi" che riscrivono la cronologia * - Git non cancella i tuoi commit per 90 giorni di default; li puoi trovare nel reflog:

$ git reset @~3   # Go back three commits
$ git reflog
c4f708b HEAD@{0}: reset: moving to @~3
2c52489 HEAD@{1}: commit: more changes
4a5246d HEAD@{2}: commit: make important changes
e8571e4 HEAD@{3}: commit: make some changes
... earlier commits ...
$ git reset 2c52489
... and you're back where you started

* Fai attenzione a opzioni come --harde --forcesebbene: possono scartare i dati. * Inoltre, non riscrivere la cronologia su nessun ramo su cui stai collaborando.


3
La parte vim è completamente fuori tema e invece di incoraggiare gli utenti a dedicare del tempo ad imparare a usare un editor arcano, perché non insegnare loro qualcosa di più sull'argomento, come come impostare l'editor git predefinito in modo che sia qualcosa di facile da usare, come nano? Stiamo parlando di modifiche banali che devono essere apportate a un file di testo, non di una codifica hardcore che genererebbe una guerra di fiamma sull'editor di testo "migliore".
Dan Dascalescu

1
@DanDascalescu: Perché è più veloce imparare Vim usando le istruzioni sopra che eseguire diversi rebase usando nano. L'intero motivo per cui git apre un editor di testo e non la propria interfaccia per il rebasing è perché Vim esiste: è leggero, installato di default sulla maggior parte dei sistemi e molto facile da imparare abbastanza da eseguire un rebase con facilità: ad esempio ddjjpZZsposta un commit 2 verso il basso. Non c'è nulla di arcano nella conoscenza di base di Vim; ci vogliono 10 minuti per sentirsi più a proprio agio con Vim che con Nano.
Zaz,

185

Se si utilizza la GUI di Git, è possibile modificare l'ultimo commit che non è stato inviato con:

Commit/Amend Last Commit

168

Uso la GUI di Git il più possibile e ciò ti dà la possibilità di modificare l'ultimo commit:

Spunta quella casella

Inoltre, git rebase -i origin/masterè un bel mantra che ti presenterà sempre i commit che hai fatto in cima al master e ti darà la possibilità di modificare, eliminare, riordinare o schiacciare. Non è necessario prima acquisire l'hash.


4
Come posso accedere a quella schermata che hai visualizzato nel tuo esempio?
Marwan مروان

2
È la parte in basso a destra di Windows Git Gui. Basta selezionare l'interruttore 'Modifica ultimo commit', e si popolerà con le informazioni di commit più recenti.
wbdarby,

138

Wow, quindi ci sono molti modi per farlo.

Un altro modo per farlo è eliminare l'ultimo commit, ma mantenere le sue modifiche in modo da non perdere il lavoro. È quindi possibile eseguire un altro commit con il messaggio corretto. Questo sarebbe simile a questo:

git reset --soft HEAD~1
git commit -m 'New and corrected commit message'

Lo faccio sempre se dimentico di aggiungere un file o faccio una modifica.

Ricorda di specificare --softinvece di --hard, altrimenti perdi completamente il commit.


5
Questo fa esattamente la stessa cosa, git commit --amendtranne per il fatto che si tratta di un processo in 2 passaggi.
Joseph K. Strauss,

3
@ JosephK.Strauss Credo che l'ammissione del commit mantenga anche le informazioni sull'autore e sulla data del commit originale, avendo il nuovo commiter e le informazioni sulla data separatamente. Non sono sicuro che questo approccio lo faccia.
everton,

4
@EvertonAgner Hai ragione. --amendmanterrà le informazioni sull'autore, ma la domanda chiede solo di cambiare il messaggio.
Joseph K. Strauss,

131

Per chiunque cerchi una GUI di Windows / Mac per aiutare a modificare i messaggi più vecchi (cioè non solo l'ultimo messaggio), consiglierei Sourcetree . I passaggi da seguire sono di seguito.

Sourcetree rebase interattivo

Per i commit che non sono stati ancora trasferiti su un telecomando:

  1. Assicurati di aver eseguito il commit o l'archiviazione di tutte le modifiche correnti (ad esempio, quindi non ci sono file elencati nella scheda "Stato file") - altrimenti non funzionerà.
  2. Nella scheda "Registro / Cronologia", fai clic con il pulsante destro del mouse sulla voce con una riga adiacente nel grafico una sotto i commit che desideri modificare e seleziona "Rebase figlio di <commit ref> interattivo ..."
  3. Seleziona l'intera riga per un messaggio di commit che desideri modificare (fai clic sulla colonna "Messaggio") .
  4. Fai clic sul pulsante "Modifica messaggio".
  5. Modifica il messaggio come desiderato nella finestra di dialogo che viene visualizzata, quindi fai clic su OK.
  6. Ripetere i passaggi 3-4 se ci sono altri messaggi di commit da modificare.
  7. Fare clic su OK: Rebasing avrà inizio. Se tutto va bene, l'output terminerà "Completato correttamente". NOTA: a volte ho riscontrato questo errore con il Unable to create 'project_path/.git/index.lock': File exists.tentativo di modificare più messaggi di commit contemporaneamente. Non sono sicuro di quale sia esattamente il problema, o se verrà risolto in una versione futura di Sourcetree, ma se ciò dovesse accadere consiglierei di risolverli uno alla volta (più lento ma sembra più affidabile).

... O ... per i commit che sono già stati spinti:

Seguire i passaggi in questa risposta , che sono simili a quelli precedenti, ma richiedono un ulteriore comando da eseguire dalla riga di comando ( git push origin <branch> -f) per forzare il push del ramo. Consiglio di leggere tutto e applicare le precauzioni necessarie!


di tutte le risposte - questo è il più appropriato per tutti i principianti git ^^^ (usa un programma gratuito SourceTree e applica "Rebase children of" su un commit prima di quello che vuoi modificare)
rivisto il

127

Se vuoi solo modificare l'ultimo commit, usa:

git commit --amend

o

git commit --amend -m 'one line message'

Ma se vuoi modificare diversi commit di fila, dovresti usare invece il rebasing:

git rebase -i <hash of one commit before the wrong commit>

Modifica modifica rebit

In un file, come quello sopra, scrivi edit/eo una delle altre opzioni e premi salva ed esci.

Ora sarai al primo commit sbagliato. Apporta le modifiche ai file e verranno messe in scena automaticamente per te. genere

git commit --amend

Salvare e uscire da quello e digitare

git rebase --continue

per passare alla selezione successiva fino al termine di tutte le selezioni.

Nota che queste cose cambiano tutti gli hash SHA dopo quel particolare commit.


2
git rebase -i <hash di un commit prima del commit errato> funziona per me. Grazie.
Viraths,

127

Se vuoi solo cambiare il tuo ultimo messaggio, dovresti usare il --onlyflag o il suo collegamento -ocon commit --amend:

git commit --amend -o -m "New commit message"

Questo ti assicura di non migliorare accidentalmente il tuo commit con elementi in scena. Naturalmente è meglio avere una corretta $EDITORconfigurazione. Quindi puoi lasciare l' -mopzione fuori e Git pre-riempirà il messaggio di commit con quello vecchio. In questo modo può essere facilmente modificato.


1
La risposta "top" non risponde alla domanda. Dà solo un'introduzione generale a git commit --amend. La domanda era molto specifica, quindi più lunga! = Migliore. La menzione decisiva della -obandiera verrebbe probabilmente sepolta nel resto delle informazioni. Inoltre non mi sento a mio agio nel modificare una risposta che ha già così tanti voti.
David Ongaro,

2
Detto questo, sei libero di modificare la risposta migliore, dal momento che esiste il reale pericolo che la gente la usi come risposta "corretta". Può facilmente succedere di modificare il tuo commit con cose in scena - è successo a me, ed è davvero fastidioso quando ti capita di spingerlo. Tuttavia, la quantità non è garanzia di correttezza. Né in numero di risposte né in numero di voti.
David Ongaro,

1
Non andrei così lontano per dire che la risposta migliore è "errata" e che "non risponde alla domanda". Funziona sicuramente e risponde alla domanda, devi solo assicurarti di non aver messo in scena cambiamenti quando provi a modificarlo. Ma vedo il tuo punto di dover avvertire la gente a riguardo. Lo modificherò più tardi se ho tempo.

1
Ad essere onesti: anche se l' --onlyopzione con --amendè disponibile da git 1.3.0 non ha funzionato correttamente fino a quando non è stata riparata in 1.7.11.3 ( ea2d4ed35902ce15959965ab86d80527731a177c ). Quindi la risposta giusta nel 2008 sarebbe stato probabilmente qualcosa come: git stash; git commit --amend; git stash pop.
David Ongaro,

103

Aggiorna l'ultimo messaggio di commit errato con il nuovo messaggio di commit in una riga:

git commit --amend -m "your new commit message"

Oppure, prova Git reset come di seguito:

# You can reset your head to n number of commit
# NOT a good idea for changing last commit message,
# but you can get an idea to split commit into multiple commits
git reset --soft HEAD^

# It will reset you last commit. Now, you
# can re-commit it with new commit message.

Utilizzo di reset per suddividere i commit in commit più piccoli

git reset può aiutarti a suddividere un commit anche in più commit:

# Reset your head. I am resetting to last commits:
git reset --soft HEAD^
# (You can reset multiple commit by doing HEAD~2(no. of commits)

# Now, reset your head for splitting it to multiple commits
git reset HEAD

# Add and commit your files separately to make multiple commits: e.g
git add app/
git commit -m "add all files in app directory"

git add config/
git commit -m "add all files in config directory"

Qui hai suddiviso correttamente il tuo ultimo commit in due commit.


3
Se tutto ciò che vuoi fare è modificare il messaggio del tuo ultimo commit, utilizzare un soft reset a tale scopo è over-kill . Basta usare git commit --amend, esattamente come dice nella risposta più votata . Inoltre, git reset --soft HEAD^funziona in modo identico al ripristino software in questa risposta precedente , poiché entrambi ripristinano il primo commit principale.

3
Mi preoccupo solo di aggiungere git resetla soluzione solo per dare l'idea di dividere un messaggio di commit in più messaggi di commit. Perché, ho riscontrato questo problema quando, stavo iniziando a usare git. A volte, questo può essere davvero utile. :)
przbadu,

87

Su questa domanda ci sono molte risposte, ma nessuna di esse spiega in dettaglio come modificare i vecchi messaggi di commit usando Vim . Ero bloccato cercando di farlo da solo, quindi qui scriverò in dettaglio come ho fatto questo soprattutto per le persone che non hanno esperienza in Vim!

Volevo modificare i miei ultimi cinque commit che ho già inviato al server. Questo è abbastanza 'pericoloso' perché se qualcun altro ha già preso questo, puoi rovinare tutto cambiando i messaggi di commit. Tuttavia, quando stai lavorando sul tuo piccolo ramo e sei sicuro che nessuno lo abbia tirato puoi cambiarlo in questo modo:

Diciamo che vuoi cambiare i tuoi ultimi cinque commit, e poi digiti questo nel terminale:

git rebase -i HEAD~5

* Dove 5 è il numero di messaggi di commit che si desidera modificare (quindi se si desidera modificare il decimo per ultimo commit, digitare 10).

Questo comando ti porterà in Vim lì dove puoi "modificare" la cronologia dei tuoi commit. Vedrai i tuoi ultimi cinque commit in alto in questo modo:

pick <commit hash> commit message

Invece di pickte devi scrivere reword. Puoi farlo in Vim digitando i. Questo ti fa entrare nella modalità di inserimento . (Vedi che sei in modalità di inserimento dalla parola INSERT in fondo.) Per i commit che vuoi modificare, digita rewordinvece dipick .

Quindi è necessario salvare ed uscire da questa schermata. Puoi farlo andando prima in "modalità comando" premendo il Escpulsante (puoi controllare che sei in modalità comando se la parola INSERT in fondo è scomparsa). Quindi è possibile digitare un comando digitando :. Il comando per salvare ed uscire è wq. Quindi se digiti :wqsei sulla strada giusta.

Quindi Vim esaminerà tutti i messaggi di commit che desideri riformulare e qui puoi effettivamente modificare i messaggi di commit. Lo farai andando nella modalità di inserimento, cambiando il messaggio di commit, andando nella modalità di comando, e salvando ed esci. Fallo cinque volte e sei fuori da Vim!

Quindi, se hai già spinto i tuoi commit sbagliati, devi git push --forcesovrascriverli. Ricorda che git push --forceè una cosa abbastanza pericolosa da fare, quindi assicurati che nessuno abbia rimosso il server da quando hai spinto i tuoi impegni sbagliati!

Ora hai cambiato i tuoi messaggi di commit!

(Come vedi, non sono così esperto in Vim, quindi se ho usato il 'lingo' sbagliato per spiegare cosa sta succedendo, sentiti libero di correggermi!)


4
<nitpick>Non ci sono "discussioni" su Stack Overflow, perché non è un forum di discussione, ci sono solo "domande", "risposte" e "post". </nitpick>. Inoltre, non tutte le versioni di Vim sono uguali, non tutte ti consentiranno di eliminare i caratteri in modalità inserimento (ha senso in un certo senso, giusto?). Se vuoi essere sempre in grado di eliminare i caratteri in Vim, Xe xlo farai (il piccolo xelimina i caratteri davanti al cursore, Xli cancellerà dietro). Se si commettono errori, è possibile utilizzare uripetutamente per annullare. Infine, rè una scorciatoia rewordnell'editor rebase interattivo.

1
Per cambiare una parola in vim viene cwdigitata all'inizio (anche se la domanda non riguarda vim, sono d'accordo).
Yaroslav Nikitenko il

Non è necessario usare quell'abominio . Puoi impostare il tuo editor git su qualcosa di sano e nanointuitivo , come il mcedit di Midnight Commander.
Dan Dascalescu,

79

Puoi usare git-rebase-reword

È progettato per modificare qualsiasi commit (non solo ultimo) allo stesso modo di commit --amend

$ git rebase-reword <commit-or-refname>

Prende il nome dall'azione su rebase interattivo per modificare un commit: "reword". Vedi questo post e la modalità interattiva man- section-

Esempi:

$ git rebase-reword b68f560
$ git rebase-reword HEAD^

6
Ciò richiede l'installazione di un programma esterno. A mio avviso, sarebbe meglio imparare a utilizzare gli strumenti e gli alias integrati in modo più efficace. Digitare: g c; g rb -i @~9(commit e rebase), spostare il nuovo commit nel punto desiderato, passare commita f( fixup) e salvare. Se volessi qualcosa di più veloce di quello, potresti alias git commit --fixup=<commit>; git rebase -i --autosquash <commit>^
Zaz

79

Ho aggiunto gli alias recie recmper recommit (amend)questo. Ora posso farlo con git recmo git recm -m:

$ vim ~/.gitconfig

[alias]

    ......
    cm = commit
    reci = commit --amend
    recm = commit --amend
    ......

57

Mi sono reso conto che avevo spinto un commit con un refuso in esso. Per annullare, ho fatto quanto segue:

git commit --amend -m "T-1000, advanced prototype"
git push --force

Avvertenza: forzare la spinta delle modifiche sovrascriverà il ramo remoto con quello locale. Assicurati di non sovrascrivere nulla che desideri conservare. Fai anche attenzione alla forza che spinge un commit modificato (riscritto) se qualcun altro condivide il ramo con te, perché dovranno riscrivere la propria cronologia se hanno la vecchia copia del commit che hai appena riscritto.


7
Niente viene mai "sovrascritto" in git. In questo caso il puntatore del ramo verrà impostato sul nuovo commit e il vecchio commit diventerà obsoleto se non viene lasciato alcun riferimento e potrebbe essere ripulito dopo alcune settimane. (Fino ad allora altri ancora riescono a trovarlo e fare riferimento, ad esempio guardando nel reflog.)
David Ongaro

51

Mi piace usare quanto segue:

  1. git status
  2. git add --all
  3. git commit -am "message goes here about the change"
  4. git pull <origin master>
  5. git push <origin master>

46

Se non hai inviato il codice al tuo ramo remoto ( GitHub / Bitbucket ) puoi modificare il messaggio di commit sulla riga di comando come di seguito.

 git commit --amend -m "Your new message"

Se stai lavorando su un ramo specifico, procedi come segue:

git commit --amend -m "BRANCH-NAME: new message"

Se hai già inviato il codice con il messaggio sbagliato e devi fare attenzione quando cambi il messaggio. Cioè, dopo aver modificato il messaggio di commit e aver provato a spingerlo di nuovo, si finisce per avere problemi. Per renderlo uniforme, attenersi alla seguente procedura.

Si prega di leggere la mia intera risposta prima di farlo.

git commit --amend -m "BRANCH-NAME : your new message"

git push -f origin BRANCH-NAME                # Not a best practice. Read below why?

Nota importante: quando si utilizza la forza forzata direttamente, si potrebbero riscontrare problemi di codice che altri sviluppatori stanno lavorando sullo stesso ramo. Quindi, per evitare tali conflitti, è necessario estrarre il codice dal proprio ramo prima di forzare :

 git commit --amend -m "BRANCH-NAME : your new message"
 git pull origin BRANCH-NAME
 git push -f origin BRANCH-NAME

Questa è la procedura migliore per modificare il messaggio di commit, se è stato già inviato.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.