Come modificare i messaggi di commit esistenti e non inviati?

Question

Ho scritto la cosa sbagliata in un messaggio di commit.

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

Answer 1

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, puoi impostare il messaggio di commit direttamente nella riga di comando con:

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

& # 8230; tuttavia, ciò può rendere più complicato l'inserimento di messaggi di commit su più righe o piccole correzioni.

Assicurati di non aver apportato modifiche alla copia di lavoro messa in scena 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, allora è necessario forzare il push del 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 sulla filiale remota che non hai nella tua filiale locale, perderai tali commit.

Avvertenza: fai attenzione a modificare i commit che hai già condiviso con altre persone. La modifica impegna essenzialmente riscrive in modo che abbiano SHA ID, 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.

---

Usa rebase interattivo

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

Per fare una 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

Dopo aver annullato i commit, scegli e/r per modificare il messaggio

Nota importante sul rebase interattivo

Quando si utilizza git rebase -i HEAD~X possono esserci più di X commit. Git & Quot; raccoglierà & Quot; tutti i commit negli ultimi git rerere commit e se c'è stata una fusione da qualche parte tra quell'intervallo vedrai anche tutti i commit, quindi il risultato sarà X +.

Buon consiglio:

Se devi farlo per più di un singolo ramo e potresti riscontrare conflitti durante la modifica del contenuto, imposta <=> e lascia che git risolva automaticamente quei conflitti per te.

---

Documentazione

• git-commit (1) Manuale pagina

• git-rebase (1) Manuale pagina

• git-push (1) Manuale pagina

Answer 2

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

Answer 3

Se il commit che vuoi correggere non è & # 8217; t il più recente:

1. git rebase --interactive $parent_of_flawed_commit

   Se vuoi correggere diversi commit imperfetti, passa 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 tutti gli commit che vuoi correggere.
   2. Una volta salvato, Git riprodurrà i commit elencati.
      
      

3. Per ogni commit che vuoi riformulare , Git ti riporterà nel tuo editor. Per ogni commit che vuoi modificare , Git ti fa cadere nella shell. Se & # 8217; 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. & # 8217; è molto facile, non devi & # 8217; non è necessario memorizzarlo & # 8211; ricorda solo che git rebase --interactive ti 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 una filiale pubblicata?

Answer 4

Per modificare il commit precedente, apporta le modifiche desiderate e mettile in scena, quindi esegui

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. Modifica il messaggio di commit come desideri, quindi salva il file e termina 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 & # 8220; modifica & # 8221; invece di & # 8220; scegli & # 8221 ;, quindi salva ed esci dal tuo editor. Apporta la modifica che desideri impegnare ed esegui

git commit --amend
git rebase --continue

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

Answer 5

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

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

Answer 6

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 fusioni dopo il tuo errato messaggio di commit.

Nota che questo tenterà di riscrivere OGNI commit tra HEAD e il commit imperfetto, quindi dovresti scegliere il tuo msg-filter comando molto saggio ;-)

Answer 7

Preferisco così.

git commit --amend -c <commit ID>

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

Answer 8

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"

Answer 9

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

$ git rebase bbc643cd^ --interactive

Nell'editor predefinito, modifica 'pick' per 'edit' nella riga di cui desideri 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 successivamente

$ git rebase --continue

per tornare al precedente head commit.

Answer 10

1. Se vuoi solo modificare l'ultimo messaggio di commit, allora fai:

   git commit --amend
   

   Questo ti farà entrare 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 momento, fornire HEAD~3 al comando git rebase -i:

   git rebase -i HEAD~3
   

Answer 11

Se devi modificare 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 il backup dei vecchi riferimenti in refs/original/.

• -f imporrà l'esecuzione dell'operazione. Ciò è necessario se la directory temporanea è già presente o se sono già presenti 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 vecchi riferimenti, è possibile tornare facilmente allo stato prima di eseguire il comando.

Supponiamo che tu voglia recuperare il tuo master e accedervi nel ramo old_master:

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

Answer 12

Usa

git commit --amend

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

Answer 13

Modificare

Hai un paio di opzioni qui.Tu puoi fare

git commit --amend

purché sia ​​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 aggiungi semplicemente la modifica a quel commit.Quando appare, fai a git commit --amend e modificare il messaggio di commit.Se vuoi tornare indietro prima di quel punto di commit, puoi anche usare git reflog ed elimina semplicemente quel commit.Quindi fai semplicemente a git commit Ancora.

Answer 14

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

Commit/Amend Last Commit

Answer 15

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 desiderato, modifica pick in r (reword), salva e chiudi il file. Fatto!

---

Tutorial vim in miniatura (o come rifare con solo 8 sequenze di tasti 3jcwZZEsc vimtutor ):

