Hoe kan ik mijn laatste X commits samenvoegen tot één commit met Git?

Antwoord 1, autoriteit 100%

Gebruik git rebase -i <after-this-commit> en vervang “pick” op de tweede en volgende commits door “squash” of “fixup”, zoals beschreven in de handleiding.

In dit voorbeeld is <after-this-commit> ofwel de SHA1-hash of de relatieve locatie van de HEAD van de huidige branch van waaruit commits worden geanalyseerd voor het rebase-commando. Als de gebruiker bijvoorbeeld 5 commits van de huidige HEAD in het verleden wil bekijken, is het commando git rebase -i HEAD~5.

Antwoord 2, autoriteit 177%

Je kunt dit vrij eenvoudig doen zonder git rebase of git merge --squash. In dit voorbeeld zullen we de laatste 3 commits pletten.

Als je het nieuwe commit-bericht helemaal opnieuw wilt schrijven, is dit voldoende:

git reset --soft HEAD~3 &&
git commit

Als je het nieuwe commit-bericht wilt gaan bewerken met een aaneenschakeling van de bestaande commit-berichten (dwz vergelijkbaar met wat een pick/squash/squash/ /squash git rebase -i instructielijst zou doen begin je mee), dan moet je die berichten extraheren en doorgeven aan git commit:

git reset --soft HEAD~3 && 
git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"

Beide methoden pletten de laatste drie commits op dezelfde manier in een enkele nieuwe commit. De zachte reset wijst HEAD gewoon opnieuw naar de laatste commit die je niet wilt squashen. Noch de index, noch de werkboom worden geraakt door de zachte reset, waardoor de index in de gewenste staat blijft voor je nieuwe commit (dwz het heeft al alle wijzigingen van de commits die je op het punt staat “weg te gooien”).

Antwoord 3, autoriteit 33%

Je kunt hiervoor git merge --squash gebruiken, wat iets eleganter is dan git rebase -i. Veronderstel dat je op master bent en je wilt de laatste 12 commits in één pletten.

WAARSCHUWING: Zorg er eerst voor dat u uw werk vastlegt. Controleer of git status schoon is (aangezien git reset --hard gefaseerde en niet-gefaseerde wijzigingen weggooit)

Dan:

# Reset the current branch to the commit just before the last 12:
git reset --hard HEAD~12
# HEAD@{1} is where the branch was just before the previous command.
# This command sets the state of the index to be as it would just
# after a merge from that commit:
git merge --squash HEAD@{1}
# Commit those squashed changes.  The commit message will be helpfully
# prepopulated with the commit messages of all the squashed commits:
git commit

De documentatie voor git merge beschrijft de optie --squash in meer detail.

Update: het enige echte voordeel van deze methode ten opzichte van de eenvoudigere git reset --soft HEAD~12 && git commit voorgesteld door Chris Johnsen in zijn antwoord is dat je het commit-bericht vooraf ingevuld krijgt bij elk commit-bericht dat je pletten.

Antwoord 4, autoriteit 10%

Ik raad aan om git reset indien mogelijk te vermijden — vooral voor Git-beginners. Tenzij je echt een proces moet automatiseren op basis van een aantal commits, is er een minder exotische manier…

Zet de te vernietigen commits op een werkende branch (als ze dat nog niet zijn) — gebruik hiervoor gitk
Bekijk de doelbranch (bijv. ‘master’)
git merge --squash (working branch name)
git commit

Het commit-bericht wordt vooraf ingevuld op basis van de squash.

Antwoord 5, autoriteit 7%

Dankzij deze handige blogpost Ik ontdekte dat je dit commando kunt gebruiken om de laatste 3 commits te pletten:

git rebase -i HEAD~3

Dit is handig omdat het zelfs werkt als u zich in een lokaal filiaal bevindt zonder trackinginformatie/repo op afstand.

Het commando zal de interactieve rebase-editor openen, waarmee u weer kunt ordenen, squashen, herformuleren, enz. zoals u gewend bent.

De interactieve rebase-editor gebruiken:

De interactieve rebase-editor toont de laatste drie commits. Deze beperking werd bepaald door HEAD~3 bij het uitvoeren van het commando git rebase -i HEAD~3.

