Comment modifier les commits existants, non compressés?

J’ai écrit la mauvaise chose dans un message de validation. Sinon, j’ai oublié d’inclure certains fichiers.

Comment puis-je modifier les messages / fichiers de validation? Le commit n’a pas encore été poussé.

Modifier le message de validation le plus récent

git commit --amend 

ouvrira votre éditeur, vous permettant de modifier le message de validation du commit le plus récent. De plus, vous pouvez définir le message de validation directement dans la ligne de commande avec:

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

… Cependant, cela peut rendre les messages de validation multi-lignes ou les petites corrections plus lourdes à saisir.

Assurez-vous qu’aucune modification de la copie de travail n’a été effectuée avant de le faire, sinon elles seront également commises. ( Les modifications non planifiées ne seront pas validées.)

Changer le message d’un commit que vous avez déjà envoyé sur votre twig distante

Si vous avez déjà poussé votre engagement vers votre succursale distante, vous devrez alors forcer la validation avec:

 git push   --force # Or git push   -f 

Attention: la poussée forcée écrase la twig distante avec l’état de votre twig locale . S’il y a des commits sur la twig distante que vous n’avez pas dans votre agence locale, vous perdrez ces commits.

Attention: soyez prudent lorsque vous modifiez des engagements que vous avez déjà partagés avec d’autres personnes. La modification des commits les réécrit essentiellement pour avoir des identifiants SHA différents, ce qui pose problème si d’autres personnes ont des copies de l’ancien commit que vous avez réécrit. Toute personne ayant une copie de l’ancien commit devra synchroniser son travail avec votre commit nouvellement réécrit, ce qui peut parfois s’avérer difficile, alors assurez-vous de coordonner avec les autres lorsque vous essayez de réécrire l’historique des validations partagées, ou simplement d’éviter de réécrire les commits partagés tout à fait.


Utiliser le rebase interactif

Une autre option consiste à utiliser le rebase interactif.
Cela vous permet de modifier n’importe quel message que vous souhaitez mettre à jour, même si ce n’est pas le dernier message.

Pour faire un git squash, procédez comme suit:

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

Une fois que vous écrasez vos commits – choisissez le e/r pour éditer le message

entrer la description de l'image ici

Note importante sur le rebase interactif

Lorsque vous utilisez la git rebase -i HEAD~X il peut y avoir plus que X commits. Git va “collecter” tous les commits dans les X derniers commits et s’il y a eu une fusion quelque part entre ces intervalles, vous verrez aussi tous les commits, donc le résultat sera X +.

Bon conseil:

Si vous devez le faire pour plus d’une seule twig et que vous pouvez être confronté à des conflits lors de la modification du contenu, configurez git rerere et laissez git résoudre ces conflits automatiquement pour vous.


Documentation

  • git-commit (1) Page de manuel

  • git-rebase (1) Page Manuelle

  • git-push (1) Page Manuelle

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

Si le commit que vous voulez corriger n’est pas le plus récent:

  1. git rebase --interactive $parent_of_flawed_commit

    Si vous souhaitez corriger plusieurs commits erronés, transmettez le parent du plus ancien d’entre eux.

  2. Un éditeur apparaîtra, avec une liste de tous les commits depuis celui que vous avez donné.

    1. Changez le pick pour reword (ou sur les anciennes versions de Git, pour edit ) en face des commits que vous voulez corriger.
    2. Une fois que vous enregistrez, Git rejouera les commits listés.
  3. Pour chaque engagement que vous souhaitez reformuler , Git vous ramènera dans votre éditeur. Pour chaque validation que vous souhaitez modifier , Git vous dépose dans le shell. Si vous êtes dans le shell:

    1. Changez le commit comme vous le souhaitez.
    2. git commit --amend
    3. git rebase --continue

La plupart de cette séquence vous sera expliquée par la sortie des différentes commandes au fur et à mesure. C’est très facile, vous n’avez pas besoin de le mémoriser – rappelez-vous simplement que git rebase --interactive vous permet de corriger les commits depuis longtemps.


Notez que vous ne voudrez pas modifier les commits que vous avez déjà poussés. Ou peut-être que vous le faites, mais dans ce cas, vous devrez prendre grand soin de communiquer avec tous ceux qui ont peut-être tiré vos commits et fait du travail en plus. Comment est-ce que je récupère / resynchronise après que quelqu’un ait poussé une rebase ou une réinitialisation à une twig publiée?

Pour modifier la validation précédente, apportez les modifications souhaitées et effectuez ces modifications, puis exécutez

 git commit --amend 

Cela ouvrira un fichier dans votre éditeur de texte représentant votre nouveau message de validation. Il commence avec le texte de votre ancien message de validation. Modifiez le message de validation comme vous le souhaitez, puis enregistrez le fichier et quittez votre éditeur pour terminer.

