27 Domanda: Come modificare i messaggi di commit esistenti non premuti?

domanda creata a Thu, May 2, 2019 12:00 AM

Ho scritto la cosa sbagliata in un messaggio di commit.

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

    
7672
  1. Per quelli in qualche modo nuovi da git: il punto di vista di Laurie su non aver ancora spinto è importante. Come la ridefinizione, questo sta cambiando la storia. Se qualcuno ha clonato /estratto dal repository tra la cronologia originale e quella riscritta, non sarà in grado di eseguire il pull dopo la riscrittura (per quel ramo).
    2008-10-10 20: 12: 17Z
27 risposte                              27                         

Modifica del messaggio di commit più recente

 
git commit --amend

aprirà il tuo editor, permettendoti di cambiare il messaggio di commit del commit più recente. Inoltre, puoi impostare il messaggio di commit direttamente nella riga di comando con:

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

... tuttavia, questo può rendere più ingombranti i messaggi di commit su più righe o piccole correzioni.

Assicurati di non avere nessuna modifica della copia di lavoro messa in scena prima di fare ciò, altrimenti si impegneranno anch'essi. (Le modifiche non prestate non verranno confermate.)

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

Se hai già trasferito il tuo commit sulla tua diramazione remota, allora deve forzare a spingere il commit con:

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

Avviso: il push forzato sovrascriverà il ramo remoto con lo stato di quello locale . Se ci sono commit sul ramo remoto che non hai nel tuo branch locale, perderà quei commit.

Avviso: fai attenzione a modificare i commit che hai già condiviso con altre persone. L'emendamento impegna essenzialmente riscrivi per avere SHA ID, che pone 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 commit appena riscritto, che a volte può essere difficile, quindi assicurati di coordinarti con gli altri quando tenti di riscrivere la cronologia dei commit condivisa, o semplicemente evita di riscrivere i commit condivisi del tutto.


Utilizza rebase interattivo

Un'altra opzione è usare rebase interattivo.
Ciò ti consente di modificare qualsiasi messaggio che desideri aggiornare anche se non è l'ultimo messaggio.

Per fare un git squash, segui questi passaggi:

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

Una volta schiacciato il tuo commit - scegli il e/r per modificare il messaggio

 inserisci la descrizione dell'immagine qui

Nota importante su Interactive rebase

Quando usi il git rebase -i HEAD~X, può esserci più di X commit. Git "raccoglierà" tutti i commit degli ultimi X commit e se c'è stata un'unione tra quel range vedrai anche tutti i commit così il risultato sarà X +.

Suggerimento:

Se devi farlo per più di una singola filiale e potresti dover affrontare dei conflitti quando modifichi il contenuto, configura git rerere e lascia che Git risolva automaticamente tali conflitti per te.


Documentazione

15372
2019-01-25 15: 17: 31Z
  1. Tuttavia git commit --amend non è potente come git rebase -i.
    2010-07-05 08: 40: 35Z
  2. @ jeffjose, sicuramente non ha bisogno di essere. Inoltre, git commit --amend può correggere il commit del dominio (a?).
    2010-07-14 06: 02: 30Z
  3. Se hai già premuto, forza semplicemente push di nuovo: git push -f origin branchname
    2012-05-02 14: 12: 24Z
  4. @ hughes non è git push -f un po 'pericoloso se altre persone usano lo stesso repository?
    2012-11-08 07: 48: 41Z
  5. Se non vuoi riscrivere l'intero messaggio di commit, vai su git commit --amend -c HEAD. Questo aprirà l'editor pre-compilato con il vecchio messaggio di commit, quindi puoi cambiarlo.
    2012-11-14 15: 38: 10Z
 
git commit --amend -m "your new message"
    
