Ik heb het verkeerde in een vastleggingsbericht geschreven.

Hoe kan ik het bericht wijzigen? De commit is nog niet gepusht.

---

Antwoord 1, autoriteit 100%

Het meest recente commit-bericht wijzigen

git commit --amend

zal je editor openen, zodat je het commit-bericht van de meest recente commit kunt wijzigen. Bovendien kun je het commit-bericht direct in de opdrachtregel instellen met:

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

Dit kan echter meerregelige commit-berichten of kleine correcties lastiger maken om in te voeren.

Zorg ervoor dat je geen werkkopie-wijzigingen gefaseerd hebt gedaan voordat je dit doet, anders worden ze ook vastgelegd. (Niet-gefaseerde wijzigingen worden niet vastgelegd.)

Het bericht wijzigen van een commit die je al naar je remote branch gepusht hebt

Als je je commit al naar je remote branch hebt gepusht, dan – nadat je je commit lokaal hebt gewijzigd (zoals hierboven beschreven) – zul je ook moet de commit forceren met:

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

Waarschuwing: force-push zal de remote branch overschrijven met de status van je lokale . Als er commits zijn op de remote branch die je niet hebt in je lokale branch, zal die commits verliezen.

Waarschuwing: wees voorzichtig met het wijzigen van commits die je al met andere mensen hebt gedeeld. Het wijzigen van commits herschrijft ze in wezen om verschillende SHA ID’s, wat een probleem vormt als andere mensen kopieën hebben van de oude commit die je hebt herschreven. Iedereen die een kopie van de oude commit heeft, moet zijn werk synchroniseren met je nieuw herschreven commit, wat soms moeilijk kan zijn, dus zorg ervoor dat je met anderen coördineert wanneer je probeert de gedeelde commit-geschiedenis te herschrijven, of vermijd het herschrijven van gedeelde commits helemaal.

---

Voer een interactieve rebase uit

Een andere optie is om interactieve rebase te gebruiken.
Hiermee kun je elk bericht dat je wilt bijwerken bewerken, zelfs als het niet het laatste bericht is.

Om een ​​Git squash te doen, volg je deze stappen:

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

Zodra je je commits hebt geplet – kies de e/r om het bericht te bewerken:

Belangrijke opmerking over interactieve rebase

Als je git rebase -i HEAD~n gebruikt, kunnen er meer zijn dan n commits. Git zal alle commits in de laatste n commits “verzamelen”, en als er ergens tussen dat bereik een merge was, zul je ook alle commits zien, dus de uitkomst zal n + zijn.

Goede tip:

Als je het voor meer dan één vertakking moet doen en je zou kunnen worden geconfronteerd met conflicten bij het wijzigen van de inhoud, stel dan git rerere en laat Git die conflicten automatisch voor je oplossen.

---

Documentatie

• git-commit(1) Handleiding Pagina

• git-rebase(1) Handleiding Pagina

• git-push(1) Handleiding Pagina

---

Antwoord 2, autoriteit 15%

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

---

Antwoord 3, autoriteit 14%

Als de commit die je wilt herstellen niet de meest recente is:

1. git rebase --interactive $parent_of_flawed_commit

   Als je meerdere gebrekkige commits wilt repareren, geef dan de ouder van de oudste ervan door.

2. Er zal een editor verschijnen met een lijst van alle commits sinds degene die je hebt gegeven.

   1. Verander pick in reword (of op oude versies van Git, in edit) vóór eventuele commits die je wilt repareren.
   2. Zodra je hebt opgeslagen, zal Git de vermelde commits opnieuw afspelen.

3. Voor elke commit die je wilt herformuleren, zal Git je terugbrengen naar je editor. Voor elke commit die je wilt bewerken, laat Git je in de shell vallen. Als je in de schelp zit:

   1. Verander de commit op elke gewenste manier.
   2. git commit --amend
   3. git rebase --continue

Het grootste deel van deze reeks zal u worden uitgelegd door de uitvoer van de verschillende opdrachten terwijl u bezig bent. Het is heel gemakkelijk; je hoeft het niet te onthouden – onthoud alleen dat je met git rebase --interactive commits kunt corrigeren, ongeacht hoe lang geleden ze waren.

---

Merk op dat je commits die je al hebt gepusht niet wilt wijzigen. Of misschien wel, maar in dat geval moet je goed opletten om te communiceren met iedereen die je commits heeft ingetrokken en er nog werk aan heeft gedaan. Hoe herstel/synchroniseer ik nadat iemand een rebase of een reset naar een gepubliceerde branch pusht?