Pour modifier la validation précédente et conserver le même message de journal, exécutez

 git commit --amend -C HEAD 

Pour corriger la validation précédente en la supprimant entièrement, exécutez

 git reset --hard HEAD^ 

Si vous souhaitez éditer plusieurs messages de validation, exécutez

 git rebase -i HEAD~ commit_count 

(Remplacez commit_count par le nombre de validations à modifier.) Cette commande lance votre éditeur. Marquez le premier commit (celui que vous souhaitez modifier) ​​comme “edit” au lieu de “pick”, puis enregistrez et quittez votre éditeur. Apportez la modification que vous souhaitez valider, puis exécutez

 git commit --amend git rebase --continue 

Note: Vous pouvez “Rendre le changement que vous voulez” aussi depuis l’éditeur ouvert par git commit --amend

Comme déjà mentionné, git commit --amend est le moyen d’écraser le dernier commit. Une note: si vous souhaitez également écraser les fichiers , la commande serait

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

Vous pouvez également utiliser git filter-branch pour cela.

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

Ce n’est pas aussi facile qu’un git commit --amend sortingvial git commit --amend , mais c’est particulièrement utile si vous avez déjà des fusions après votre message d’erreur erroné.

Notez que cela va essayer de réécrire chaque commit entre HEAD et le commit défectueux, donc vous devriez choisir votre commande msg-filter très judicieuse 😉

Je préfère cette façon.

 git commit --amend -c  

Sinon, il y aura un nouveau commit avec un nouvel identifiant de validation

Si vous utilisez l’outil GUI Git, il existe un bouton nommé modifier dernière validation. Cliquez sur ce bouton pour afficher vos derniers fichiers et messages de validation. Modifiez simplement ce message et vous pouvez le valider avec un nouveau message de validation.

Ou utilisez cette commande depuis une console / un terminal:

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

Vous pouvez utiliser Git rebasing . Par exemple, si vous souhaitez modifier pour valider bbc643cd, exécutez

 $ git rebase bbc643cd^ --interactive 

Dans l’éditeur par défaut, modifiez ‘pick’ pour ‘edit’ dans la ligne dont vous souhaitez modifier le commit. Apportez vos modifications puis mettez-les en scène avec

 $ git add  

Maintenant, vous pouvez utiliser

 $ git commit --amend 

modifier le commit et après cela

 $ git rebase --continue 

revenir à l’engagement de tête précédent.

  1. Si vous souhaitez uniquement modifier votre dernier message de validation, procédez comme suit:

     git commit --amend 

    Cela vous déposera dans votre éditeur de texte et vous permettra de changer le dernier message de validation.

  2. Si vous souhaitez modifier les 3 derniers messages de validation, ou l’un des messages de validation, fournissez HEAD~3 à la commande git rebase -i :

     git rebase -i HEAD~3 

Si vous devez changer un ancien message de validation sur plusieurs twigs (par exemple, la validation avec le message erroné est présente dans plusieurs twigs), vous pouvez utiliser:

 git filter-branch -f --msg-filter \ 'sed "s///g"' -- --all 

Git créera un répertoire temporaire pour la réécriture et sauvegardera les anciennes références dans refs/original/ .

  • -f va exécuter l’exécution de l’opération. Ceci est nécessaire si le répertoire temporaire est déjà présent ou s’il existe déjà des références stockées sous refs/original . Si ce n’est pas le cas, vous pouvez déposer ce drapeau.

  • -- sépare les options de twig de filtre des options de révision.

  • --all s’assurera que toutes les twigs et les balises sont réécrites.

Grâce à la sauvegarde de vos anciennes références, vous pouvez facilement revenir à l’état avant d’exécuter la commande.

Dites, vous voulez récupérer votre maître et y accéder dans la twig old_master :

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

Utilisation

 git commit --amend 

Pour bien le comprendre, un excellent article est 4. Réécrire l’histoire de Git . Il parle également de ne pas utiliser git commit --amend .

Modifier

Vous avez quelques options ici. Tu peux faire

 git commit --amend 

tant que c’est votre dernier engagement.

Rebase interactif

Sinon, si ce n’est pas votre dernier engagement, vous pouvez faire un rebase interactif,

 git rebase -i [twigd_from] [hash before commit] 

Ensuite, à l’intérieur du rebase interactif, il vous suffit d’append edit à ce commit. Quand il se présente, faites un git commit --amend et modifiez le message de validation. Si vous souhaitez revenir en arrière avant ce sharepoint validation, vous pouvez également utiliser git reflog et simplement supprimer cette validation. Ensuite, il vous suffit de refaire un git commit .

Si vous utilisez l’interface graphique de Git, vous pouvez modifier le dernier commit qui n’a pas été poussé avec:

 Commit/Amend Last Commit 

