Ryd op i din Git-historik med Squash

At vedligeholde en ren og koncis commit-historik er afgørende for læsbarhed og samarbejde i ethvert softwareprojekt. En kraftfuld teknik til at opnå dette er Git squash. Squashing giver dig mulighed for at kombinere flere commits til en enkelt, samlet commit, hvilket gør dit projekts historik enklere og lettere at følge. I denne artikel vil vi dykke ned i, hvad Git squash er, hvilke fordele det giver, og hvordan du kan bruge det effektivt i dit daglige arbejde.

Hvad er Git Squash?

Git squash er processen, hvor man tager en række af commits og fletter dem sammen til én enkelt commit. Denne teknik er især nyttig, når en feature-gren har talrige små, inkrementelle commits, som kan rode i den samlede historik. Ved at 'squashe' disse commits kan du præsentere en mere poleret og sammenhængende historik for dine samarbejdspartnere. Forestil dig, at du har arbejdet på en ny funktion og har lavet 10 små commits som "fix typo", "add variable" og "refactor small function". I stedet for at disse 10 små ændringer fylder i master-grenens historik, kan du kombinere dem til én enkelt commit med en beskrivende besked som "Implement new user authentication feature". Dette gør det markant lettere for andre at forstå, hvad der er sket.

Hvornår bør man bruge Squash?

For at illustrere et godt tidspunkt at bruge squash, lad os forestille os et scenarie. Vi har et repository kaldet GFG_VIDEO, et open-source videokonferenceværktøj. GFG_VIDEO har udgivet den første version af deres værktøj med grundlæggende funktioner som peer-to-peer videoopkald og beskeder, tagget som R_V1.

Efter R_V1-udgivelsen begyndte teamet at tilføje nye funktioner såsom oprettelse af grupper, gruppevideoopkald og rettelse af mindre fejl fra R_V1, f.eks. opkaldsafbrydelser. Nu er GFG_VIDEO klar til deres nye udgivelse, R_V2.

Hvis vi kigger på historikken, har vi tre commits fra vores oprindelige commit til R_V1 (1. udgivelse). Efter R_V1 har vi yderligere tre commits til R_V2 (2. udgivelse). Historikken ser en smule rodet og svær at følge ud. Her kan vi bruge squash-konceptet og flette alle commits efter R_V1 frem til R_V2 sammen til en enkelt commit. Dette gør vores repository-log mere ryddelig og let at følge.

Sådan bruger du Squash: To Effektive Metoder

Der er primært to måder at udføre en squash-operation på i Git: via interaktiv rebase eller ved at bruge --squash-optionen under en merge. Begge metoder har deres fordele og er nyttige i forskellige situationer.

Metode 1: Interaktiv Rebase (`git rebase -i`)

Den mest almindelige og fleksible måde at squashe commits på er ved hjælp af interaktiv rebase. Denne metode giver dig fuld kontrol over, hvilke commits der skal kombineres.

Lad os sige, at vi vil squashe de sidste 3 commits i vores GFG_VIDEO-projekt. Vi bruger følgende kommando:

git rebase -i HEAD~3

Bemærk: Rebase er en handling, der omskriver commits og deres historik. Flagget "-i" står for "interaktiv tilstand". `HEAD~3` angiver, at vi vil udføre vores operation på de sidste 3 commits fra HEAD (den aktuelle commit).

Når du udfører denne kommando, åbnes en interaktiv editor med en liste over de valgte commits. Det vil se nogenlunde sådan ud:

pick a1b2c3d Add group creation feature pick e4f5g6h Implement group video calls pick i7j8k9l Fix call drop bug from R_V1 # Commands: # p, pick = use commit # r, reword = use commit, but edit the commit message # e, edit = use commit, but stop for amending # s, squash = use commit, but meld into previous commit # ...

For at kombinere den anden og tredje commit med den første, skal vi ændre ordet `pick` til `squash` (eller blot `s`) for de commits, vi vil smelte sammen med den foregående. Vores fil skal se således ud:

pick a1b2c3d Add group creation feature squash e4f5g6h Implement group video calls squash i7j8k9l Fix call drop bug from R_V1