---

Antwoord 4, autoriteit 5%

Om de vorige commit te wijzigen, breng je de gewenste wijzigingen aan en stage die wijzigingen, en voer dan uit

git commit --amend

Dit opent een bestand in je teksteditor dat je nieuwe commit-bericht vertegenwoordigt. Het begint gevuld met de tekst van je oude commit-bericht. Wijzig het commit-bericht zoals je wilt, sla het bestand op en sluit je editor af om te voltooien.

Om de vorige commit te wijzigen en hetzelfde logbericht te behouden, voer je uit

git commit --amend -C HEAD

Om de vorige commit te herstellen door deze volledig te verwijderen, voer je uit

git reset --hard HEAD^

Als je meer dan één vastleggingsbericht wilt bewerken, voer je uit

git rebase -i HEAD~commit_count

(Vervang commit_count door het aantal commits dat je wilt bewerken.) Dit commando start je editor. Markeer de eerste commit (degene die je wilt wijzigen) als edit in plaats van pick , sla op en verlaat je editor. Breng de wijziging aan die u wilt vastleggen en voer vervolgens uit

git commit --amend
git rebase --continue

Opmerking: je kunt ook “de gewenste wijziging aanbrengen” vanuit de editor die is geopend door git commit --amend

---

Antwoord 5, autoriteit 2%

Zoals reeds vermeld, is git commit --amend de manier om de laatste commit te overschrijven. Een opmerking: als u ook de bestanden wilt overschrijven, is het commando

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

---

Antwoord 6, autoriteit 2%

Je kunt daar ook git filter-branch voor gebruiken.

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

Het is niet zo eenvoudig als een triviale git commit --amend, maar het is vooral handig als je al wat merges hebt na je foutieve commit-bericht.

Merk op dat dit zal proberen om elke commit tussen HEAD en de gebrekkige commit te herschrijven, dus je moet je msg-filter commando zeer verstandig 😉

---

Antwoord 7, autoriteit 2%

Ik geef de voorkeur aan deze manier:

git commit --amend -c <commit ID>

Anders zal er een nieuwe commit zijn met een nieuwe commit ID.

---

Antwoord 8, autoriteit 2%

Als je de Git GUI-tool gebruikt, is er een knop met de naam Laatste commit wijzigen. Klik op die knop en dan worden je laatste commit-bestanden en bericht weergegeven. Bewerk dat bericht gewoon en je kunt het vastleggen met een nieuw vastleggingsbericht.

Of gebruik deze opdracht vanaf een console/terminal:

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

---

Antwoord 9, autoriteit 2%

Je kunt Git-rebasing gebruiken. Als je bijvoorbeeld terug wilt wijzigen om bbc643cd te committen, voer je

$ git rebase bbc643cd^ --interactive

Wijzig in de standaardeditor ‘pick’ naar ‘edit’ in de regel waarvan je de commit wilt wijzigen. Breng uw wijzigingen aan en faseer ze vervolgens met

$ git add <filepattern>

Nu kunt u

$ git commit --amend

om de commit te wijzigen, en daarna

$ git rebase --continue

om terug te keren naar de vorige head-commit.

---

Antwoord 10, autoriteit 2%

1. Als je alleen je laatste commit-bericht wilt wijzigen, doe dan:

   git commit --amend
   

Hierdoor kom je in je teksteditor en kun je het laatste commit-bericht wijzigen.

2. Als je de laatste drie commit-berichten wilt wijzigen, of een van de commit-berichten tot dat moment, geef dan HEAD~3 op aan de git rebase -i commando:

   git rebase -i HEAD~3
   

---

Antwoord 11, autoriteit 2%

Als je een oud commit-bericht over meerdere branches moet wijzigen (d.w.z. de commit met het foutieve bericht is aanwezig in meerdere branches), wil je misschien het volgende gebruiken:

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

Git zal een tijdelijke map maken voor het herschrijven en aanvullen van oude referenties in refs/original/.

• -f zal de uitvoering van de bewerking afdwingen. Dit is nodig als de tijdelijke directory al aanwezig is of als er al referenties zijn opgeslagen onder refs/original. Als dat niet het geval is, kunt u deze vlag laten vallen.

• -- scheidt filter-branch-opties van revisie-opties.

• --all zorgt ervoor dat alle takken en tags worden herschreven.