Si c’est votre dernier commit, modifiez simplement le commit:

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

(en utilisant l’ --only -o ( --only ) pour vous assurer que vous ne modifiez que le message de validation)

S’il s’agit d’un commit enterré, utilisez le rebase interactif génial :

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

Trouvez le commit souhaité, changez le pick en r ( reword ) et enregistrez et fermez le fichier. Terminé!


Tutoriel miniature vim (ou comment rebaser avec seulement 8 frappes 3j cw r Esc ZZ ):

  • Exécutez vimtutor si vous avez le temps
  • h j k l correspond aux touches de déplacement
  • Toutes les commandes peuvent être préfixées avec une “plage”, par exemple 3j descend 3 lignes
  • i dois entrer en mode d’insertion – le texte que vous tapez apparaîtra dans le fichier
  • Esc ou Ctrl c pour quitter le mode insertion et revenir au mode “normal”
  • u défaire
  • Ctrl r pour refaire
  • dd , dw , dl pour supprimer une ligne, un mot ou une lettre, respectivement
  • cc , cw , cl pour changer une ligne, un mot ou une lettre, respectivement (identique à dd i )
  • yy , yw , yl pour copier (“yank”) une ligne, un mot ou une lettre, respectivement
  • p ou P pour coller après ou avant la position actuelle, respectivement
  • :w Entrez pour enregistrer (écrire) un fichier
  • :q! Entrez pour quitter sans sauvegarder
  • :wq Enter ou ZZ pour enregistrer et quitter

Si vous éditez beaucoup de texte, passez à la disposition du clavier Dvorak, apprenez à taper sur le clavier et apprenez vim. Cela en vaut-il la peine? Oui.


ProTip ™: n’ayez pas peur d’expérimenter des commandes “dangereuses” qui réécrivent l’historique * – Git ne supprime pas vos commits pendant 90 jours par défaut; vous pouvez les trouver dans le 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 

* Surveillez les options comme --hard et --force si – elles peuvent rejeter des données.
* En outre, ne réécrivez pas l’historique sur les twigs sur lesquelles vous collaborez.

J’utilise autant que possible l’ interface graphique de Git , ce qui vous permet de modifier le dernier commit:

Tick that box

De plus, git rebase -i origin/master est un joli mantra qui vous présentera toujours les commits que vous avez faits au-dessus de master, et vous donne la possibilité de modifier, supprimer, réorganiser ou squash. Pas besoin de mettre la main sur ce hash en premier.

Wow, il y a beaucoup de façons de le faire.

Une autre façon de procéder consiste à supprimer le dernier commit, mais conservez ses modifications afin de ne pas perdre votre travail. Vous pouvez ensuite faire un autre commit avec le message corrigé. Cela ressemblerait à ceci:

 git reset --soft HEAD~1 git commit -m 'New and corrected commit message' 

Je le fais toujours si j’oublie d’append un fichier ou de faire un changement.

N’oubliez pas de spécifier --soft place de --hard , sinon vous perdez entièrement cette valeur.

Si vous souhaitez simplement modifier la dernière utilisation de commit:

 git commit --amend 

ou

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

Mais si vous voulez éditer plusieurs commits à la suite, vous devriez plutôt utiliser rebasing:

 git rebase -i  

édition de git rebase

Dans un fichier comme celui ci-dessus, éditez edit / e ou une des autres options et cliquez sur save and exit.

Maintenant, vous serez au premier engagement erroné. Apportez des modifications aux fichiers et ils seront automatiquement organisés pour vous. Type

 git commit --amend 

enregistrer et quitter cela et taper

 git rebase --continue 

pour passer à la sélection suivante jusqu’à ce que toutes vos sélections soient terminées.

Notez que ces choses changent tous vos hachages SHA après cette validation particulière.

Pour ceux qui recherchent une interface graphique Windows / Mac pour aider à éditer des messages plus anciens (c.-à-d. Pas seulement le dernier message), je vous recommande SourceTree . Les étapes à suivre sont ci-dessous.

Reprise interactive de SourceTree

Pour les commits qui n’ont pas encore été poussés vers une télécommande:

  1. Assurez-vous que vous avez validé ou caché toutes les modifications en cours (c.-à-d. Qu’il n’y a aucun fichier répertorié dans l’onglet “État du fichier”) – cela ne fonctionnera pas autrement.
  2. Dans l’onglet “Journal / Historique”, cliquez avec le bouton droit de la souris sur l’entrée avec une ligne contiguë dans le graphique ci-dessous les validations à modifier et sélectionnez “Rebase les enfants de interactivement …”
  3. Sélectionnez la ligne entière du message de validation que vous souhaitez modifier ( c.-à-d. Cliquez sur la colonne “Message” ).
  4. Cliquez sur le bouton “Modifier le message”.
  5. Modifiez le message comme vous le souhaitez dans la boîte de dialog qui s’affiche, puis cliquez sur OK.
  6. Répétez les étapes 3 et 4 s’il y a d’autres messages de validation à modifier.
  7. Cliquez sur OK: le remappage va commencer. Si tout va bien, la sortie se terminera “Terminé avec succès”.

