J'ai écrit la mauvaise chose dans un message de validation.

Comment puis-je changer le message? Le commit n'a pas encore été poussé.

Modification du 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 sur plusieurs lignes ou les petites corrections plus difficiles à saisir.

Assurez - vous que vous ne disposez pas des modifications de la copie de travail mis en scène avant de le faire ou ils seront engagés aussi. ( Les modifications non planifiées ne seront pas validées.)

Modification du message d'un commit que vous avez déjà transmis à votre branche distante

Si vous avez déjà poussé votre commit vers votre branche distante, alors - après avoir modifié votre commit localement (comme décrit ci-dessus) - vous devrez également forcer le push avec:

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

Avertissement: la poussée forcée écrasera la branche distante avec l'état de votre branche locale . S'il y a des commits sur la branche à distance que vous n'avez pas dans votre branche locale, vous allez perdre ces commits.

Avertissement: soyez prudent lorsque vous modifiez des commits que vous avez déjà partagés avec d'autres personnes. La modification des validations les réécrit essentiellement pour avoir des ID SHA différents , ce qui pose un problème si d'autres personnes ont des copies de l'ancienne validation que vous avez réécrite. Quiconque possède une copie de l'ancien commit devra synchroniser son travail avec votre commit nouvellement réécrit, ce qui peut parfois être difficile, alors assurez-vous de vous coordonner avec les autres lorsque vous essayez de réécrire l'historique des commit partagés, ou évitez simplement de réécrire les commits partagés tout à fait.

Effectuer un rebase interactif

Une autre option consiste à utiliser un rebase interactif. Cela vous permet de modifier tout message que vous souhaitez mettre à jour même s'il ne s'agit pas du dernier message.

Afin de faire un squash Git, procédez comme suit:

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

Une fois que vous écrasez vos commits - choisissez le e/rpour éditer le message:

Remarque importante sur le rebasage interactif

Lorsque vous utilisez, git rebase -i HEAD~nil peut y avoir plus de n validations. Git "collectera" toutes les validations dans les n dernières validations, et s'il y avait une fusion quelque part entre cette plage, vous verrez également toutes les validations, donc le résultat sera n +.

Bon conseil:

Si vous devez le faire pour plus d'une seule branche et que vous pouvez rencontrer des conflits lors de la modification du contenu, configurez git rerereet laissez Git résoudre ces conflits automatiquement pour vous.

Documentation

• Page de manuel de git-commit (1)

• Page de manuel de git-rebase (1)

• Page de manuel de git-push (1)

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

Si le commit que vous souhaitez corriger n'est pas le plus récent:

1. git rebase --interactive $parent_of_flawed_commit

   Si vous souhaitez corriger plusieurs validations défectueuses, passez 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. Passez pickà reword(ou sur les anciennes versions de Git, à edit) devant tous les commits que vous souhaitez corriger.
   2. Une fois que vous avez enregistré, Git rejouera les validations répertoriées.
      
      

3. Pour chaque commit que vous souhaitez reformuler , Git vous renverra dans votre éditeur. Pour chaque commit que vous souhaitez modifier , Git vous dépose dans le shell. Si vous êtes dans le shell:

   1. Modifiez 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 cela git rebase --interactivevous permet de corriger les commits, peu importe leur ancienneté.

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 peuvent avoir tiré vos engagements et effectué un travail par-dessus eux. Comment récupérer / resynchroniser après que quelqu'un a poussé un rebase ou une réinitialisation dans une branche publiée?

Pour modifier le commit précédent, effectuez 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 le commit précédent et conserver le même message de journal, exécutez

git commit --amend -C HEAD

Pour corriger le commit précédent en le supprimant entièrement, exécutez

git reset --hard HEAD^

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

git rebase -i HEAD~commit_count

(Remplacez commit_count par le nombre de validations que vous souhaitez modifier.) Cette commande lance votre éditeur. Marquez le premier commit (celui que vous voulez changer) 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

Remarque: Vous pouvez également "Apporter la modification souhaitée" à partir de l'éditeur ouvert par git commit --amend

Comme déjà mentionné, git commit --amendest le moyen d'écraser le dernier commit. Une remarque: si vous souhaitez également écraser les fichiers , la commande serait

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

Vous pouvez également l'utiliser git filter-branchpour cela.

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

Ce n'est pas aussi facile qu'un trivial git commit --amend, mais c'est particulièrement utile, si vous avez déjà quelques fusions après votre message de validation erroné.