Door de back-up van uw oude referenties, kunt u gemakkelijk teruggaan naar de staat voordat u de opdracht uitvoert.

Stel, je wilt je master herstellen en openen in branch old_master:

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

---

Antwoord 12

Gebruik

git commit --amend

Om het in detail te begrijpen, is een uitstekende post 4. Git-geschiedenis herschrijven. Er wordt ook gesproken over wanneer niet te gebruiken git commit --amend.

---

Antwoord 13

Als het je laatste commit is, wijzig de commit:

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

(Gebruik de -o (--only) vlag om er zeker van te zijn dat je alleen het commit bericht verandert)

Als het een begraven commit is, gebruik dan de geweldige interactieve rebase:

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

Vind de gewenste commit, verander pick in r (reword), en sla het bestand op en sluit het. Klaar!

---

Miniatuur Vim-zelfstudie (of hoe te rebasen met slechts 8 toetsaanslagen 3jcwrEscZZ):

• Voer vimtutor uit als je tijd hebt
• hjkl komen overeen met bewegingstoetsen <v^>
• Alle opdrachten kunnen worden voorafgegaan door een "bereik", b.v. 3j gaat drie regels omlaag
• i om de invoegmodus te openen de tekst die u typt, verschijnt in het bestand
• Esc of Ctrlc om de invoegmodus te verlaten en terug te keren naar de "normale" modus
• u om ongedaan te maken
• Ctrlr om opnieuw te doen
• dd, dw, dl om respectievelijk een regel, woord of letter te verwijderen
• cc, cw, cl om respectievelijk een regel, woord of letter te wijzigen (hetzelfde als ddi)
• yy, yw, yl om respectievelijk een regel, woord of letter te kopiëren ("yank")
• P of P om respectievelijk achter of voor de huidige positie te plakken
• :wEnter om een ​​bestand op te slaan (schrijven)
• :q!Enter om te stoppen zonder op te slaan
• :wqEnter of ZZ om op te slaan en af ​​te sluiten

Als je veel tekst bewerkt, schakel dan over naar de Dvorak-toetsenbordindeling, leer aanraken -type, en leer Vim. Is het de moeite waard? Ja.

---

ProTip : Wees niet bang om te experimenteren met "gevaarlijke" commando's die de geschiedenis herschrijven* Git verwijdert standaard je commits niet gedurende 90 dagen; je kunt ze vinden in de 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

* Pas op voor opties zoals --hard en --force, hoewel ze gegevens kunnen weggooien.
* Herschrijf ook niet de geschiedenis van filialen waaraan u samenwerkt.

---

Antwoord 14

Wijzigen

Je hebt hier een aantal opties. Je kunt doen

git commit --amend

zolang het je laatste commit is.

Interactieve rebase

Anders, als het niet je laatste commit is, kun je een interactieve rebase doen,

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

Dan voeg je in de interactieve rebase eenvoudig edit toe aan die commit. Als het verschijnt, voer dan een git commit --amend uit en pas het commit-bericht aan. Als je terug wilt gaan voor dat commit-punt, kun je ook git reflog gebruiken en die commit gewoon verwijderen. Dan doe je gewoon opnieuw een git commit.

---

Antwoord 15

Als je de Git GUI gebruikt, kun je de laatste commit die niet is gepusht aanpassen met:

Commit/Amend Last Commit

---

Antwoord 16

Ik gebruik de Git GUI zoveel als ik kan, en dat geeft je de mogelijkheid om de laatste aan te passen commit:

Bovendien is git rebase -i origin/master een mooie mantra die je altijd de commits zal tonen die je bovenop master hebt gedaan, en je de mogelijkheid geeft om te wijzigen, verwijderen, opnieuw te ordenen of pompoen. Je hoeft die hash niet eerst te pakken te krijgen.

---

Antwoord 17

Wauw, er zijn dus veel manieren om dit te doen.

Nog een andere manier om dit te doen is door de laatste commit te verwijderen, maar de wijzigingen te behouden zodat je je werk niet kwijtraakt. Je kunt dan nog een commit doen met het gecorrigeerde bericht. Dit zou er ongeveer zo uitzien:

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

Ik doe dit altijd als ik vergeet een bestand toe te voegen of een wijziging aan te brengen.

Vergeet niet om --soft op te geven in plaats van --hard, anders verlies je die commit volledig.

---

Antwoord 18