… Ou … pour les commits qui ont déjà été poussés:

Suivez les étapes de cette réponse , qui sont similaires à celles ci-dessus mais nécessitent une commande supplémentaire à exécuter à partir de la ligne de commande pour forcer la twig – lisez tout et appliquez les précautions nécessaires!

Si vous voulez seulement changer votre dernier message, vous devez utiliser le drapeau --only ou son raccourci -o avec commit --amend :

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

Cela garantit que vous n’améliorez pas accidentellement votre commit avec des éléments mis en scène. Bien sûr, il est préférable d’avoir une configuration correcte de $EDITOR . Ensuite, vous pouvez laisser l’option -m désactivée et git remplira le message de validation avec l’ancien. De cette façon, il peut être facilement modifié.

Mettez à jour votre dernier message de validation erroné avec un nouveau message de validation sur une seule ligne:

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

Ou essayez git reset comme ci-dessous:

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

L’utilisation de la réinitialisation pour diviser commet des commits plus petits

git reset peut aussi vous aider à casser un commit en plusieurs commits:

 # 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" 

Ici, vous avez réussi à rompre votre dernier engagement en deux commits.

Sur cette question, il y a beaucoup de réponses, mais aucune n’explique en détail comment changer les anciens messages de validation en utilisant VIM. J’étais coincé à essayer de le faire moi-même, alors j’écrirai en détail comment je l’ai fait, en particulier pour les personnes qui n’ont aucune expérience en VIM!

Je voulais changer mes cinq derniers commits que j’ai déjà transmis au serveur. Ceci est assez “dangereux” car si quelqu’un d’autre en a déjà tiré, vous pouvez tout gâcher en modifiant les messages de validation. Cependant, lorsque vous travaillez sur votre propre petite twig et que vous êtes sûr que personne ne l’a tiré, vous pouvez le modifier comme suit:

Disons que vous voulez changer vos cinq derniers commits, puis vous tapez ceci dans le terminal:

git rebase -i HEAD~5 * Où 5 est le nombre de messages de validation que vous souhaitez modifier. (donc si vous voulez changer le 10ème en dernier, vous tapez 10)

Cette commande vous amènera à VIM là où vous pourrez “éditer” votre historique de validation. Vous verrez vos 5 derniers commits en haut comme ceci:

pick commit message

Au lieu de pick vous devez écrire reword . Vous pouvez le faire dans VIM en tapant i , qui vous fait passer en mode INSERT. (Vous voyez que vous êtes en mode d’insertion par le mot INSERT en bas) Pour les commits que vous souhaitez modifier tapez reword au lieu de pick

Ensuite, vous devez enregistrer et quitter cet écran, vous le faites en allant d’abord en mode commande en appuyant sur le bouton esc. (vous pouvez vérifier que vous êtes en mode commande si le mot INSERT en bas a disparu) Ensuite, vous pouvez taper une commande en tapant:, la commande pour enregistrer et quitter est wq . Donc, si vous tapez :wq vous êtes sur la bonne voie.

Ensuite, VIM va parcourir chaque message de validation que vous souhaitez reformuler, ici vous pouvez réellement modifier les messages de validation. Pour ce faire, accédez au mode INSERT, modifiez le message de validation, passez en mode commande et enregistrez et quittez. Faites ceci 5 fois et vous êtes hors de VIM!

Ensuite, si vous avez déjà poussé vos commits incorrects, vous devez git push --force pour les écraser. Rappelez-vous que git push --force est une chose très dangereuse à faire, alors assurez-vous que personne ne soit sorti du serveur depuis que vous vous êtes trompé de commits!

Vous avez maintenant changé vos messages de validation!

(Comme vous le voyez, je ne suis pas aussi expérimenté dans VIM, donc si je me suis trompé de “jargon” pour expliquer ce qui se passe, n’hésitez pas à me corriger!)

J’ai ajouté l’alias de reci , recm pour recm recommit (amend) , maintenant je peux le faire avec git recm ou git recm -m .

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

Vous pouvez utiliser git-rebase-reword

Il est conçu pour éditer tout commit (pas seulement le dernier) de la même manière que commit --amend

 $ git rebase-reword  

Il porte le nom de l’action sur rebase interactive pour modifier un commit: “reword”. Voir ce mode interactif post et man -section-

Exemples:

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