Ho scritto la cosa sbagliata in un messaggio di commit.

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

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:

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

• Pagina di manuale git-commit (1)

• Pagina di manuale git-rebase (1)

• git-push (1) Pagina del manuale

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

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?

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

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"

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 ;-)

Preferisco così:

git commit --amend -c <commit ID>

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

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"

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

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

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

Uso

git commit --amend

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

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.

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.

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

Commit/Amend Last Commit

Uso la GUI di Git 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, eliminare, riordinare o schiacciare. Non è necessario prima acquisire l'hash.

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.

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

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>

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.

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.

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.

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!)

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^

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

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.

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>

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.