2461
2016-03-01 18: 19: 29Z
  1. Ho fatto git commit --amend -m "New message", ma premendo su Github ho generato "Unisci le modifiche remote prima di premere nuovamente". Dopo il pull, commit --amend e push di nuovo, il nuovo messaggio non appare. Invece ho "Unisci branch master" di github.com:[myrepo] "
    2011-10-14 16: 58: 32Z
  2. @ DaveEveritt molto probabilmente hai spinto il tuo commit upstream prima di provare a risolverlo.
    2013-04-25 08: 21: 20Z
  3. @ Kyralessa non è vero. In bash puoi facilmente comporre messaggi di commit multilinea semplicemente non chiudendo la citazione fino a quando non hai finito (premendo il ritorno alla fine di ogni riga tra virgolette).
    2013-06-11 21: 11: 57Z
  4. Non capisco come una risposta assomigli molto all'idea principale di una risposta che è stata scritta due anni fa e anche la risposta accettata ottiene tanti voti . Strano. (non c'è niente di sbagliato nella risposta)
    2014-01-15 05: 30: 22Z
  5. @ AmalMurali, beh. Il mio punto non era tanto la popolarità della domanda, né l'utilità della risposta. Ma questa particolare risposta non è la risposta più antica, né offre ulteriori informazioni sulla risposta accettata. Sembra essere una copia di una sezione della risposta accettata. Questo era il mio punto. Cheers!
    2014-05-21 20: 16: 23Z

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

  1. git rebase --interactive $parent_of_flawed_commit

    Se vuoi correggere diversi commit difettosi, passa il genitore di uno dei più vecchi.

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

    1. Modifica da pick a reword (o su versioni precedenti di Git, a edit) di fronte a qualsiasi commit che vuoi correggere.
    2. Una volta salvato, Git ripeterà i commit elencati.
  3. Per ogni commit che vuoi reword , Git ti riporterà nel tuo editor. Per ogni commit che vuoi edit , Git ti fa cadere nella shell. Se sei nella shell:

    1. Cambia 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 man mano che procedi. È molto semplice, non è necessario memorizzarlo: ricorda che il git rebase --interactive ti consente di correggere i commit non importa quanto tempo fa.


Nota che non vorrai cambiare i commit che hai già spinto. O forse lo fai, ma in quel caso dovrai fare molta attenzione a comunicare con chiunque abbia tirato fuori i tuoi impegni e fatto il lavoro su di loro. Come faccio a ripristinare /risincronizzare dopo che qualcuno ha premuto un rebase o un reset to un ramo pubblicato?

    
2336
2017-05-23 12: 02: 48Z
  1. Si può cambiare il messaggio del primo commit (che non ha un genitore)?
    2010-01-21 19: 57: 18Z
  2. Questo è menzionato in una delle altre risposte, ma ne inserirò una nota qui. Poiché git 1.6.6 è possibile utilizzare reword al posto di pick per modificare il messaggio di registro.
    2010-05-31 13: 27: 57Z
  3. Per inciso, $parent_of_flawed_commit è equivalente a $flawed_commit^.
    2010-11-28 23: 26: 12Z
  4. Mai MAI fare questo (o rebase in generale) se hai già spinto a monte!
    2011-05-31 19: 14: 04Z
  5. Usa -p (--preserve-merges) se c'è stata un'unione dopo il commit errato.
    2012-01-31 14: 37: 47Z

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 dal vecchio messaggio di commit. Cambia il messaggio di commit come vuoi, quindi salva il file e chiudi l'editor per terminarlo.

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

 
git commit --amend -C HEAD

Per correggere il commit precedente rimuovendolo interamente, esegui

 
git reset --hard HEAD^

Se desideri modificare più di un messaggio di commit, esegui

 
git rebase -i HEAD~commit_count

(Sostituisci commit_count con il numero di commit che desideri modificare.) Questo comando avvia l'editor. Segna il primo commit (quello che vuoi cambiare) come "edit" invece di "pick", quindi salva ed esci dal tuo editor. Apporta la modifica che desideri eseguire e poi lancia

 
git commit --amend
git rebase --continue

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

    
762
2014-10-24 10: 20: 01Z
  1. git rebase -i HEAD~commit_count ti permetterà anche di cambiare i messaggi di commit di molti commit che scegli. Contrassegna i commit scelti come "reword" anziché "pick".
    2013-08-21 20: 21: 59Z
  2. Che cosa succede se non vuoi rebase? Vuoi solo cambiare un vecchio messaggio?
    2016-04-21 08: 56: 35Z
  3. git reset --hard annulla le modifiche non eseguite. Sostituire --hard con --soft.
    2018-02-28 17: 44: 56Z

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

 
git commit -a --amend -m "My new commit message"
    
