it-swarm.it

Come modificare i messaggi di commit esistenti non premuti?

Ho scritto la cosa sbagliata in un messaggio di commit.

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

7673
Laurie Young

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, è possibile 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 aver modificato la copia di lavoro staged prima di farlo, altrimenti si impegneranno anch'essi. (Le modifiche non programmate non verranno eseguite.)

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

Se hai già trasferito il tuo commit sulla tua diramazione remota, dovrai dover forzare Spingi il commit con:

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

Attenzione: 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, you will perde quei commit.

Attenzione: sii cauto nel modificare i commit che hai già condiviso con altre persone. L'emendamento impegna essenzialmente riscrive per avere ID _ sha diversi, il 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.


Usa rebase interattivo

Un'altra opzione è usare rebase interattivo.
Ciò consente di modificare qualsiasi messaggio che si desidera 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 schiacciati i tuoi commit, scegli e/r per modificare il messaggio

enter image description here

Nota importante su rebase interattivo

Quando usi git rebase -i HEAD~X può esserci più rispetto a X commit. Git "raccoglierà" tutti i commit negli ultimi commit di X e se c'è stata un'unione da qualche parte tra quell'intervallo vedrai anche tutti i commit così il risultato sarà X +.

Bel consiglio:

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.


Documentazione

15296
EfForEffort
git commit --amend -m "your new message"
2458
lfx_cool

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

  1. git rebase --interactive $parent_of_flawed_commit

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

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

    1. Cambia pick in reword (o nelle vecchie versioni di Git, in edit) davanti a qualsiasi commit che vuoi correggere.
    2. Una volta salvato, Git ripeterà i commit elencati.

  3. Per ogni commit che vuoi reword , Git ti ricondurrà 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 git rebase --interactive ti consente di correggere i commit non importa quanto tempo fa fossero.


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 si ripristina/risincronizza dopo che qualcuno ha premuto un rebase o un reset su un ramo pubblicato?

2330

Per modificare il commit precedente, apportare le modifiche desiderate e metterle in atto e 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 si desidera modificare più di un messaggio di commit, eseguire

git rebase -i HEAD~commit_count

(Sostituire cOMMIT_COUNT con il numero di commit che si desidera 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 vuoi commettere e quindi esegui

git commit --amend
git rebase --continue

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

762
Fatih

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

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

Puoi anche usare git filter-branch per quello.

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

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

Nota che questo proverà a riscrivere OGNI commit tra HEAD e il commit errato, quindi dovresti scegliere il comando msg-filter molto saggio ;-)

352
Mark

Preferisco in questo modo.

git commit --amend -c <commit ID>

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

312
krevedko

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. 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"
310
Akhilraj N S

Puoi usare 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 comando precedente.

282
Shoaib Ud-Din
  1. Se vuoi solo modificare il tuo ultimo messaggio di commit, allora fai:

    git commit --amend
    

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

  2. Se si desidera modificare 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
    
275
Heena Hussain

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. Questo è necessario se la directory temporanea è già presente o se ci sono già riferimenti memorizzati sotto refs/original. In caso contrario, puoi eliminare questo flag.

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

  • --all si assicurerà che tutti i rami branches evengano 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
258
sebers

Uso

git commit --amend

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

221
skin

Emendare

Hai un paio di opzioni qui. Tu puoi fare

git commit --amend

finché è il tuo ultimo impegno.

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 è sufficiente aggiungere la modifica a quel commit. Quando appare fare un git commit --amend e modificare 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
wallerjake

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

Commit/Amend Last Commit
183
gulchrider

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 si tratta di 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, cambia pick in r (reword), e salva e chiudi il file. Fatto!



Tutorial di miniature vim (o, come rebase con solo 8 sequenze di tasti 3jcwrEscZZ):

  • Esegui vimtutor se hai tempo
  • hjkl corrispondono ai tasti di movimento 
  • Tutti i comandi possono essere preceduti da un "intervallo", ad es. 3j si sposta verso il basso di 3 righe
  • i per inserire la 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 annullare
  • Ctrlr da rifare
  • dddwdl per eliminare una riga, parola o lettera, rispettivamente
  • cccwcl per cambiare una riga, parola o lettera, rispettivamente (come ddi)
  • yyywyl per copiare ("yank") una riga, una parola o una lettera, rispettivamente
  • p o P per incollare dopo, o prima della posizione corrente, rispettivamente
  • :wEnter per salvare (scrivere) un file
  • :q!Enter per uscire senza salvare
  • :wqEnter o ZZ per salvare e 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 [email protected]{0}: reset: moving to @~3