Efter at have gemt og lukket filen, åbnes en ny editor med det samme. Her skal du skrive den nye, samlede commit-besked. Git vil inkludere beskederne fra alle de squashede commits, som du kan redigere eller erstatte med en ny, klar og dækkende besked.

# This is a combination of 3 commits. # The first line is the new commit message: Implement group features and fix bugs for R_V2 # This is the 1st commit message: # Add group creation feature # This is the 2nd commit message: # Implement group video calls # This is the 3rd commit message: # Fix call drop bug from R_V1

Indtast den nye commit-besked, gem og luk filen. Git vil nu udføre rebasen, og du vil se en succesmeddelelse. Hvis du nu tjekker din `git log`, vil du se, at dine tre commits er blevet erstattet af én enkelt, ren commit. Din historik er nu meget mere læsbar.

Metode 2: Merge med `--squash` optionen

En anden metode er at bruge `--squash`-flagget, når du merger en feature-gren ind i din hovedgren (f.eks. `main` eller `develop`). Denne metode tager alle commits fra feature-grenen, kombinerer dem til et enkelt sæt ændringer og iscenesætter dem i din nuværende gren. Derefter kan du lave en enkelt ny commit.

Følg disse trin:

1. Skift til din mål-gren: Sørg for, at du er på den gren, du vil merge ind i (f.eks. `main`).
   git checkout main
2. Kør merge-kommandoen med --squash: Angiv den feature-gren, du vil merge.
   git merge --squash feature-branch
3. Commit ændringerne: Git vil ikke automatisk oprette en commit. I stedet vil alle ændringerne fra `feature-branch` blive iscenesat. Du skal nu selv oprette en commit med en passende besked.
   git commit -m "Implement new feature from feature-branch"
4. Push ændringerne: Skub den nye commit til dit remote repository.
   git push origin main

Fordelen ved denne metode er, at den holder historikken på `main`-grenen ekstremt ren, da hele feature-grenens detaljerede historik er skjult i en enkelt merge-commit.

Git Squash vs. Rebase: En Sammenligning

Selvom squash ofte udføres via interaktiv rebase, er det vigtigt at forstå forskellen mellem squash som koncept og rebase som en bredere operation.

Ofte Stillede Spørgsmål (OSS)

Er det sikkert at bruge squash på en delt gren?

Nej, det er generelt en dårlig idé. At squashe commits omskriver Git-historikken. Hvis du squasher commits, der allerede er blevet pushet og trukket ned af andre udviklere, vil deres lokale historik afvige fra den nye, omskrevne historik. Dette fører til komplekse og forvirrende merge-konflikter. Brug kun squash på din egen lokale feature-gren, før du merger den ind i en delt gren.

Hvad sker der med de originale commits efter en squash?

De originale commits bliver ikke en del af grenens direkte historik længere. De bliver til såkaldte 'dangling commits'. Git fjerner dem ikke med det samme, men de vil efterhånden blive slettet af Gits 'garbage collector'. Du kan i en periode finde dem igen ved hjælp af `git reflog`, hvis du har brug for at fortryde din handling.

Kan jeg fortryde en squash-operation?

Ja. Git holder en log over alle de steder, HEAD har peget. Denne log kaldes `reflog`. Ved at køre `git reflog` kan du finde commit-hashen fra før, du udførte din rebase/squash. Du kan derefter nulstille din gren til den tidligere tilstand ved hjælp af `git reset --hard `. Vær dog meget forsigtig, når du bruger `git reset --hard`, da det kan medføre tab af arbejde, der ikke er committet.

Konklusion

Git squash er et utroligt værdifuldt værktøj i en udviklers arsenal. Ved at kombinere små, midlertidige commits til en enkelt, logisk enhed kan du skabe en meget renere, mere meningsfuld og lettere navigerbar projekthistorik. Uanset om du bruger interaktiv rebase for finmasket kontrol eller `--squash` for en simpel merge-proces, er resultatet en forbedret samarbejdsproces og en sundere codebase. Husk blot at bruge det ansvarligt og undgå at omskrive historikken på delte grene for at sikre et problemfrit samarbejde med dit team.