392
2014-02-23 23: 10: 08Z
  1. E se non vuoi aggiungere tutto, puoi prima fare git add file.ext quindi solo git commit --amend
    2015-09-22 05: 56: 35Z

Puoi anche usare git filter-branch per 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 unioni dopo il tuo messaggio di commit errato.

Si noti che questo tenterà di riscrivere OGNI commit tra HEADe il commit imperfetto, quindi dovresti scegliere il comando msg-filter molto saggio; -)

    
352
2014-05-21 02: 37: 16Z
  1. Esiste una versione di questo che non cambia il commit se la regex non trova nulla?
    2013-03-28 20: 08: 13Z
  2. AFAIK filtro-ramo --msg-filter genererà nuovi commit in ogni caso. Tuttavia, è possibile controllare all'interno del filtro msg, se il sed è riuscito e utilizzare questa informazione quando l'operazione di filtro-branch termina per reimpostare l'albero su refs /originale.
    2013-03-29 16: 16: 25Z
  3. @ DavidHogue Ciò vale solo quando si utilizza il metodo filter-branch. Gli ID commit dopo un commit modificato non cambiano se si utilizza il rebase interattivo.
    2013-07-06 19: 08: 37Z
  4. @ Mark Sì, lo fanno, sono obbligatori. Gli ID di commit dipendono dai commit precedenti. Se non fossero cambiati, git sarebbe stato inutile.
    2014-01-11 04: 45: 27Z
  5. Hai bisogno di $flawed_commit^..HEAD, non di $flawed_commit..HEAD. come indicato dalla pagina man: « Il comando riscriverà solo i ref positivi menzionati nella riga di comando (ad esempio se passi a..b, solo b verrà riscritto). »
    2014-07-29 11: 18: 49Z

Preferisco in questo modo.

 
git commit --amend -c <commit ID>

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

    
311
2013-01-10 14: 23: 28Z
  1. Per me, usare il comando precedente crea effettivamente un nuovo commit con un nuovo ID commit più un commit extra che dice "unire branch" come messaggio di commit predefinito.
    2013-03-29 16: 27: 38Z
  2. Modificando always crea un nuovo commit con un nuovo commit ID. L'ID commit è l'hash SHA dei contenuti del commit, inclusi il messaggio di commit e i timestamp scritti /impegnati. Questa è una caratteristica di Git che, escludendo le collisioni hash, garantisce che due commit con lo stesso ID siano esattamente lo stesso commit, con esattamente lo stesso contenuto, la stessa storia e così via.
    2013-06-19 09: 30: 11Z
  3. Accetto con Emil. Inoltre, leggendo i documenti - sembra che tutto ciò che "-c" fa è dire a git quale messaggio di commit usare come default /template per il tuo nuovo commit .. Realmente già farà "-c < commit ID >" per impostazione predefinita, quindi non è necessario specificarlo.
    2013-09-29 19: 12: 37Z
  4. Il -c fa alcune cose. Utilizza il vecchio messaggio per impostazione predefinita, ma copia anche le informazioni sull'autore (persona e ora). -C fa la stessa cosa tranne che non ti chiede di modificare il messaggio.
    2014-12-28 02: 55: 53Z
  5. Come @SantanuDey, non ha funzionato per me. Ho ottenuto fatal: Option -m cannot be combined with -c/-C/-F/--fixup.
    2015-04-14 05: 22: 17Z

Se si utilizza lo strumento Git GUI, esiste un pulsante denominato modifica ultimo commit. Clicca su quel pulsante e poi mostrerà i tuoi ultimi file e messaggi di commit. Modifica quel messaggio e puoi impegnarlo con un nuovo messaggio di commit.

O usa questo comando da una console /terminale:

 
git commit -a --amend -m "My new commit message"
    
310
2017-02-26 16: 48: 31Z
  1. Questa risposta è letteralmente identica a questo quello vecchio . Hai controllato le risposte esistenti prima di fornirne un altro?
    2019-05-02 01: 15: 38Z

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

 
$ git rebase bbc643cd^ --interactive

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

 
$ git add <filepattern>

Ora puoi usare

 
$ git commit --amend

per modificare il commit e dopo

 
$ git rebase --continue