2c52489 [email protected]{1}: commit: more changes
4a5246d [email protected]{2}: commit: make important changes
e8571e4 [email protected]{3}: commit: make some changes
... earlier commits ...
$ git reset 2c52489
... and you're back where you started

* Attenzione per opzioni come --hard e --force sebbene - possano scartare i dati.
* Inoltre, non riscrivere la cronologia su nessun ramo su cui stai collaborando.

172
Zaz

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

Tick that box

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 procurarsi prima quell'hash.

165
Havard Graff

Wow, quindi ci sono molti modi per farlo.

Un altro modo per farlo è cancellare 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 dovrebbe assomigliare 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 una modifica.

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

135
Radu Murzea

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

SourceTree interactive rebase

Per i commit che non sono ancora stati 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 > interattivamente ... "
  3. Seleziona l'intera riga per il messaggio di commit che desideri modificare (ad esempio, fai clic sulla colonna "Messaggio").
  4. Fai clic sul pulsante "Modifica messaggio".
  5. Modificare il messaggio come desiderato nella finestra di dialogo che appare e quindi fare clic su OK.
  6. Ripeti i passaggi 3-4 se ci sono altri messaggi di commit da modificare.
  7. Fare clic su OK: inizierà il rebasing. Se tutto va bene, l'output terminerà "Completato con successo".

... 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 dalla riga di comando per forzare-Spingi il ramo - leggi tutto e applica la necessaria cautela!

125
Steve Chambers

Se desideri solo modificare l'ultimo utilizzo di commit:

git commit --amend

o

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

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

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

git rebase editing

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

git commit --amend

salva e esci e digita

git rebase --continue 

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

Nota che queste cose cambiano tutte le tue SHA hash dopo quel particolare commit.

124

Se vuoi solo cambiare il tuo ultimo messaggio dovresti usare il flag --only o il suo collegamento -o con commit --amend:

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

Ciò garantisce che non aumenti accidentalmente il tuo commit con contenuti 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
David Ongaro

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

Usando il reset per dividere 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 rotto con successo il tuo ultimo commit in due commit.

99
przbadu

Su questa domanda ci sono molte risposte, ma nessuna di queste spiega in modo super dettagliato come cambiare 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à spinto 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 lo ha tirato puoi cambiarlo 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 lì puoi 'modificare' la cronologia dei commit. Vedrai i tuoi ultimi 5 commit in alto in questo modo:

pick <commit hash> commit message

Invece di pick è necessario scrivere reword. Puoi farlo in VIM digitando i, che ti fa entrare in modalità INSERT. (Si vede che si è in modalità di inserimento da parte di Word INSERT in basso) Per i commit che si desidera modificare digitare reword anziché pick

Quindi devi salvare e uscire da questa schermata, lo fai prima andando in 'modalità comando' premendo il tasto esc. (puoi verificare di essere in modalità di comando se il Word INSERT in fondo è scomparso) 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à inserito commit errati, è necessario git Push --force per sovrascriverli. Ricorda che git Push --force è una cosa abbastanza pericolosa da fare, quindi assicurati che nessuno abbia tirato fuori 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
Marijn

Puoi usare git-rebase-reword

È progettato per modificare qualsiasi commit (non solo l'ultimo) allo stesso modo di 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 man - sezione modalità interattiva-

Esempi:

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

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

$ vim ~/.gitconfig

[alias]

    ......
    cm = commit
    reci = commit --amend
    recm = commit --amend
    ......
76
Chu-Siang Lai

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

Attenzione: forza forzando le modifiche sovrascrive il ramo remoto con quello locale. Assicurati di non sovrascrivere nulla che vuoi mantenere. Inoltre, sii cauto 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 che hai appena riscritto.

54
neoneye

Mi piace usare il seguente:

  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
Kedar Adhikari

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

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 usi la forza Spingi direttamente potresti finire con problemi di codice che altri sviluppatori stanno lavorando sullo stesso ramo. Per evitare tali conflitti, è necessario estrarre il codice dal ramo prima di eseguire force Push :

 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
Prabhakar