De meest recente commit, HEAD, wordt als eerste weergegeven op regel 1. De regels die beginnen met een # zijn opmerkingen/documentatie.

De weergegeven documentatie is vrij duidelijk. Op een willekeurige regel kun je het commando van pick veranderen in een commando naar keuze.

Ik gebruik liever het commando fixup omdat dit de wijzigingen van de commit “vernietigt” in de commit op de regel hierboven en het bericht van de commit negeert.

Aangezien de commit op regel 1 HEAD is, zou je dit in de meeste gevallen als pick laten staan.
Je kunt squash of fixup niet gebruiken omdat er geen andere commit is om de commit in te squashen.

Je kunt ook de volgorde van de commits veranderen. Dit stelt je in staat om commits die niet chronologisch naast elkaar liggen te pletten of op te lossen.

Een praktisch alledaags voorbeeld

Ik heb onlangs een nieuwe functie toegevoegd. Sindsdien heb ik twee bugfixes doorgevoerd. Maar nu heb ik een bug (of misschien gewoon een spelfout) ontdekt in de nieuwe functie die ik heb toegevoegd. Hoe irritant! Ik wil niet dat een nieuwe commit mijn commit-geschiedenis vervuilt!

Het eerste wat ik doe is de fout herstellen en een nieuwe commit maken met de opmerking squash this into my new feature!.

Ik voer dan git log of gitk uit en verkrijg de commit SHA van de nieuwe functie (in dit geval 1ff9460).

Vervolgens breng ik de interactieve rebase-editor naar voren met git rebase -i 1ff9460~. De ~ na de commit SHA vertelt de editor om die commit in de editor op te nemen.

Vervolgens verplaats ik de commit met de fix (fe7f1e0) naar onder de feature-commit, en verander ik pick in fixup.

Als je de editor sluit, wordt de fix geplet in de feature-commit en ziet mijn commit-geschiedenis er mooi en schoon uit!

Dit werkt goed als alle commits lokaal zijn, maar als je commits probeert te wijzigen die al naar de remote zijn gepusht, kun je echt problemen veroorzaken voor andere ontwikkelaars die dezelfde branch hebben uitgecheckt!

Antwoord 6, autoriteit 6%

Gebaseerd op antwoord van Chris Johnsen,

Voeg een globale “squash”-alias toe vanuit bash: (of Git Bash op Windows)

git config --global alias.squash '!f(){ git reset --soft HEAD~${1} && git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"; };f'

… of via de opdrachtprompt van Windows:

git config --global alias.squash "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

Uw ~/.gitconfig zou nu deze alias moeten bevatten:

[alias]
    squash = "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

Gebruik:

git squash N

… Wat automatisch de laatste N commits samenperst, inclusief.

Opmerking: het resulterende commit-bericht is een combinatie van alle geplette commits, in volgorde. Als je daar niet tevreden mee bent, kun je altijd git commit --amend om het handmatig te wijzigen. (Of bewerk de alias naar uw smaak.)

Antwoord 7, autoriteit 5%

2020 Eenvoudige oplossing zonder rebase :

git reset --soft HEAD~2

git commit -m "new commit message"

git push -f

2 betekent dat de laatste twee commits worden geplet. Je kunt het vervangen door een willekeurig getal

Antwoord 8, autoriteit 3%

Om dit te doen kun je het volgende git commando gebruiken.

 git rebase -i HEAD~n

n(=4 hier) is het nummer van de laatste commit. Dan heb je de volgende opties,

pick 01d1124 Message....
pick 6340aaa Message....
pick ebfd367 Message....
pick 30e0ccb Message....

Update zoals hieronder pick één commit en squash de anderen naar de meest recente,

p 01d1124 Message....
s 6340aaa Message....
s ebfd367 Message....
s 30e0ccb Message....

Klik voor details op de Link

Antwoord 9, autoriteit 2%

Als je TortoiseGit gebruikt, kun je de functie Combine to one commit:

Contextmenu TortoiseGit openen
Selecteer Show Log
Markeer de relevante commits in de logweergave
Selecteer Combine to one commit in het contextmenu

Deze functie voert automatisch alle noodzakelijke enkele git-stappen uit.
Helaas alleen beschikbaar voor Windows.