Iedereen die op zoek is naar een Windows/Mac GUI om oudere berichten te bewerken (dus niet alleen het laatste bericht), raad ik Bronboom. De te volgen stappen staan ​​onder de afbeelding.

Voor commits die nog niet naar een afstandsbediening zijn gepusht:

1. Zorg ervoor dat je alle huidige wijzigingen hebt doorgevoerd of opgeslagen (d.w.z. dat er geen bestanden worden vermeld op het tabblad 'Bestandsstatus') - anders werkt het niet.
2. Klik in het tabblad "Log / Geschiedenis" met de rechtermuisknop op het item met een aangrenzende regel in de grafiek één onder de commit(s) die u wilt bewerken en selecteer "Rebase kinderen van <commit ref> interactief..."
3. Selecteer de hele rij voor een vastleggingsbericht dat u wilt wijzigen (klik op de kolom "Bericht").
4. Klik op de knop "Bericht bewerken".
5. Bewerk het bericht naar wens in het dialoogvenster dat verschijnt en klik vervolgens op OK.
6. Herhaal stap 3-4 als er andere vastleggingsberichten zijn om te wijzigen.
7. Klik op OK: het rebasen begint. Als alles in orde is, eindigt de uitvoer met "Succesvol voltooid". OPMERKING: ik heb dit soms zien mislukken met Unable to create 'project_path/.git/index.lock': File exists. bij het wijzigen van meerdere commits tegelijkertijd berichten. Ik weet niet precies wat het probleem is, en of het in een toekomstige versie van Sourcetree zal worden opgelost, maar als dit gebeurt, raad dan aan om ze een voor een opnieuw te baseren (langzamer maar lijkt betrouwbaarder).

...Of... voor commits die al zijn gepusht:

Volg de stappen in dit antwoord, die vergelijkbaar zijn met hierboven, maar waarvoor een extra opdracht moet worden uitgevoerd vanaf de opdrachtregel (git push origin <branch> -f) om de branch geforceerd te pushen. Ik raad aan om alles te lezen en de nodige voorzichtigheid in acht te nemen!

---

Antwoord 19

Als je alleen de laatste commit wilt bewerken, gebruik dan:

git commit --amend

of

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

Maar als je meerdere commits achter elkaar wilt bewerken, moet je in plaats daarvan rebasen gebruiken:

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

Schrijf in een bestand, zoals hierboven, edit/e of een van de andere opties, en druk op opslaan en afsluiten.

Nu ben je bij de eerste verkeerde commit. Breng wijzigingen aan in de bestanden en ze worden automatisch voor u gestaged. Typ

git commit --amend

Opslaan en afsluiten en typ

git rebase --continue

om naar de volgende selectie te gaan totdat u klaar bent met al uw selecties.

Merk op dat deze dingen al je SHA-hashes veranderen na die specifieke commit.

---

Antwoord 20

Als u alleen uw laatste bericht wilt wijzigen, moet u de vlag --only of de sneltoets -o gebruiken met commit --amend:

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

Dit zorgt ervoor dat je je commit niet per ongeluk vergroot met gefaseerde dingen. Natuurlijk is het het beste om een ​​goede $EDITOR configuratie te hebben. Dan kun je de -m optie weglaten, en Git zal het commit bericht vooraf vullen met de oude. Op deze manier kan het gemakkelijk worden bewerkt.

---

Antwoord 21

Update je laatste verkeerde commit-bericht met het nieuwe commit-bericht in één regel:

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

Of probeer Git reset zoals hieronder:

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

Reset gebruiken om commits op te splitsen in kleinere commits

git reset kan je ook helpen om een ​​commit op te splitsen in meerdere 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 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"

Hier heb je met succes je laatste commit in twee commits gebroken.

---

Antwoord 22

Op deze vraag zijn er veel antwoorden, maar geen van hen legt super gedetailleerd uit hoe oudere commit-berichten kunnen worden gewijzigd met behulp van Vim. Ik zat vast bij het proberen dit zelf te doen, dus hier zal ik in detail opschrijven hoe ik dit heb gedaan, speciaal voor mensen die geen ervaring hebben met Vim!

Ik wilde mijn vijf laatste commits wijzigen die ik al naar de server had gepusht. Dit is behoorlijk 'gevaarlijk', want als iemand anders hier al uit is getrokken, kun je dingen verknoeien door de commit-berichten te wijzigen. Als je echter aan je eigen kleine branch werkt en zeker weet dat niemand het heeft getrokken, kun je het als volgt veranderen:

