Come modificare i commit esistenti, non spinti?

Ho scritto la cosa sbagliata in un messaggio di commit. In alternativa, ho dimenticato di includere alcuni file.

Come posso cambiare il messaggio / i file di commit? Il commit non è stato ancora spinto.

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, è ansible 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 le modifiche di copia di lavoro prima di farlo, altrimenti si impegneranno anche tu. (Le modifiche non applicate non verranno commesse).

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 forzare l’invio del commit con:

 git push   --force # Or git push   -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 nella tua filiale locale, perderai quei commit.

Avvertenza: sii cauto nel modificare i commit che hai già condiviso con altre persone. La modifica dei commit essenzialmente li 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 l’ e/r per modificare il messaggio

inserisci la descrizione dell'immagine qui

Nota importante su rebase interattivo

Quando usi git rebase -i HEAD~X possono esserci più di X commit. Git “raccoglierà” tutti i commit degli ultimi X commit e se c’è stata un’unione da qualche parte tra quel range vedrai anche tutti i commit così il risultato sarà X +.

Bel consiglio:

Se devi farlo per più di un singolo ramo e potresti git rerere affrontare dei conflitti quando modifichi il contenuto, configura git rerere e lascia che git rerere risolva automaticamente tali conflitti.


Documentazione

  • git-commit (1) Pagina manuale

  • git-rebase (1) Pagina manuale

  • git-push (1) Pagina manuale

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

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. Arriverà 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 riformulare , Git ti riporterà nel tuo editor. Per ogni commit che vuoi modificare , 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 faccio a ripristinare / risincronizzare dopo che qualcuno ha premuto un rebase o un reset su un ramo pubblicato?

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 

(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 vuoi impegnare e poi esegui

 git commit --amend git rebase --continue 

Nota: puoi “Apportare la modifica che desideri” anche dall’editor aperto da git commit --amend

Come già accennato, git commit --amend è il modo per 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 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.

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

Preferisco così.

 git commit --amend -c  

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

Se si utilizza lo strumento Git GUI, è disponibile un pulsante denominato modify last commit. Clicca su quel bottone 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" 

Puoi utilizzare il rebasing di Git . Ad esempio, se si desidera modificare di nuovo 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  

Ora puoi usare

 $ git commit --amend 

per modificare il commit e dopo

 $ git rebase --continue 

per tornare al comando precedente.

  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 

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///g"' -- --all 

Git creerà una directory temporanea per la riscrittura 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 in refs/original . In caso contrario, puoi eliminare questo flag.

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

  • --all ci assicureremo che tutti i rami e i tag vengano riscritti.

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

Dì, vuoi recuperare il tuo padrone 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 la storia di Git . Parla anche di quando non usare git commit --amend .

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

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

 Commit/Amend Last Commit 

Se è il tuo ultimo commit, modifica il commit:

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

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

Se è un commit sepolto, usa l’incredibile rebase interattivo :

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

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


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

  • Esegui vimtutor se hai tempo
  • h j k l corrispondono ai tasti di movimento
  • Tutti i comandi possono essere preceduti da un “intervallo”, ad es. 3j sposta su 3 linee
  • per entrare nella modalità di inserimento – il testo digitato verrà visualizzato nel file
  • Esc o Ctrl c per uscire dalla modalità di inserimento e tornare alla modalità “normale”
  • u devi annullare
  • Ctrl r per ripetere
  • 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 per incollare, rispettivamente, o prima della posizione corrente, rispettivamente
  • :w Invio per salvare (scrivere) un file
  • :q! Invio per uscire senza salvare
  • :wq Enter o ZZ per salvare e uscire

Se modifichi molto il testo, passa al layout della tastiera di Dvorak, impara a digitare il tipo e impara a vim. Vale la pena lo sforzo? 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 opzioni come --hard e --force però – possono scartare i dati.
* Inoltre, non riscrivere la cronologia su alcun ramo su cui stai collaborando.

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

Tick that box

Inoltre, git rebase -i origin/master è un simpatico mantra che ti presenterà sempre i commit che hai eseguito in cima al master e ti darà la possibilità di modificare, eliminare, riordinare o schiacciare. Non è necessario procurarsi prima quell’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 ansible 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 una modifica.

Ricordati di specificare --soft invece di --hard , altrimenti perdi il commit interamente.

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 il rebasing:

 git rebase -i  

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 nei 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 con tutte le selezioni.

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

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

Rebase interattivo di SourceTree

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 in modo interattivo …”
  3. Seleziona l’intera riga per il messaggio di commit che desideri modificare (ad es . 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 cambiare.
  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 spinti:

Segui i passaggi di questa risposta , che sono simili a quelli precedenti ma richiedono un ulteriore comando da eseguire dalla riga di comando per forzare il ramo – leggere tutto e applicare la necessaria caucanvas!

Se vuoi solo cambiare il tuo ultimo messaggio dovresti usare l’ --only flag 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 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.

Aggiorna l’ultimo messaggio di commit errato con un nuovo messaggio di commit in un’unica 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: eg 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.

Su questa domanda ci sono molte risposte ma nessuna di esse 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, dove puoi “modificare” la tua cronologia dei commit. Vedrai i tuoi ultimi 5 commit in alto in questo modo:

pick commit message

Invece di pick è necessario scrivere una reword . Puoi farlo in VIM digitando i , che ti fa entrare in modalità INSERT. (Vedi che sei in modalità inserimento con la parola INSERISCI in basso) Per i commit che vuoi cambiare scrivi in reword invece di 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 la parola INSERISCI 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à spinto i tuoi commit errati, devi 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!)

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

 $ vim ~/.gitconfig [alias] ...... cm = commit reci = commit --amend recm = commit --amend ...... 

Puoi usare git-rebase-reword

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

 $ git rebase-reword  

Prende il nome dall’azione su rebase interactive per modificare un commit: “reword”. Vedi questo post e la modalità intertriggers uomo- sezione

Esempi:

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

I realised that I had pushed a commit with a typo in it. In order to undo, I did the following:

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

Warning: force pushing your changes will overwrite the remote branch with your local one. Make sure that you aren’t going to be overwriting anything that you want to keep. Also be cautious about force pushing an amended (rewritten) commit if anyone else shares the branch with you, because they’ll need to rewrite their own history if they have the old copy of the commit that you’ve just rewritten.

I like to use the following:

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

If you have not pushed the code to your remote branch ( GitHub / Bitbucket ) you can change the commit message on the command line as below.

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

If you’re working on a specific branch do this:

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

If you’ve already pushed the code with the wrong message, and you need to be careful when changing the message. That is, after you change the commit message and try pushing it again, you end up with having issues. To make it smooth, follow these steps.

Please read my entire answer before doing it.

 git commit --amend -m "BRANCH-NAME : your new message" git push -f origin BRANCH-NAME # Not a best practice. Read below why? 

Important note: When you use the force push directly you might end up with code issues that other developers are working on the same branch. So to avoid those conflicts, you need to pull the code from your branch before making the force push :

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

This is the best practice when changing the commit message, if it was already pushed.