Antwoord 10, autoriteit 2%

Gebaseerd op dit artikel Ik vond deze methode gemakkelijker voor mijn gebruik.

Mijn ‘dev’ branch liep 96 commits voor op ‘origin/dev’ (dus deze commits zijn nog niet naar de remote gepusht).

Ik wilde deze commits samenpersen in één voordat ik de wijziging doorzette. Ik geef er de voorkeur aan om de branch te resetten naar de staat van ‘origin/dev’ (hierdoor blijven alle wijzigingen van de 96 commits niet gestaged) en commit de wijzigingen dan in één keer:

git reset origin/dev
git add --all
git commit -m 'my commit message'

Antwoord 11, autoriteit 2%

In de branch waar je de commits wilt combineren, voer je uit:

git rebase -i HEAD~(n number of commits back to review)

voorbeeld:

git rebase -i HEAD~1

Dit zal de teksteditor openen en je moet de ‘pick’ voor elke commit verwisselen met ‘squash’ als je wilt dat deze commits worden samengevoegd. Uit documentatie:

p, pick = gebruik commit

s, squash = gebruik commit, maar meld je aan bij vorige commit

Als je bijvoorbeeld alle commits in één wilt samenvoegen, is de ‘pick’ de eerste commit die je hebt gemaakt en alle toekomstige (onder de eerste geplaatst) moeten worden ingesteld op ‘squash’. Als je vim gebruikt, gebruik dan 😡 in de invoegmodus om op te slaan en de editor af te sluiten.

Om vervolgens door te gaan met de rebase:

git rebase --continue

Voor meer informatie over deze en andere manieren om je commit-geschiedenis te herschrijven, zie dit nuttige bericht

Antwoord 12, autoriteit 2%

Anomies antwoord is goed, maar ik voelde me hier onzeker over, dus besloot ik een paar screenshots toe te voegen.

Stap 0: git log

Zie waar je bent met git log. Het belangrijkste is dat je de commit-hash vindt van de eerste commit die je niet wilt pletten. Dus alleen de :

Stap 1: git rebase

Voer git rebase -i [your hash], in mijn geval:

$ git rebase -i 2d23ea524936e612fae1ac63c95b705db44d937d

Stap 2: kies / plet wat je wilt

In mijn geval wil ik alles platleggen op de commit die als eerste op tijd was. De volgorde is van de eerste naar de laatste, dus precies andersom als in git log. In mijn geval wil ik:

Stap 3: Bericht(en) aanpassen

Als je maar één commit hebt gekozen en de rest hebt geplet, kun je één commit-bericht aanpassen:

Dat is het. Als je dit eenmaal hebt opgeslagen (:wq), ben je klaar. Bekijk het eens met git log.

Antwoord 13

Procedure 1

1) Identificeer de korte hash van de commit

# git log --pretty=oneline --abbrev-commit
abcd1234 Update to Fix for issue B
cdababcd Fix issue B
deab3412 Fix issue A
....

Hier kan zelfs git log --oneline ook worden gebruikt om korte hash te krijgen.

2) Als je de laatste twee commit wilt pletten (samenvoegen)

# git rebase -i deab3412

3) Dit opent een nano-editor voor het samenvoegen. En het ziet er als volgt uit

....
pick cdababcd Fix issue B
pick abcd1234 Update to Fix for issue B
....

4) Hernoem het woord pick naar squash dat vóór abcd1234 staat. Na het hernoemen zou het moeten zijn zoals hieronder.

....
pick cdababcd Fix issue B
squash abcd1234 Update to Fix for issue B
....

5) Sla nu de nano-editor op en sluit deze. Druk op ctrl + o en druk op Enter om op te slaan. En druk vervolgens op ctrl + x om de editor te verlaten.

6) Vervolgens wordt de nano-editor opnieuw geopend voor het bijwerken van opmerkingen, indien nodig bijwerken.

7) Het is nu succesvol geplet, je kunt het verifiëren door de logs te controleren.

# git log --pretty=oneline --abbrev-commit
1122abcd Fix issue B
deab3412 Fix issue A
....

8) Druk nu naar repo. Opmerking om het teken + toe te voegen voor de filiaalnaam. Dit betekent geforceerd duwen.