per tornare al commit della testa precedente.

    
283
2013-03-16 09: 39: 44Z
  1. Se vuoi assicurarti che la tua modifica da git commit --amend abbia effetto, puoi usare git show e mostrerà il nuovo messaggio.
    2013-02-19 20: 12: 44Z
  1. Se vuoi solo modificare il tuo ultimo messaggio di commit, allora esegui:

     
    git commit --amend
    

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

  2. Se vuoi cambiare gli ultimi 3 messaggi di commit, o uno qualsiasi dei messaggi di commit fino a quel punto, fornire HEAD~3 al comando git rebase -i:

     
    git rebase -i HEAD~3
    
276
2014-05-21 02: 38: 25Z
  1. Questa precedente risposta dice già che è possibile utilizzare git commit --amend, e dice anche che puoi usare git rebase -i HEAD~commit_count, tutto ciò che hai fatto è stato collegare 3 per commit_count.
    2014-07-23 12: 21: 05Z
  2. Downvoted pure. Le persone semplicemente non si preoccupano di leggere le risposte esistenti .
    2019-05-02 01: 16: 22Z

    Se devi modificare un vecchio messaggio di commit su più rami (ad esempio, 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 inoltre eseguirà il backup dei vecchi riferimenti in refs/original/.

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

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

    • --all si assicurerà che tutti i rami e tag vengano riscritti.

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

    Di ', vuoi recuperare il tuo master e accedervi nel ramo old_master:

     
    git checkout -b old_master refs/original/refs/heads/master
    
        
    259
    2014-05-21 02: 39: 54Z
    1. Questa risposta non affronta la domanda dell'OP, dato che sono puramente interessati a correggere un commit che hanno appena fatto. Uso regolarmente il git commit --amend per correggere commenti o aggiungere file che ho dimenticato di usare git add, ma solo mai prima di avere git push ed. Io uso anche il git filter-branch quando voglio rovinare totalmente la cronologia delle versioni, ma l'OP non lo vuole, quindi questa risposta ha bisogno di un grande avvertimento di salute - non provarlo a casa, fa capolino !!
      2013-06-29 03: 17: 38Z

    Usa

     
    git commit --amend
    

    Per capirlo in dettaglio, un post eccellente è 4. Riscrivi la cronologia Git . Parla anche di quando non si usa git commit --amend.

        
    223
    2018-05-22 19: 46: 06Z
    1. Esiste un buon modo per correggere i messaggi di commit già inseriti in un repository pubblico? Finora sono giunto alla conclusione che, una volta spinti, i miei errori di battitura e il loro messaggio devono vivere per sempre.
      2013-06-04 11: 32: 34Z
    2. In una parola, NOPE! Non c'è un buon modo per ritrattare qualcosa che hai spinto. Tutte le retrazioni sono BAD in misura maggiore o minore. È necessario adottare la disciplina di lavorare in un ramo nel proprio repository privato, eseguire più commit mentre si aggiunge un po ', si verifica un po', si modifica un po '. Quindi unisci l'intero ramo in un singolo commit, scrivi un nuovo messaggio di commit che descrive la modifica generale, PROOFREAD e premi.
      2013-06-29 03: 29: 44Z
    3. Solo per evidenziare l'ovvio che non è necessario eseguire un singolo commit quando si torna da un ramo di funzione. Quello che molte persone fanno è rebase sul ramo di destinazione (per rendere le cose pulite) quindi unire con l'opzione per sopprimere l'inoltro veloce. D'accordo con il punto principale di fare attenzione prima di spingere verso l'alto però.
      2013-09-11 18: 20: 34Z
    4. La risposta git commit --amend era già stata data (più volte) prima di scrivere la tua. Perché l'hai postato di nuovo? Se si desidera aggiungere un collegamento a "Riscrivere la cronologia di Git", è possibile aver modificato una delle risposte esistenti o lasciato un commento.
      2019-05-02 01: 17: 45Z

    Modificare

    Hai un paio di opzioni qui. Puoi fare

     
    git commit --amend
    

    finché è 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 devi semplicemente aggiungere la modifica a quel commit. Quando arriva, fai un git commit --amend e modifica il messaggio di commit. Se vuoi eseguire il rollback prima di quel punto di commit puoi anche usare git reflog e cancellare quel commit. Quindi fai di nuovo un git commit.

        
    195
    2014-07-19 23: 45: 05Z

    Se stai usando la GUI di Git, puoi modificare l'ultimo commit che non è stato inserito con:

     
    Commit/Amend Last Commit
    
        
    183
    2013-03-16 09: 37: 26Z

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

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

    (usando il flag -o (--only) per essere sicuro di cambiare solo il messaggio di commit)


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

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

    Trova il commit desiderato, modifica da pick a r (reword), quindi salva e chiudi il file. Fatto!


    Tutorial di miniature vim (o, come rebase con solo 8 tasti 3j cw r Esc ZZ ) :

    • Esegui vimtutor se hai tempo
    • h j k l corrisponde ai tasti di spostamento
    • Tutti i comandi possono essere preceduti da un "intervallo", ad es. 3j si sposta verso il basso di 3 righe
    • i per accedere alla modalità di inserimento - text che digiti apparirà nel file
    • Esc o Ctrl c per uscire dalla modalità di inserimento e tornare alla modalità "normale"
    • u per annullare
    • Ctrl r per rifare
    • dd , dw , dl per eliminare una riga, una parola o una lettera, rispettivamente
    • cc , cw , cl per cambiare una riga, una parola o una lettera, rispettivamente (come dd i )
    • yy , yw , yl per copiare ("yank") una riga, una parola o una lettera, rispettivamente
    • p o P da incollare dopo, o prima della posizione corrente, rispettivamente
    • :w Invio per salvare (scrivere) un file
    • :q! Invio per uscire senza salvare
    • :wq Invio o ZZ per salvare ed uscire

    Se modifichi molto il testo, passa al layout di tastiera di Dvorak, impara a digitare il tipo di tocco e impara a vim. Vale la pena? Sì.


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

     
    $ git reset @~3   # go back 3 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
    

    * Attenzione però per opzioni come --hard e --force - possono scartare i dati.
    * Inoltre, non riscrivere la cronologia su tutti i rami su cui stai collaborando.

        
    173
    2015-04-29 15: 50: 45Z
    1. La parte vim è completamente fuori tema e invece di incoraggiare gli utenti a dedicare del tempo ad imparare ad usare un editor arcano, perché non insegnare loro qualcosa di più in tema, come come impostare l'editor git predefinito per essere qualcosa di user friendly, come nano? Stiamo parlando di modifiche banali che devono essere apportate a un file di testo, non a una codifica hardcore che genererebbe una guerra di fuoco per il "migliore" editor di testo.
      2019-05-02 01: 19: 53Z
    2. @ DanDascalescu: Perché è più veloce imparare Vim usando le istruzioni sopra riportate che eseguire diversi rebasi usando nano. L'intero motivo per cui Git apre un editor di testo e non la sua interfaccia per il rebasing è perché Vim esiste: è leggero, installato di default sulla maggior parte dei sistemi e molto facile da imparare quanto basta per eseguire un rebase con facilità: ad es. ddjjpZZ sposta un commit 2 verso il basso. Non c'è niente di arcano nella conoscenza di base di Vim; ci vogliono 10 minuti per diventare più a tuo agio con Vim che con nano.
      2019-05-02 22: 07: 53Z

    Uso la Git GUI il più possibile, e questo ti dà la possibilità di modificare l'ultima commit:

    Spunta quella casella

    Inoltre, git rebase -i origin/master è un bel mantra che ti presenterà sempre i commit che hai fatto sopra il master e ti darà la possibilità di modificare, eliminare, riordinare o schiacciare. Non è necessario prima impossessarsi di questo hash.

        
    165
    2014-05-21 02: 44: 35Z
    1. Come si arriva a quella schermata che hai visualizzato nell'esempio?
      2014-06-24 20: 01: 47Z
    2. È la parte in basso a destra di Windows Git Gui. Basta selezionare il commutatore "Amend Last Commit" e verrà compilato con le informazioni di commit più recenti.
      2016-01-29 16: 51: 33Z

    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 di fare un cambiamento.

    Ricorda per specificare --soft anziché --hard, altrimenti perdi il commit interamente.

        
    135
    2014-07-20 08: 21: 55Z
    1. Questo fa esattamente la stessa cosa di git commit --amend tranne che è un processo in 2 fasi.
      2014-12-28 02: 58: 00Z
    2. @ JosephK.Strauss Credo che ammettere il commit mantenga anche le informazioni originali dell'autore del commit e della data, con le nuove informazioni sul committer e sulla data separatamente. Non sono sicuro che questo approccio lo faccia.
      2016-05-07 23: 13: 23Z
    3. @ EvertonAgner Hai ragione. --amend manterrà le informazioni dell'autore, ma la domanda chiede solo di cambiare il messaggio.
      2016-05-09 13: 59: 34Z

    Per chiunque cerchi una GUI Windows /Mac per aiutare a modificare i vecchi messaggi (cioè non solo l'ultimo messaggio), ti consiglio SourceTree . I passi da seguire sono di seguito.

    SourceTree rebase interattivo ​​

    per commit che non sono stati ancora inviati a un telecomando:

    1. Assicurati di aver impegnato o nascosto tutte le modifiche correnti (ovvero non ci sono file elencati nella scheda "Stato file") - altrimenti non funzionerà.
    2. Nella scheda "Registro /Cronologia", fai clic destro sulla voce con una linea adiacente nel grafico uno sotto il commit (s) che si desidera modificare e selezionare "Rebase child of < commit ref > in modo interattivo ... "
    3. Seleziona l'intera riga per un messaggio di commit che desideri modificare ( quindi fai clic sulla colonna "Messaggio" ).
    4. Fai clic sul pulsante "Modifica messaggio".
    5. Modifica il messaggio come desiderato nella finestra di dialogo visualizzata, quindi fai clic su OK.
    6. Ripeti i passaggi 3-4 se ci sono altri messaggi di commit da modificare.
    7. Fai clic su OK: inizierà il rebasing. Se tutto va bene, l'output terminerà "Completato con successo". NOTA: di recente ho notato che non funziona con Unable to create 'project_path/.git/index.lock': File exists. quando provo a modificare più messaggi di commit contemporaneamente. Non sei sicuro di quale sia il problema, o se verrà risolto in una versione futura di SourceTree, ma se ciò dovesse accadere ti consigliamo di ridistribuirli uno alla volta (più lentamente ma sembra più affidabile).

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

    Segui i passaggi in questa risposta , che sono simili a sopra ma richiedono un ulteriore comando da eseguire dal comando line to force-push the branch - leggi tutto e applica la necessaria cautela!

        
    126
    2019-06-17 13: 20: 56Z

    Se vuoi solo modificare l'ultimo commit usa:

     
    git commit --amend
    

    o

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

    Ma se vuoi modificare più commit in una riga, dovresti usare invece la ridefinizione:

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

    modifica di git rebase

    In un file come quello sopra scrivi edit /e o una delle altre opzioni e premi Salva ed esci.

    Ora sarai al primo commit sbagliato. Apporta modifiche ai file e verranno automaticamente organizzati per te. Tipo

     
    git commit --amend
    

    salva e esci e digita ​​p>  

    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.

        
    124
    2014-07-19 17: 42: 48Z
    1. git rebase -i < hash di un commit prima del commit errato > per me va bene. grazie.
      2018-04-13 00: 57: 11Z

    Se vuoi solo cambiare il tuo ultimo messaggio dovresti usare il flag --only o la sua scorciatoia -o con commit --amend:

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

    Ciò garantisce che non aumenti accidentalmente il tuo commit con oggetti in scena. Ovviamente è meglio avere una corretta configurazione $EDITOR. Quindi puoi lasciare l'opzione -m e git pre-riempirà il messaggio di commit con quello vecchio. In questo modo può essere facilmente modificato.

        
    123
    2015-03-13 10: 38: 50Z
    1. La risposta "top" non risponde alla domanda. Fornisce solo un'introduzione generale a git commit --amend. La domanda era molto specifica, quindi più lunga! = Meglio. La menzione decisiva della bandiera -o sarebbe probabilmente sepolta nel resto delle informazioni. Inoltre, non mi sento a mio agio nel modificare una risposta che ha già tanti voti.
      2014-07-20 20: 51: 26Z
    2. Detto questo, sei libero di modificare la risposta in alto, dal momento che esiste il pericolo reale che le persone lo usino come risposta "corretta". Può facilmente accadere di emendare il tuo commit con materiale in scena - è successo a me, ed è davvero fastidioso quando ti capita di spingerlo. Ma ancora, la quantità non è garanzia di correttezza. Né sul numero di risposte né sul numero di voti.
      2014-07-20 20: 51: 54Z
    3. Non vorrei andare così lontano per dire che la risposta migliore è "errato" e "non risponde alla domanda". Funziona sicuramente e risponde alla domanda, devi solo assicurarti di non avere modifiche graduali quando provi a modificare. Ma vedo il tuo punto sul fatto di dover avvisare la gente di questo. Lo modificherò più tardi se avrò tempo.
      2014-07-21 21: 26: 20Z
    4. Per essere onesti: anche se l'opzione --only con --amend è disponibile dal git 1.3.0 non ha funzionato correttamente finché non è stato corretto in 1.7.11.3 ( ea2d4ed35902ce15959965ab86d80527731a177c ). Quindi la risposta giusta nel 2008 sarebbe stata probabilmente qualcosa come: git stash; git commit --amend; git stash pop.
      2014-07-21 23: 00: 48Z

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

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

    Oppure prova a ripristinare Git 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.
    

    Uso del ripristino per suddividere i commit in commit più piccoli

    git reset può aiutarti a rompere un commit 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 seperately 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 interrotto correttamente l'ultimo commit in due commit.

        
    99
    2014-07-22 06: 24: 54Z
    1. Se tutto quello che vuoi fare è modificare il messaggio del tuo ultimo commit, utilizzando un soft reset a tale scopo è over-kill . Utilizza git commit --amend, esattamente come dice in la risposta più votata . Inoltre, git reset --soft HEAD^ funziona in modo identico alla reimpostazione a caldo in questa risposta precedente , in quanto entrambe resettano al primo commit genitore.
      2014-07-21 23: 15: 47Z
    2. Mi preoccupo solo di aggiungere git reset nella soluzione solo per dare un'idea di dividere un messaggio di commit in più messaggi di commit. Perché, ho affrontato quel problema quando, stavo iniziando a usare git. A volte, questo può essere davvero utile. :)
      2014-07-22 06: 29: 00Z

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

    Volevo cambiare i miei cinque ultimi commit che ho già inviato al server. Questo è abbastanza "pericoloso" perché se qualcun altro ha già tirato fuori da questo puoi rovinare tutto cambiando i messaggi di commit. Tuttavia, quando lavori sul tuo piccolo ramo e sei sicuro che nessuno l'ha estratto, puoi modificarlo in questo modo:

    Diciamo che vuoi cambiare i tuoi cinque ultimi commit, quindi scrivi questo nel terminale:

    git rebase -i HEAD~5 * Dove 5 è il numero di messaggi di commit che si desidera modificare. (quindi se vuoi cambiare il decimo per ultimo ti impegni a digitare 10)

    Questo comando ti porterà in VIM, dove puoi "modificare" la tua cronologia dei commit. Vedrai i tuoi ultimi 5 commit in alto in questo modo:

    pick <commit hash> commit message

    Invece di pick devi scrivere reword. Puoi farlo in VIM digitando i, che ti fa entrare in modalità INSERT. (Vedi che sei in modalità inserimento dalla parola INSERT in basso) Per i commit che vuoi cambiare scrivi reword invece di pick

    Quindi devi salvare e uscire da questa schermata, lo fai prima andando in 'modalità comando' premendo il pulsante esc. (puoi verificare di essere in modalità di comando se la parola INSERT in basso è scomparsa) Quindi puoi digitare un comando digitando :, il comando per salvare e uscire è wq. Quindi se digiti :wq sei sulla buona strada.

    Quindi VIM passerà sopra ogni messaggio di commit che vuoi riformulare, qui puoi effettivamente cambiare i messaggi di commit. Lo farai andando in modalità INSERT, cambiando il messaggio di commit, andando in modalità comando e salvando e uscendo. Fai questo 5 volte e sei fuori da VIM!

    Quindi, se hai già eseguito il commit sbagliato, devi git push --force per sovrascriverli. Ricorda che git push --force è una cosa abbastanza pericolosa da fare, quindi assicurati che nessuno venga prelevato dal server da quando hai spinto i tuoi commit sbagliati!

    Ora hai cambiato i tuoi messaggi di commit!

    (Come vedi, io non sono così esperto in VIM, quindi se ho usato il "gergo" sbagliato per spiegare cosa sta succedendo, sentiti libero di correggermi!)

        
    82
    2014-08-19 04: 34: 23Z
    1. <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 nella modalità di inserimento (ha senso in un certo senso, giusto?). Se vuoi essere sempre in grado di eliminare i caratteri in Vim, lo faranno X e x (il piccolo x cancella i caratteri davanti al cursore, X si cancellerà dietro). Se si commettono errori, è possibile utilizzare ripetutamente u per annullare. Infine, r è abbreviazione di reword nell'editor di rebase interattivo.
      2014-08-07 17: 47: 10Z
    2. Per cambiare una parola in vim è scritto cw all'inizio (anche se la domanda non riguarda Vim, sono d'accordo).
      2015-12-05 06: 25: 59Z
    3. Non è necessario utilizzare quell'abominio . Puoi impostare il tuo editor git a qualcosa di sano e facile da usare, come il mcedit nano o Midnight Commander.
      2019-05-02 01: 28: 41Z

    Ho aggiunto l'alias reci, recm per recommit (amend), ora posso farlo con git recm o git recm -m.

     
    $ vim ~/.gitconfig
    
    [alias]
    
        ......
        cm = commit
        reci = commit --amend
        recm = commit --amend
        ......
    
        
    76
    2014-03-11 08: 21: 36Z

    Puoi utilizzare git-rebase-reword

    È progettato per modificare qualsiasi commit (non solo l'ultimo) come commit --amend

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

    Prende il nome dall'azione su rebase interactive per modificare un commit: "reword". Vedi questo post e uomo - modalità interattiva sezione -

    Esempi:

     
    $ git rebase-reword b68f560
    $ git rebase-reword HEAD^
    
        
    76
    2015-07-29 22: 28: 58Z
    1. Ciò richiede l'installazione di un programma esterno. A mio parere, sarebbe meglio imparare a utilizzare gli strumenti e gli alias integrati in modo più efficace. Vorrei digitare: g c; g rb -i @~9 (commit e rebase), spostare il nuovo commit su dove lo voglio, cambiare da commit a f (fixup) e salvare. Se vuoi qualcosa di più veloce, potresti usare alias git commit --fixup=<commit>; git rebase -i --autosquash <commit>^
      2015-04-29 15: 25: 01Z
    2. github.com/qxo/git -rebase-reword sia per linux che per windows
      2016-10-29 10: 25: 14Z

    Mi sono reso conto che avevo inserito un commit con un errore di battitura al suo interno. Per annullare, ho fatto quanto segue:

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

    Avviso: la forzatura delle modifiche sovrascrive il ramo remoto con quello locale. Assicurati di non sovrascrivere nulla che vuoi mantenere. Inoltre, sii prudente nel forzare 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 appena riscritta.

        
    54
    2014-08-05 14: 44: 50Z
    1. 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 gli altri possono ancora trovarlo e farvi riferimento, ad esempio guardando nel reflog.)
      2014-09-04 23: 47: 35Z

    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>
    49
    2015-02-03 11: 08: 43Z

    Se non hai inserito il codice nel ramo remoto ( GitHub /Bitbucket ) puoi cambiare il messaggio di commit sulla riga di comando come sotto.

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

    Se stai lavorando su un ramo specifico fai questo:

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

    Se hai già inserito il codice con il messaggio sbagliato, e devi fare attenzione quando cambi il messaggio. Cioè, dopo aver cambiato il messaggio di commit e provato a spingerlo di nuovo, si finisce per avere problemi. Per renderlo scorrevole, segui questi passaggi.

    Leggi tutta la mia 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 usi direttamente il force push potresti finire con problemi di codice che altri sviluppatori stanno lavorando sullo stesso ramo. Per evitare tali conflitti, devi estrarre il codice dal ramo prima di eseguire il push forzato :

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

    Questa è la procedura migliore quando si modifica il messaggio di commit, se è già stato premuto.

        
    43
    2015-02-03 11: 14: 19Z
fonte posta Qui