Stel dat je je vijf laatste commits wilt wijzigen, en dan typ je dit in de terminal:

git rebase -i HEAD~5

*Waarbij 5 het aantal commit-berichten is dat je wilt wijzigen (dus als je de 10e wilt wijzigen in de laatste commit, typ je 10).

Met dit commando kom je in Vim, waar je je commit-geschiedenis kunt 'bewerken'. Je ziet je laatste vijf commits bovenaan als volgt:

pick <commit hash> commit message

In plaats van pick moet je reword schrijven. Je kunt dit in Vim doen door i in te typen. Dat zorgt ervoor dat je in de modus invoegen gaat. (Je ziet dat je in de invoegmodus bent aan het woord INSERT onderaan.) Voor de commits die je wilt wijzigen, typ je reword in plaats van pick.

Vervolgens moet u dit scherm opslaan en afsluiten. Dat doe je door eerst naar de command-mode te gaan door op de Esc-knop te drukken (je kunt controleren of je in de command-mode bent als het woord INSERT op de onderkant is verdwenen). Vervolgens kunt u een opdracht typen door : te typen. Het commando om op te slaan en af ​​te sluiten is wq. Dus als je :wq typt, ben je op de goede weg.

Vervolgens zal Vim elk commit-bericht dat je wilt herformuleren doornemen, en hier kun je de commit-berichten daadwerkelijk wijzigen. U doet dit door in de invoegmodus te gaan, het vastleggingsbericht te wijzigen, naar de opdrachtmodus te gaan en op te slaan en af ​​te sluiten. Doe dit vijf keer en je hebt geen Vim meer!

Als je je verkeerde commits al hebt gepusht, moet je git push --force gebruiken om ze te overschrijven. Onthoud dat git push --force behoorlijk gevaarlijk is om te doen, dus zorg ervoor dat niemand van de server trekt sinds je je verkeerde commits hebt gepusht!

Nu heb je je commit-berichten gewijzigd!

(Zoals je ziet, ben ik niet zo ervaren in Vim, dus als ik de verkeerde 'lingo' heb gebruikt om uit te leggen wat er gebeurt, corrigeer me dan gerust!)

---

Antwoord 23

Je kunt git-rebase-reword

gebruiken

Het is ontworpen om elke commit (niet alleen de laatste) op dezelfde manier te bewerken als commit --amend

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

Het is genoemd naar de actie op interactieve rebase om een ​​commit te wijzigen: "reword". Zie dit bericht en man -sectie interactieve modus-

Voorbeelden:

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

---

Antwoord 24

Ik heb de aliassen reci en recm toegevoegd voor recommit (amend) it. Nu kan ik het doen met git recm of git recm -m:

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

---

Antwoord 25

Ik realiseerde me dat ik een commit had gepusht met een typefout erin. Om ongedaan te maken, heb ik het volgende gedaan:

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

Waarschuwing: als u uw wijzigingen forceert, wordt de externe branch overschreven met uw lokale. Zorg ervoor dat u niets overschrijft dat u wilt behouden. Wees ook voorzichtig met het forceren van een gewijzigde (herschreven) commit als iemand anders de branch met je deelt, omdat ze hun eigen geschiedenis moeten herschrijven als ze de oude kopie van de commit hebben die je zojuist hebt herschreven.

---

Antwoord 26

Ik gebruik graag het volgende:

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>

---

Antwoord 27

Als je de code niet naar je remote branch hebt gepusht (GitHub/Bitbucket) kun je het commit-bericht op de opdrachtregel wijzigen zoals hieronder.

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

Als je aan een specifieke branch werkt, doe dit dan:

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

Als je de code met het verkeerde bericht al hebt gepusht, moet je voorzichtig zijn bij het wijzigen van het bericht. Dat wil zeggen, nadat je het commit-bericht hebt gewijzigd en het opnieuw probeert te pushen, krijg je problemen. Volg deze stappen om het soepel te laten verlopen.

Lees alstublieft mijn hele antwoord voordat u het doet.

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

Belangrijke opmerking: Als je de force push rechtstreeks gebruikt, kun je problemen krijgen met de code dat andere ontwikkelaars aan dezelfde branch werken. Dus om die conflicten te vermijden, moet je de code uit je branch halen voordat je de force push doet:

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

Dit is de beste manier om het commit-bericht te wijzigen, als het al is gepusht.