# git push origin +master

Opmerking: dit is gebaseerd op het gebruik van git op de ubuntu-shell. Als je verschillende besturingssystemen gebruikt (Windows of Mac) dan zijn bovenstaande commando’s hetzelfde, behalve editor. Mogelijk krijgt u een andere editor.

Procedure 2

Voeg eerst de vereiste bestanden toe voor vastlegging

git add <files>

Bevestig vervolgens met de optie --fixup en de OLDCOMMIT zou moeten zijn waarop we deze vastlegging moeten samenvoegen (squash).

git commit --fixup=OLDCOMMIT

Dit creëert nu een nieuwe commit bovenop HEAD met fixup1 <OLDCOMMIT_MSG>.

Voer vervolgens het onderstaande commando uit om de nieuwe commit samen te voegen (squash) naar de OLDCOMMIT.

git rebase --interactive --autosquash OLDCOMMIT^

Hier betekent ^ de vorige commit aan OLDCOMMIT. Deze opdracht rebase opent een interactief venster op een editor (vim of nano) daarop
we hoeven niets te doen, gewoon opslaan en afsluiten is voldoende. Omdat de optie die hieraan wordt doorgegeven automatisch de nieuwste
commit to naast oude commit en verander de operatie in fixup (gelijk aan squash). Daarna gaat rebase verder en eindigt.

Procedure 3

Als het nodig is om nieuwe wijzigingen aan de laatste vastlegging toe te voegen, kan --amend worden gebruikt met git-commit.

    # git log --pretty=oneline --abbrev-commit
    cdababcd Fix issue B
    deab3412 Fix issue A
    ....
    # git add <files> # New changes
    # git commit --amend
    # git log --pretty=oneline --abbrev-commit
    1d4ab2e1 Fix issue B
    deab3412 Fix issue A
    ....

Hier voegt --amend de nieuwe wijzigingen samen tot de laatste commit cdababcd en genereert een nieuwe commit ID 1d4ab2e1

Conclusie

Voordeel van de eerste procedure is om meerdere commits te pletten en opnieuw te ordenen. Maar deze procedure zal moeilijk zijn als we een fix moeten samenvoegen met een heel oude commit.
Dus de 2e procedure helpt om de commit gemakkelijk samen te voegen met een zeer oude commit.
En de 3e procedure is handig in een geval om een nieuwe wijziging te pletten voor de laatste commit.

Antwoord 14

Als je op een remote branch zit (genaamd feature-branch) gekloond van een Golden Repository(golden_repo_name), dan is hier de techniek om je commits in één te pletten:

Bekijk de gouden repo
```
git checkout golden_repo_name
```
Maak er als volgt een nieuwe branch van (golden repo)
```
git checkout -b dev-branch
```
Squash merge met je lokale branch die je al hebt
```
git merge --squash feature-branch
```
Maak je wijzigingen door (dit is de enige commit die in dev-branch gaat)
```
git commit -m "My feature complete"
```
Push de branch naar uw lokale repository
```
git push origin dev-branch
```

Antwoord 15

Ik denk dat de gemakkelijkste manier om dit te doen is door een nieuwe branch te maken op basis van master en een merge --squash van de feature branch te doen.

git checkout master
git checkout -b feature_branch_squashed
git merge --squash feature_branch

Dan heb je alle wijzigingen klaar om vast te leggen.

Antwoord 16

Als je bijvoorbeeld de laatste 3 commits wilt pletten naar een enkele commit in een branch (remote repository) in bijvoorbeeld: https ://bitbucket.org

Wat ik deed is

git reset --soft HEAD~3
git commit
git push origin <branch_name> --force

Antwoord 17

Om de laatste 10 commits in 1 enkele commit te pletten:

git reset --soft HEAD~10 && git commit -m "squashed commit"

Als je ook de remote branch wilt updaten met de geplette commit:

git push -f

Antwoord 18

Hier is nog een visueel voorbeeld van wat er zou volgen na het uitvoeren:
git rebase -i HEAD~3

Bron: https://www.git-tower.com /learn/git/faq/git-squash/

Antwoord 19

Wat echt handig kan zijn:
Zoek de commit-hash die je wilt squashen, zeg d43e15.

Gebruik nu