Notez que cela va essayer de réécrire chaque commit entre HEADet le commit défectueux, vous devez donc choisir votre msg-filtercommande très judicieusement ;-)

Je préfère cette façon:

git commit --amend -c <commit ID>

Sinon, il y aura une nouvelle validation avec un nouvel ID de validation.

Si vous utilisez l'outil Git GUI, il existe un bouton nommé Modifier le dernier commit . Cliquez sur ce bouton, puis il affichera vos derniers fichiers de validation et message. 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 le rebasage Git . Par exemple, si vous souhaitez modifier à nouveau pour valider bbc643cd, exécutez

$ git rebase bbc643cd^ --interactive

Dans l'éditeur par défaut, modifiez «choisir» pour «modifier» dans la ligne dont vous souhaitez modifier la validation. Apportez vos modifications, puis mettez-les en scène avec

$ git add <filepattern>

Vous pouvez maintenant utiliser

$ git commit --amend

pour modifier le commit, et après cela

$ git rebase --continue

pour revenir au commit 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 modifier le dernier message de validation.

2. Si vous souhaitez modifier les trois derniers messages de validation, ou l'un des messages de validation jusqu'à ce point, fournissez HEAD~3à la git rebase -icommande:

   git rebase -i HEAD~3
   

Si vous devez modifier un ancien message de validation sur plusieurs branches (c'est-à-dire que la validation avec le message erroné est présente dans plusieurs branches), vous pouvez utiliser:

git filter-branch -f --msg-filter \
'sed "s/<old message>/<new message>/g"' -- --all

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

• -fimposera l'exécution de l'opération. Cela est nécessaire si le répertoire temporaire est déjà présent ou s'il y a déjà des références stockées sous refs/original. Si ce n'est pas le cas, vous pouvez supprimer ce drapeau.

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

• --alls'assurera que toutes les branches et balises sont réécrites.

En raison de 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 en succursale old_master:

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

Utilisation

git commit --amend

Pour le comprendre en détail, un excellent article est 4. Rewriting Git History . Il indique également quand ne pas l'utiliser git commit --amend .

Modifier

Vous avez quelques options ici. Tu peux faire

git commit --amend

tant que c'est votre dernier commit.

Rebase interactive

Sinon, si ce n'est pas votre dernier commit, vous pouvez faire un rebase interactif,

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

Ensuite, à l'intérieur du rebase interactif, vous ajoutez simplement la modification à ce commit. Quand il apparaît, faites un git commit --amendet modifiez le message de validation. Si vous souhaitez annuler avant ce point de validation, vous pouvez également utiliser git refloget simplement supprimer cette validation. Ensuite, vous faites à git commitnouveau.

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

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

(Utilisation de l' indicateur -o( --only) pour vous assurer de ne modifier que le message de validation)

S'il s'agit d'un commit enterré, utilisez la redéfinition interactive impressionnante :

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

Recherchez le commit que vous souhaitez, passez pickà r( reword), puis enregistrez et fermez le fichier. Terminé!

Tutoriel Miniature Vim (ou comment rebaser avec seulement 8 touches 3jcwrEscZZ):

• Courez vimtutorsi vous avez le temps
• hjkl correspondent aux touches de mouvement ←↓↑→
• Toutes les commandes peuvent être préfixées par une "plage", par exemple 3jdescend de trois lignes
• i pour entrer en mode insertion - le texte que vous tapez apparaîtra dans le fichier
• Escou Ctrlcpour quitter le mode insertion et revenir au mode "normal"
• u défaire
• Ctrlr refaire
• dd, dw, dlSupprimer une ligne, un mot ou une lettre, respectivement
• cc, cw, cl, Respectivement changer une ligne, un mot ou lettre (comme ddi)
• yy, yw, ylCopier ( « Yank ») une ligne, un mot ou une lettre, respectivement
• pou Ppour coller respectivement après ou avant la position actuelle
• :wEnter enregistrer (écrire) un fichier
• :q!Enter quitter sans enregistrer
• :wqEnterou ZZpour enregistrer et quitter

Si vous modifiez beaucoup de texte, passez à la disposition du clavier Dvorak , apprenez à taper et apprenez Vim. Cela en vaut-il la peine? Oui.

ProTip ™: N'ayez pas peur d'expérimenter avec des commandes "dangereuses" qui réécrivent l'historique * - Git ne supprime pas vos validations pendant 90 jours par défaut; vous pouvez les trouver dans le 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

* Méfiez-vous des options comme --hardet --forcebien - ils peuvent éliminer les données. * De plus, ne réécrivez pas l'historique sur les branches sur lesquelles vous collaborez.

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

Commit/Amend Last Commit

J'utilise autant que possible l' interface graphique de Git , et cela vous donne la possibilité de modifier le dernier commit:

En outre, git rebase -i origin/masterc'est un joli mantra qui vous présentera toujours les commits que vous avez effectués sur Master, et vous donnera la possibilité de modifier, supprimer, réorganiser ou écraser. Pas besoin de mettre la main sur ce hachage en premier.

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

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

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

Je fais toujours cela si j'oublie d'ajouter un fichier ou de faire un changement.

N'oubliez pas de spécifier --softau lieu de --hard, sinon vous perdez entièrement ce commit.

Pour tous ceux qui recherchent une interface graphique Windows / Mac pour aider à modifier les messages plus anciens (c'est-à-dire pas seulement le dernier message), je recommanderais Sourcetree . Les étapes à suivre sont ci-dessous.

Pour les validations qui n'ont pas encore été transmises à une télécommande:

1. Assurez-vous que vous avez validé ou caché toutes les modifications en cours (c'est-à-dire 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 adjacente dans le graphique situé sous le ou les commit (s) que vous souhaitez modifier et sélectionnez "Rebase des enfants de <commit ref> de manière interactive ..."
3. Sélectionnez la ligne entière pour un message de validation que vous souhaitez modifier (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 dialogue qui s'affiche, puis cliquez sur OK.
6. Répétez les étapes 3 à 4 s'il y a d'autres messages de validation à modifier.
7. Cliquez sur OK: Le rebasage commencera. Si tout va bien, la sortie se terminera "Terminé avec succès". REMARQUE: j'ai parfois vu cela échouer Unable to create 'project_path/.git/index.lock': File exists.lors de la tentative de modification de plusieurs messages de validation en même temps. Je ne sais pas exactement quel est le problème, ni s'il sera résolu dans une future version de Sourcetree, mais si cela se produit, je recommanderais de les rebaser un par un (plus lent mais semble plus fiable).

... 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 qu'une autre commande soit exécutée à partir de la ligne de commande ( git push origin <branch> -f) pour forcer le branchement. Je recommanderais de tout lire et d'appliquer la prudence nécessaire!

Si vous souhaitez simplement modifier le dernier commit, utilisez:

git commit --amend

ou

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

Mais si vous souhaitez modifier plusieurs validations d'affilée, vous devriez plutôt utiliser le rebasage:

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

Dans un fichier, comme celui ci-dessus, écrivez edit/eou l'une des autres options, puis appuyez sur Enregistrer et quitter.

Vous serez maintenant au premier mauvais commit. Apportez des modifications dans les fichiers et ils seront automatiquement mis en scène pour vous. Type

git commit --amend

Enregistrez et quittez cela et tapez

git rebase --continue

pour passer à la sélection suivante jusqu'à ce que vous ayez terminé toutes vos sélections.

Notez que ces choses changent tous vos hachages SHA après ce commit particulier.

Si vous souhaitez uniquement modifier votre dernier message, vous devez utiliser l' --onlyindicateur ou son raccourci -oavec commit --amend:

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

Cela garantit que vous n'améliorez pas accidentellement votre validation avec des éléments mis en scène. Bien sûr, il est préférable d'avoir une $EDITORconfiguration appropriée . Ensuite, vous pouvez laisser l' -moption désactivée, et Git pré-remplira le message de validation avec l'ancien. De cette façon, il peut être facilement édité.

Mettez à jour votre dernier message de validation incorrect avec le 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.

Utilisation de la réinitialisation pour diviser les commits en petits commits

git reset peut également vous aider à diviser un commit en plusieurs 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"

Ici, vous avez réussi à diviser votre dernier commit en deux commits.

Sur cette question, il existe de nombreuses réponses, mais aucune d'entre elles n'explique en détail comment modifier les anciens messages de validation à l'aide de Vim . J'étais coincé à essayer de le faire moi-même, alors ici, je vais écrire en détail comment j'ai fait cela, en particulier pour les personnes qui n'ont aucune expérience à Vim!

Je voulais modifier mes cinq derniers commits que j'ai déjà envoyés au serveur. C'est assez «dangereux» car si quelqu'un d'autre s'en est déjà tiré, vous pouvez gâcher les choses en modifiant les messages de validation. Cependant, lorsque vous travaillez sur votre propre petite branche et que vous êtes sûr que personne ne l'a tirée, vous pouvez la changer comme ceci:

Imaginons que vous souhaitiez modifier vos cinq derniers commits, puis saisissez ceci dans le terminal:

git rebase -i HEAD~5

* Où 5 est le nombre de messages de commit que vous voulez changer (donc si vous voulez changer le 10ème au dernier commit, vous tapez 10).

Cette commande vous amènera dans Vim où vous pourrez «modifier» votre historique de commit. Vous verrez vos cinq derniers commits en haut comme ceci:

pick <commit hash> commit message

Au lieu de pickvous devez écrire reword. Vous pouvez le faire dans Vim en tapant i. Cela vous fait passer en mode insertion . (Vous voyez que vous êtes en mode d'insertion par le mot INSERT en bas.) Pour les commits que vous souhaitez modifier, tapez à la rewordplace de pick.

Ensuite, vous devez enregistrer et quitter cet écran. Pour ce faire, Escpassez d'abord en «mode commande» en appuyant sur le bouton (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, :wqvous êtes sur la bonne voie.

Ensuite, Vim examinera chaque message de validation que vous souhaitez reformuler, et ici vous pouvez réellement modifier les messages de validation. Pour ce faire, passez en mode insertion, modifiez le message de validation, passez en mode commande, puis enregistrez et quittez. Faites-le cinq fois et vous êtes hors de Vim!

Ensuite, si vous avez déjà poussé vos mauvais commits, vous devez les git push --forceécraser. N'oubliez pas que git push --forcec'est une chose assez dangereuse à faire, alors assurez-vous que personne ne s'est retiré du serveur puisque vous avez poussé vos mauvais commits!

Vous avez maintenant changé vos messages de validation!

(Comme vous le voyez, je ne suis pas très expérimenté à Vim, donc si j'ai utilisé le mauvais 'jargon' pour expliquer ce qui se passe, n'hésitez pas à me corriger!)

Vous pouvez utiliser git-rebase-reword

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

$ git rebase-reword <commit-or-refname>

Il est nommé d'après l'action sur rebase interactive pour modifier un commit: "reword". Voir cet article et man -section mode interactif-

Exemples:

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

J'ai ajouté les alias reciet recmpour recommit (amend)cela. Maintenant je peux le faire avec git recmou git recm -m:

$ vim ~/.gitconfig

[alias]

    ......
    cm = commit
    reci = commit --amend
    recm = commit --amend
    ......

J'ai réalisé que j'avais poussé un commit avec une faute de frappe dedans. Pour annuler, j'ai fait ce qui suit:

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

Avertissement: pousser de force vos modifications écrasera la branche distante avec votre branche locale. Assurez-vous que vous n'écraserez pas tout ce que vous souhaitez conserver. Soyez également prudent lorsque vous forcez à pousser un commit modifié (réécrit) si quelqu'un d'autre partage la branche avec vous, car il devra réécrire sa propre histoire s'il a l'ancienne copie du commit que vous venez de réécrire.

J'aime utiliser ce qui suit:

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>

Si vous n'avez pas poussé le code vers votre branche distante ( GitHub / Bitbucket ), vous pouvez modifier le message de validation sur la ligne de commande comme ci-dessous.

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

Si vous travaillez sur une branche spécifique, procédez comme suit:

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

Si vous avez déjà poussé le code avec le mauvais message et que vous devez être prudent lorsque vous modifiez le message. Autrement dit, après avoir modifié le message de validation et essayé de le pousser à nouveau, vous vous retrouvez avec des problèmes. Pour le rendre lisse, suivez ces étapes.

Veuillez lire l'intégralité de ma réponse avant de le faire.

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

git push -f origin BRANCH-NAME                # Not a best practice. Read below why?

Remarque importante: lorsque vous utilisez directement la poussée forcée, vous pouvez vous retrouver avec des problèmes de code que d'autres développeurs travaillent sur la même branche. Donc, pour éviter ces conflits, vous devez extraire le code de votre branche avant de faire le push de force :

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

Il s'agit de la meilleure pratique lors de la modification du message de validation, s'il a déjà été poussé.