• Esegui h se hai tempo
• jkli corrisponde ai tasti di movimento & # 8592; # 8595 &; # 8593 &; # 8594 &;
• Tutti i comandi possono essere preceduti da un " range " ;, ad es. c si sposta in basso di 3 righe
• u per accedere alla modalità di inserimento & # 8212; il testo digitato verrà visualizzato nel file
• Esc o Ctrldd per uscire dalla modalità di inserimento e tornare a " normale " modalità
• dw per annullare
• Ctrldl da ripetere
• cc , cl , yy per eliminare una riga, una parola o una lettera, rispettivamente
• yw , yl , p per modificare una riga, una parola o una lettera, rispettivamente (uguale a < kbd> P :w )
• :q! , :wq , --hard per copiare (" yank ") una riga, una parola o una lettera, rispettivamente
• --force o <=> per incollare dopo, o prima della posizione corrente, rispettivamente
• <=> Inserisci per salvare (scrivere) un file
• <=> Inserisci per uscire senza salvare
• <=> Inserisci o <=> per salvare ed uscire

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

---

ProTip & # 8482 ;: & nbsp; Non abbiate paura di sperimentare & Quot; pericoloso & Quot; comandi che riscrivono la cronologia * & # 8212; 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

* Fai attenzione a opzioni come <=> e <=> sebbene & # 8212; possono scartare i dati.
* Inoltre, non riscrivere la cronologia su nessun ramo su cui stai collaborando.

Answer 16

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

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, cancellare, riordinare o schiacciare. Non è necessario prima acquisire l'hash.

Answer 17

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 --soft anziché --hard, altrimenti perderai completamente il commit.

Answer 18

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.

Per 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 (ovvero, quindi non ci sono file elencati nella scheda " Stato file "); altrimenti non funzionerà.
2. Nel " Registro / Cronologia " scheda, 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 " Sostituisci i figli di < commit ref > in modo interattivo ... "
3. Seleziona l'intera riga per un messaggio di commit che desideri modificare ( ovvero fai clic sulla " Messaggio " colonna ).
4. Fai clic sul " Modifica messaggio " pulsante.
5. Modifica il messaggio come desiderato nella finestra di dialogo che viene 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 rifacimento. Se tutto va bene, l'output terminerà & Quot; Completato correttamente & Quot ;. NOTA : Di recente l'ho visto fallire con Unable to create 'project_path/.git/index.lock': File exists. quando ho provato a 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 inviati:

Segui i passaggi in questa risposta , che sono simili a quelli precedenti ma richiedono un ulteriore comando da eseguire dal comando linea per forzare la spinta del ramo - leggi tutto e applica le precauzioni necessarie!

Answer 19

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 invece usare la rebasing:

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

In un file come quello sopra scrivi modifica / 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. Tipo

git rebase --continue 

salva e chiudi questo e digita

<*>

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.

Answer 20

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

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

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

Answer 21

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.

Utilizzo di reset per suddividere i commit in commit minori

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 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 con successo il tuo ultimo commit in due commit.

Answer 22

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 l'ho fatto soprattutto per le persone che non hanno esperienza in VIM!

Volevo cambiare 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 & # 8217; stai lavorando sul tuo piccolo ramo e sei sicuro che nessuno lo abbia estratto, puoi cambiarlo in questo modo:

Supponiamo che tu voglia modificare i tuoi ultimi cinque commit, quindi digita 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 dove puoi & # 8216; modifica & # 8217; la tua cronologia di commit. & # 8217; 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 porta in modalità INSERT. (Vedi che & # 8217; sei in modalità di inserimento dalla parola INSERT in fondo) Per i commit che vuoi cambiare digita : invece di wq

Quindi devi salvare ed uscire da questa schermata, per prima cosa accedi a & # 8216; modalità-comando & # 8217; premendo il pulsante esc. (puoi verificare che & # 8217; sei in modalità comando se la parola INSERT in fondo è scomparsa) Quindi puoi digitare un comando digitando :wq, il comando per salvare ed uscire è git push --force . Quindi, se digiti <=> tu & # 8217; procedi nel modo giusto.

Quindi VIM esaminerà tutti i messaggi di commit che desideri riformulare, qui puoi effettivamente cambiare i messaggi di commit. Tu & # 8217; lo farai andando in modalità INSERT, cambiando il messaggio di commit, andando in modalità di comando e salvando ed esci. Fallo 5 volte e & # 8217; sei fuori da VIM!

Quindi, se hai già spinto i tuoi commit sbagliati, devi <=> per sovrascriverli. Ricorda che <=> è 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 'lingo' sbagliato per spiegare cosa sta succedendo, sentiti libero di correggermi!)

Answer 23

Ho aggiunto l'alias di 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
    ......

Answer 24

Puoi utilizzare 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 interattivo per modificare un commit: " reword " ;. Vedi questo post e man -section modalità interattiva-

Esempi:

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

Answer 25

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

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

Avviso: la forzatura della 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.

Answer 26

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>

Answer 27

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, esegui questa operazione:

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 verificano problemi. Per semplificare, segui questi passaggi.

Per favore leggi 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 con cui altri sviluppatori stanno lavorando sullo stesso ramo. Quindi, per evitare quei conflitti, devi estrarre il codice dalla tua filiale prima di fare forzare la spinta :

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

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