git reset d43e15
git commit -am 'new commit name'

Antwoord 20

Als je elke commit in een enkele commit wilt squish (bijvoorbeeld wanneer je een project voor de eerste keer publiekelijk vrijgeeft), probeer dan:

git checkout --orphan <new-branch>
git commit

Antwoord 21

Eenvoudige one-liner die altijd werkt, aangezien je je momenteel in de branch bevindt die je wilt squashen, master de branch is waar het vandaan komt, en de laatste commit het commit-bericht en de auteur bevat die je wilt gebruiken:

git reset --soft $(git merge-base HEAD master) && git commit --reuse-message=HEAD@{1}

Antwoord 22

Dit is super-duper kludgy, maar op een soort coole manier, dus ik gooi het gewoon in de ring:

GIT_EDITOR='f() { if [ "$(basename $1)" = "git-rebase-todo" ]; then sed -i "2,\$s/pick/squash/" $1; else vim $1; fi }; f' git rebase -i foo~5 foo

Vertaling: geef een nieuwe “editor” voor git die, als de te bewerken bestandsnaam git-rebase-todo is (de interactieve rebase-prompt), alles behalve de eerste “pick” verandert in ” squash”, en anders vim spawnt – zodat wanneer je wordt gevraagd om het geplette commit-bericht te bewerken, je vim krijgt. (En natuurlijk was ik de laatste vijf commits op branch foo aan het pletten, maar je kunt dat veranderen zoals je wilt.)

Ik zou waarschijnlijk doen wat Mark Longair stelde echter voor.

Antwoord 23

?? WAARSCHUWING: “Mijn laatste X commits” kan dubbelzinnig zijn.

  (MASTER)  
Fleetwood Mac            Fritz
      ¦                    ¦
  Add Danny  Lindsey     Stevie       
    Kirwan  Buckingham    Nicks                                              
      ¦         L===T======-     
Add Christine       ¦          
   Perfect      Buckingham
      ¦           Nicks            
    LA1974==========-                                    
      ¦                  
      ¦                  
    Bill <====== YOU ARE EDITING HERE
  Clinton        (CHECKED OUT, CURRENT WORKING DIRECTORY)

In deze zeer verkorte geschiedenis van de https://github.com/fleetwood-mac/band-history repository u een pull-verzoek hebt geopend om de Bill Clinton-commit in het origineel samen te voegen (MASTER) Fleetwood Mac commit.

Je hebt een pull-verzoek geopend en op GitHub zie je dit:

Vier toezeggingen:

Danny Kirwan toevoegen
Christine Perfect toevoegen
LA1974
Bill Clinton

In de veronderstelling dat niemand ooit de volledige geschiedenis van de repository zou willen lezen. (Er is eigenlijk een repository, klik op de link hierboven!) Je besluit deze commits te pletten. Dus je gaat en voert git reset --soft HEAD~4 && git commit. Dan git push --force het op GitHub om je PR op te schonen.

En wat gebeurt er? Je hebt zojuist een enkele toezegging gedaan die van Fritz naar Bill Clinton gaat. Omdat je vergeten was dat je gisteren aan de Buckingham Nicks-versie van dit project werkte. En git log komt niet overeen met wat je op GitHub ziet.

?? MORAAL VAN HET VERHAAL

Vind de exacte bestanden die je naar wilt hebben, en git checkout ze
Vind de exacte eerdere commit die je in de geschiedenis wilt bewaren, en git reset --soft die
Maak een git commit die direct vervormt van de van naar de naar

Antwoord 24

Als je niet geïnteresseerd bent in de commit-berichten van de tussenliggende commits, kun je

gebruiken

git reset --mixed <commit-hash-into-which-you-want-to-squash>
git commit -a --amend

Antwoord 25

Als je met GitLab werkt, kun je gewoon op de optie Squash klikken in het Merge Request, zoals hieronder wordt weergegeven. Het commit-bericht zal de titel zijn van het Merge Request.

Antwoord 26

Veel antwoorden zijn gebaseerd op het git rebase-commando, maar in mijn ervaring is het enigszins complex en geavanceerd voor git-beginners.

Stel dat je de laatste 3 commits wilt squishen. Daarna volgen de stappen:

Noteer huidige commit id: Gebruik git log -1 --oneline en noteer de commit-id van de huidige status (voor het geval je iets verkeerd doet met git reset)
Ga 3 commits terug: Met git reset --soft HEAD~3 ga je 3 commits terug (en vergeet je een beetje dat je deze hebt gemaakt drie commits eerder)
Voer een nieuwe commit uit: doe nu gewoon git commit -m <NEW_SINGLE_MESSAGE> waarmee automatisch de drie commits onder je bericht worden gecombineerd

In het geval dat er iets misgaat met git reset, kun je weer terugkeren naar de oorspronkelijke staat door git reset --soft <ORIGINAL_COMMIT>

Antwoord 27

Hoe zit het met een antwoord op de vraag met betrekking tot een workflow als deze?

veel lokale commits, gemengd met meerdere merges FROM master,
eindelijk een push naar remote,
PR en samenvoegen TO master door recensent.
(Ja, het zou voor de ontwikkelaar gemakkelijker zijn om na de PR te merge --squash, maar het team dacht dat dit het proces zou vertragen.)

Zo’n workflow heb ik op deze pagina nog niet gezien. (Dat kunnen mijn ogen zijn.) Als ik rebase goed begrijp, zouden meerdere samenvoegingen meerdere conflictoplossingen vereisen. Daar wil ik niet eens aan denken!

Dus dit lijkt voor ons te werken.

git pull master
git checkout -b new-branch
git checkout -b new-branch-temp
bewerk en commit veel lokaal, voeg master regelmatig samen
git checkout new-branch
git merge --squash new-branch-temp // zet alle wijzigingen in stage
git commit 'one message to rule them all'
git push
Reviewer doet PR en fuseert tot master.

Antwoord 28

Ik vind dat een meer generieke oplossing is om geen ‘N’-commits te specificeren, maar eerder de branch/commit-id waar je bovenop wilt pletten. Dit is minder foutgevoelig dan het tellen van de commits tot een specifieke commit—geef gewoon de tag rechtstreeks op, of als je echt wilt tellen, kun je HEAD~N specificeren.

In mijn workflow start ik een branch, en mijn eerste commit op die branch vat het doel samen (dat wil zeggen, het is meestal wat ik zal pushen als het ‘laatste’ bericht voor de functie naar de openbare repository.) klaar, alles wat ik wil doen is git squash master terug naar het eerste bericht en dan ben ik klaar om te pushen.

Ik gebruik de alias:

squash = !EDITOR="\"_() { sed -n 's/^pick //p' \"\\$1\"; sed -i .tmp '2,\\$s/^pick/f/' \"\\$1\"; }; _\"" git rebase -i

Hiermee wordt de geschiedenis die wordt geplet, gedumpt voordat dit gebeurt. Dit geeft je de kans om te herstellen door een oude commit-ID van de console te halen als je wilt terugkeren. (Solaris-gebruikers merken op dat het de GNU sed -i-optie gebruikt, Mac- en Linux-gebruikers zouden hiermee in orde moeten zijn.)

Antwoord 29

git rebase -i HEAD^^

waar het aantal ^-en X is

(in dit geval, verpletter de laatste twee commits)

Antwoord 30

Naast andere uitstekende antwoorden, zou ik willen toevoegen hoe git rebase -i me altijd verwart met de commit-volgorde – ouder naar nieuwer of vice versa? Dit is dus mijn workflow:

git rebase -i HEAD~[N] , waarbij N het aantal commits is waaraan ik wil deelnemen, vanaf de meest recente. Dus git rebase -i HEAD~5 zou betekenen “squash de laatste 5 commits in een nieuwe”;
de editor verschijnt en toont de lijst met commits die ik wil samenvoegen. Nu worden ze weergegeven in omgekeerde volgorde: de oudere commit staat bovenaan. Markeer als “squash” of “s” alle commits daar behalve de eerste/oudere: het zal als startpunt worden gebruikt. Bewaar en sluit de editor;
de editor verschijnt weer met een standaardbericht voor de nieuwe vastlegging: verander het naar uw behoeften, sla op en sluit. Squash voltooid!

Bronnen & extra gelezen: #1, #2.

Squash mijn laatste X commits samen met Git